also add EnumMember and Struct to SymbolKind, #2628

src/vs/workbench/api/node/extHost.protocol.ts

@@ -34,7 +34,6 @@ import { IWorkspaceConfigurationValues } from 'vs/workbench/services/configurati
 
 import { IPickOpenEntry, IPickOptions } from 'vs/platform/quickOpen/common/quickOpen';
 import { SaveReason } from 'vs/workbench/services/textfile/common/textfiles';
-import { IWorkspaceSymbol } from 'vs/workbench/parts/search/common/search';
 import { IApplyEditsOptions, IUndoStopOptions, TextEditorRevealType, ITextEditorConfigurationUpdate, IResolvedTextEditorConfiguration, ISelectionChangeEvent } from './mainThreadEditor';
 
 import { InternalTreeExplorerNodeContent } from 'vs/workbench/parts/explorers/common/treeExplorerViewModel';
@@ -383,8 +382,8 @@ export abstract class ExtHostLanguageFeaturesShape {
 	$provideDocumentFormattingEdits(handle: number, resource: URI, options: modes.FormattingOptions): TPromise<editorCommon.ISingleEditOperation[]> { throw ni(); }
 	$provideDocumentRangeFormattingEdits(handle: number, resource: URI, range: editorCommon.IRange, options: modes.FormattingOptions): TPromise<editorCommon.ISingleEditOperation[]> { throw ni(); }
 	$provideOnTypeFormattingEdits(handle: number, resource: URI, position: editorCommon.IPosition, ch: string, options: modes.FormattingOptions): TPromise<editorCommon.ISingleEditOperation[]> { throw ni(); }
-	$provideWorkspaceSymbols(handle: number, search: string): TPromise<IWorkspaceSymbol[]> { throw ni(); }
-	$resolveWorkspaceSymbol(handle: number, symbol: IWorkspaceSymbol): TPromise<IWorkspaceSymbol> { throw ni(); }
+	$provideWorkspaceSymbols(handle: number, search: string): TPromise<modes.SymbolInformation[]> { throw ni(); }
+	$resolveWorkspaceSymbol(handle: number, symbol: modes.SymbolInformation): TPromise<modes.SymbolInformation> { throw ni(); }
 	$provideRenameEdits(handle: number, resource: URI, position: editorCommon.IPosition, newName: string): TPromise<modes.WorkspaceEdit> { throw ni(); }
 	$provideCompletionItems(handle: number, resource: URI, position: editorCommon.IPosition): TPromise<modes.ISuggestResult> { throw ni(); }
 	$resolveCompletionItem(handle: number, resource: URI, position: editorCommon.IPosition, suggestion: modes.ISuggestion): TPromise<modes.ISuggestion> { throw ni(); }

src/vs/workbench/api/node/extHostApiCommands.ts

@@ -15,7 +15,7 @@ import * as modes from 'vs/editor/common/modes';
 import { ICommandHandlerDescription } from 'vs/platform/commands/common/commands';
 import { ExtHostCommands } from 'vs/workbench/api/node/extHostCommands';
 import { IOutline } from 'vs/editor/contrib/quickOpen/common/quickOpen';
-import { IWorkspaceSymbolProvider, IWorkspaceSymbol } from 'vs/workbench/parts/search/common/search';
+import { IWorkspaceSymbolProvider } from 'vs/workbench/parts/search/common/search';
 import { ICodeLensData } from 'vs/editor/contrib/codelens/common/codelens';
 
 export class ExtHostApiCommands {
@@ -239,7 +239,7 @@ export class ExtHostApiCommands {
 	 * @return A promise that resolves to an array of symbol information.
 	 */
 	private _executeWorkspaceSymbolProvider(query: string): Thenable<types.SymbolInformation[]> {
-		return this._commands.executeCommand<[IWorkspaceSymbolProvider, IWorkspaceSymbol[]][]>('_executeWorkspaceSymbolProvider', { query }).then(value => {
+		return this._commands.executeCommand<[IWorkspaceSymbolProvider, modes.SymbolInformation[]][]>('_executeWorkspaceSymbolProvider', { query }).then(value => {
 			const result: types.SymbolInformation[] = [];
 			if (Array.isArray(value)) {
 				for (let tuple of value) {
@@ -371,7 +371,7 @@ export class ExtHostApiCommands {
 		};
 		return this._commands.executeCommand<IOutline>('_executeDocumentSymbolProvider', args).then(value => {
 			if (value && Array.isArray(value.entries)) {
-				return value.entries.map(typeConverters.SymbolInformation.fromOutlineEntry);
+				return value.entries.map(typeConverters.toSymbolInformation);
 			}
 			return undefined;
 		});

src/vs/workbench/api/node/extHostLanguageFeatures.ts

@@ -17,7 +17,7 @@ import { ExtHostHeapService } from 'vs/workbench/api/node/extHostHeapService';
 import { ExtHostDocuments } from 'vs/workbench/api/node/extHostDocuments';
 import { ExtHostCommands, CommandsConverter } from 'vs/workbench/api/node/extHostCommands';
 import { ExtHostDiagnostics } from 'vs/workbench/api/node/extHostDiagnostics';
-import { IWorkspaceSymbolProvider, IWorkspaceSymbol } from 'vs/workbench/parts/search/common/search';
+import { IWorkspaceSymbolProvider } from 'vs/workbench/parts/search/common/search';
 import { asWinJsPromise } from 'vs/base/common/async';
 import { MainContext, MainThreadLanguageFeaturesShape, ExtHostLanguageFeaturesShape, ObjectIdentifier } from './extHost.protocol';
 import { regExpLeadsToEndlessLoop } from 'vs/base/common/strings';
@@ -38,7 +38,7 @@ class OutlineAdapter {
 		let doc = this._documents.getDocumentData(resource).document;
 		return asWinJsPromise(token => this._provider.provideDocumentSymbols(doc, token)).then(value => {
 			if (Array.isArray(value)) {
-				return value.map(TypeConverters.SymbolInformation.toOutlineEntry);
+				return value.map(TypeConverters.fromSymbolInformation);
 			}
 			return undefined;
 		});
@@ -311,7 +311,7 @@ class DocumentFormattingAdapter {
 
 	provideDocumentFormattingEdits(resource: URI, options: modes.FormattingOptions): TPromise<ISingleEditOperation[]> {
 
-		const {document} = this._documents.getDocumentData(resource);
+		const { document } = this._documents.getDocumentData(resource);
 
 		return asWinJsPromise(token => this._provider.provideDocumentFormattingEdits(document, <any>options, token)).then(value => {
 			if (Array.isArray(value)) {
@@ -334,7 +334,7 @@ class RangeFormattingAdapter {
 
 	provideDocumentRangeFormattingEdits(resource: URI, range: IRange, options: modes.FormattingOptions): TPromise<ISingleEditOperation[]> {
 
-		const {document} = this._documents.getDocumentData(resource);
+		const { document } = this._documents.getDocumentData(resource);
 		const ran = TypeConverters.toRange(range);
 
 		return asWinJsPromise(token => this._provider.provideDocumentRangeFormattingEdits(document, ran, <any>options, token)).then(value => {
@@ -360,7 +360,7 @@ class OnTypeFormattingAdapter {
 
 	provideOnTypeFormattingEdits(resource: URI, position: IPosition, ch: string, options: modes.FormattingOptions): TPromise<ISingleEditOperation[]> {
 
-		const {document} = this._documents.getDocumentData(resource);
+		const { document } = this._documents.getDocumentData(resource);
 		const pos = TypeConverters.toPosition(position);
 
 		return asWinJsPromise(token => this._provider.provideOnTypeFormattingEdits(document, pos, ch, <any>options, token)).then(value => {
@@ -383,7 +383,7 @@ class NavigateTypeAdapter implements IWorkspaceSymbolProvider {
 		this._heapService = heapService;
 	}
 
-	provideWorkspaceSymbols(search: string): TPromise<IWorkspaceSymbol[]> {
+	provideWorkspaceSymbols(search: string): TPromise<modes.SymbolInformation[]> {
 
 		return asWinJsPromise(token => this._provider.provideWorkspaceSymbols(search, token)).then(value => {
 			if (Array.isArray(value)) {
@@ -397,7 +397,7 @@ class NavigateTypeAdapter implements IWorkspaceSymbolProvider {
 		});
 	}
 
-	resolveWorkspaceSymbol(item: IWorkspaceSymbol): TPromise<IWorkspaceSymbol> {
+	resolveWorkspaceSymbol(item: modes.SymbolInformation): TPromise<modes.SymbolInformation> {
 
 		if (typeof this._provider.resolveWorkspaceSymbol !== 'function') {
 			return TPromise.as(item);
@@ -889,11 +889,11 @@ export class ExtHostLanguageFeatures extends ExtHostLanguageFeaturesShape {
 		return this._createDisposable(handle);
 	}
 
-	$provideWorkspaceSymbols(handle: number, search: string): TPromise<IWorkspaceSymbol[]> {
+	$provideWorkspaceSymbols(handle: number, search: string): TPromise<modes.SymbolInformation[]> {
 		return this._withAdapter(handle, NavigateTypeAdapter, adapter => adapter.provideWorkspaceSymbols(search));
 	}
 
-	$resolveWorkspaceSymbol(handle: number, symbol: IWorkspaceSymbol): TPromise<IWorkspaceSymbol> {
+	$resolveWorkspaceSymbol(handle: number, symbol: modes.SymbolInformation): TPromise<modes.SymbolInformation> {
 		return this._withAdapter(handle, NavigateTypeAdapter, adapter => adapter.resolveWorkspaceSymbol(symbol));
 	}
 
@@ -960,7 +960,7 @@ export class ExtHostLanguageFeatures extends ExtHostLanguageFeaturesShape {
 	// --- configuration
 
 	setLanguageConfiguration(languageId: string, configuration: vscode.LanguageConfiguration): vscode.Disposable {
-		let {wordPattern} = configuration;
+		let { wordPattern } = configuration;
 
 		// check for a valid word pattern
 		if (wordPattern && regExpLeadsToEndlessLoop(wordPattern)) {

src/vs/workbench/api/node/extHostTypeConverters.ts

@@ -9,7 +9,6 @@ import * as modes from 'vs/editor/common/modes';
 import * as types from './extHostTypes';
 import { Position as EditorPosition } from 'vs/platform/editor/common/editor';
 import { IPosition, ISelection, IRange, IDecorationOptions, ISingleEditOperation } from 'vs/editor/common/editorCommon';
-import { IWorkspaceSymbol } from 'vs/workbench/parts/search/common/search';
 import * as vscode from 'vscode';
 import URI from 'vs/base/common/uri';
 import { SaveReason } from 'vs/workbench/services/textfile/common/textfiles';
@@ -165,46 +164,63 @@ export const TextEdit = {
 	}
 };
 
-export namespace SymbolInformation {
 
-	export function fromOutlineEntry(entry: modes.SymbolInformation): types.SymbolInformation {
-		return new types.SymbolInformation(
-			entry.name,
-			entry.kind,
-			toRange(entry.location.range),
-			entry.location.uri,
-			entry.containerName
-		);
+export namespace SymbolKind {
+
+	const _fromMapping: { [kind: number]: modes.SymbolKind } = Object.create(null);
+	_fromMapping[types.SymbolKind.File] = 'file';
+	_fromMapping[types.SymbolKind.Module] = 'module';
+	_fromMapping[types.SymbolKind.Namespace] = 'namespace';
+	_fromMapping[types.SymbolKind.Package] = 'package';
+	_fromMapping[types.SymbolKind.Class] = 'class';
+	_fromMapping[types.SymbolKind.Method] = 'method';
+	_fromMapping[types.SymbolKind.Property] = 'property';
+	_fromMapping[types.SymbolKind.Field] = 'field';
+	_fromMapping[types.SymbolKind.Constructor] = 'constructor';
+	_fromMapping[types.SymbolKind.Enum] = 'enum';
+	_fromMapping[types.SymbolKind.Interface] = 'interface';
+	_fromMapping[types.SymbolKind.Function] = 'function';
+	_fromMapping[types.SymbolKind.Variable] = 'variable';
+	_fromMapping[types.SymbolKind.Constant] = 'constant';
+	_fromMapping[types.SymbolKind.String] = 'string';
+	_fromMapping[types.SymbolKind.Number] = 'number';
+	_fromMapping[types.SymbolKind.Boolean] = 'boolean';
+	_fromMapping[types.SymbolKind.Array] = 'array';
+	_fromMapping[types.SymbolKind.Object] = 'object';
+	_fromMapping[types.SymbolKind.Key] = 'key';
+	_fromMapping[types.SymbolKind.Null] = 'null';
+	_fromMapping[types.SymbolKind.EnumMember] = 'enum-member';
+	_fromMapping[types.SymbolKind.Struct] = 'struct';
+
+	export function from(kind: vscode.SymbolKind): modes.SymbolKind {
+		return _fromMapping[kind] || 'property';
 	}
 
-	export function toOutlineEntry(symbol: vscode.SymbolInformation): modes.SymbolInformation {
-		return <modes.SymbolInformation>{
-			name: symbol.name,
-			kind: symbol.kind,
-			containerName: symbol.containerName,
-			location: {
-				uri: <URI>symbol.location.uri,
-				range: fromRange(symbol.location.range)
+	export function to(kind: modes.SymbolKind): vscode.SymbolKind {
+		for (let k in _fromMapping) {
+			if (_fromMapping[k] === kind) {
+				return Number(k);
 			}
-		};
+		}
+		return types.SymbolKind.Property;
 	}
 }
 
-export function fromSymbolInformation(info: vscode.SymbolInformation): IWorkspaceSymbol {
-	return <IWorkspaceSymbol>{
+export function fromSymbolInformation(info: vscode.SymbolInformation): modes.SymbolInformation {
+	return <modes.SymbolInformation>{
 		name: info.name,
-		type: types.SymbolKind[info.kind || types.SymbolKind.Property].toLowerCase(),
+		kind: SymbolKind.from(info.kind),
 		containerName: info.containerName,
-		range: info.location && fromRange(info.location.range),
-		resource: info.location && info.location.uri,
+		location: location.from(info.location)
 	};
 }
 
-export function toSymbolInformation(bearing: IWorkspaceSymbol): types.SymbolInformation {
-	return new types.SymbolInformation(bearing.name,
-		types.SymbolKind[bearing.type.charAt(0).toUpperCase() + bearing.type.substr(1)],
+export function toSymbolInformation(bearing: modes.SymbolInformation): types.SymbolInformation {
+	return new types.SymbolInformation(
+		bearing.name,
+		SymbolKind.to(bearing.kind),
 		bearing.containerName,
-		new types.Location(bearing.resource, toRange(bearing.range))
+		location.to(bearing.location)
 	);
 }
 

src/vs/workbench/api/node/extHostTypes.ts

@@ -713,27 +713,29 @@ export class DocumentHighlight {
 }
 
 export enum SymbolKind {
-	File,
-	Module,
-	Namespace,
-	Package,
-	Class,
-	Method,
-	Property,
-	Field,
-	Constructor,
-	Enum,
-	Interface,
-	Function,
-	Variable,
-	Constant,
-	String,
-	Number,
-	Boolean,
-	Array,
-	Object,
-	Key,
-	Null
+	File = 0,
+	Module = 1,
+	Namespace = 2,
+	Package = 3,
+	Class = 4,
+	Method = 5,
+	Property = 6,
+	Field = 7,
+	Constructor = 8,
+	Enum = 9,
+	Interface = 10,
+	Function = 11,
+	Variable = 12,
+	Constant = 13,
+	String = 14,
+	Number = 15,
+	Boolean = 16,
+	Array = 17,
+	Object = 18,
+	Key = 19,
+	Null = 20,
+	EnumMember = 21,
+	Struct = 22
 }
 
 export class SymbolInformation {

src/vs/workbench/api/node/mainThreadLanguageFeatures.ts

@@ -11,7 +11,7 @@ import { IThreadService } from 'vs/workbench/services/thread/common/threadServic
 import * as vscode from 'vscode';
 import { IReadOnlyModel, ISingleEditOperation } from 'vs/editor/common/editorCommon';
 import * as modes from 'vs/editor/common/modes';
-import { WorkspaceSymbolProviderRegistry, IWorkspaceSymbolProvider, IWorkspaceSymbol } from 'vs/workbench/parts/search/common/search';
+import { WorkspaceSymbolProviderRegistry, IWorkspaceSymbolProvider } from 'vs/workbench/parts/search/common/search';
 import { wireCancellationToken } from 'vs/base/common/async';
 import { CancellationToken } from 'vs/base/common/cancellation';
 import { Position as EditorPosition } from 'vs/editor/common/core/position';
@@ -200,10 +200,10 @@ export class MainThreadLanguageFeatures extends MainThreadLanguageFeaturesShape
 
 	$registerNavigateTypeSupport(handle: number): TPromise<any> {
 		this._registrations[handle] = WorkspaceSymbolProviderRegistry.register(<IWorkspaceSymbolProvider>{
-			provideWorkspaceSymbols: (search: string): TPromise<IWorkspaceSymbol[]> => {
+			provideWorkspaceSymbols: (search: string): TPromise<modes.SymbolInformation[]> => {
 				return this._heapService.trackRecursive(this._proxy.$provideWorkspaceSymbols(handle, search));
 			},
-			resolveWorkspaceSymbol: (item: IWorkspaceSymbol): TPromise<IWorkspaceSymbol> => {
+			resolveWorkspaceSymbol: (item: modes.SymbolInformation): TPromise<modes.SymbolInformation> => {
 				return this._proxy.$resolveWorkspaceSymbol(handle, item);
 			}
 		});