explore Hierarchy<T> idea, #34968

extensions/typescript-language-features/src/features/documentSymbolProvider.ts

@@ -3,7 +3,7 @@
  *  Licensed under the MIT License. See License.txt in the project root for license information.
  *--------------------------------------------------------------------------------------------*/
 
-import { DocumentSymbolProvider, SymbolInformation, SymbolKind, TextDocument, CancellationToken, Uri, HierarchicalSymbolInformation } from 'vscode';
+import { DocumentSymbolProvider, SymbolInformation, SymbolKind, TextDocument, CancellationToken, Uri, Hierarchy, SymbolInformation2 } from 'vscode';
 
 import * as Proto from '../protocol';
 import * as PConst from '../protocol.const';
@@ -31,7 +31,7 @@ export default class TypeScriptDocumentSymbolProvider implements DocumentSymbolP
 	public constructor(
 		private readonly client: ITypeScriptServiceClient) { }
 
-	public async provideDocumentSymbols(resource: TextDocument, token: CancellationToken): Promise<any[]> { // todo@joh `any[]` temporary hack to make typescript happy...
+	public async provideDocumentSymbols(resource: TextDocument, token: CancellationToken): Promise<any> { // todo@joh `any[]` temporary hack to make typescript happy...
 		const filepath = this.client.normalizePath(resource.uri);
 		if (!filepath) {
 			return [];
@@ -41,24 +41,27 @@ export default class TypeScriptDocumentSymbolProvider implements DocumentSymbolP
 		};
 
 		try {
-			const result: SymbolInformation[] | HierarchicalSymbolInformation[] = [];
 			if (this.client.apiVersion.has206Features()) {
 				const response = await this.client.execute('navtree', args, token);
 				if (response.body) {
 					// The root represents the file. Ignore this when showing in the UI
 					let tree = response.body;
 					if (tree.childItems) {
-						tree.childItems.forEach(item => TypeScriptDocumentSymbolProvider.convertNavTree(resource.uri, result as HierarchicalSymbolInformation[], item));
+						let result = new Array<Hierarchy<SymbolInformation2>>();
+						tree.childItems.forEach(item => TypeScriptDocumentSymbolProvider.convertNavTree(resource.uri, result, item));
+						return result;
 					}
 				}
 			} else {
 				const response = await this.client.execute('navbar', args, token);
 				if (response.body) {
+					let result = new Array<SymbolInformation>();
 					let foldingMap: ObjectMap<SymbolInformation> = Object.create(null);
 					response.body.forEach(item => TypeScriptDocumentSymbolProvider.convertNavBar(resource.uri, 0, foldingMap, result as SymbolInformation[], item));
+					return result;
 				}
 			}
-			return result;
+			return [];
 		} catch (e) {
 			return [];
 		}
@@ -82,24 +85,25 @@ export default class TypeScriptDocumentSymbolProvider implements DocumentSymbolP
 		}
 	}
 
-	private static convertNavTree(resource: Uri, bucket: HierarchicalSymbolInformation[], item: Proto.NavigationTree): void {
-		const result = new HierarchicalSymbolInformation(
+	private static convertNavTree(resource: Uri, bucket: Hierarchy<SymbolInformation>[], item: Proto.NavigationTree): void {
+		if (!TypeScriptDocumentSymbolProvider.shouldInclueEntry(item.text)) {
+			return;
+		}
+		const symbolInfo = new SymbolInformation2(
 			item.text,
-			'', // detail, e.g. signature etc
+			'', // todo@joh detail
 			outlineTypeTable[item.kind as string] || SymbolKind.Variable,
+			typeConverters.Range.fromTextSpan(item.spans[0]),
 			typeConverters.Location.fromTextSpan(resource, item.spans[0]),
-			typeConverters.Range.fromTextSpan(item.spans[0])
 		);
+		const hierarchy = new Hierarchy(symbolInfo);
 		if (item.childItems && item.childItems.length > 0) {
-			result.children = [];
 			for (const child of item.childItems) {
-				TypeScriptDocumentSymbolProvider.convertNavTree(resource, result.children, child);
+				TypeScriptDocumentSymbolProvider.convertNavTree(resource, hierarchy.children, child);
 			}
 		}
+		bucket.push(hierarchy);
 
-		if (TypeScriptDocumentSymbolProvider.shouldInclueEntry(result.name)) {
-			bucket.push(result);
-		}
 	}
 
 	private static shouldInclueEntry(name: string): boolean {

src/vs/vscode.proposed.d.ts

@@ -571,19 +571,20 @@ declare module 'vscode' {
 
 	//#region Joh: hierarchical document symbols, https://github.com/Microsoft/vscode/issues/34968
 
-	export class HierarchicalSymbolInformation {
-		name: string;
-		kind: SymbolKind;
+	export class Hierarchy<T> {
+		parent: T;
+		children: Hierarchy<T>[];
+		constructor(element: T);
+	}
+
+	export class SymbolInformation2 extends SymbolInformation {
 		detail: string;
-		location: Location;
 		range: Range;
-		children: HierarchicalSymbolInformation[];
-
-		constructor(name: string, detail: string, kind: SymbolKind, location: Location, range: Range);
+		constructor(name: string, detail: string, kind: SymbolKind, range: Range, location: Location);
 	}
 
 	export interface DocumentSymbolProvider {
-		provideDocumentSymbols(document: TextDocument, token: CancellationToken): ProviderResult<HierarchicalSymbolInformation[] | SymbolInformation[]>;
+		provideDocumentSymbols(document: TextDocument, token: CancellationToken): ProviderResult<SymbolInformation[] | Hierarchy<SymbolInformation>[]>;
 	}
 
 	//#endregion

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

@@ -700,10 +700,16 @@ export function createApiFactory(
 			SourceBreakpoint: extHostTypes.SourceBreakpoint,
 			StatusBarAlignment: extHostTypes.StatusBarAlignment,
 			SymbolInformation: extHostTypes.SymbolInformation,
-			HierarchicalSymbolInformation: class extends extHostTypes.HierarchicalSymbolInformation {
-				constructor(name, detail, kind, keyof, range) {
+			SymbolInformation2: class extends extHostTypes.SymbolInformation2 {
+				constructor(name, detail, kind, range, location) {
 					checkProposedApiEnabled(extension);
-					super(name, detail, kind, keyof, range);
+					super(name, detail, kind, range, location);
+				}
+			},
+			Hierarchy: class <T> extends extHostTypes.Hierarchy<T> {
+				constructor(parent: T) {
+					checkProposedApiEnabled(extension);
+					super(parent);
 				}
 			},
 			SymbolKind: extHostTypes.SymbolKind,

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

@@ -9,7 +9,7 @@ import { TPromise } from 'vs/base/common/winjs.base';
 import { mixin } from 'vs/base/common/objects';
 import * as vscode from 'vscode';
 import * as typeConvert from 'vs/workbench/api/node/extHostTypeConverters';
-import { Range, Disposable, CompletionList, SnippetString, CodeActionKind, HierarchicalSymbolInformation, SymbolInformation } from 'vs/workbench/api/node/extHostTypes';
+import { Range, Disposable, CompletionList, SnippetString, CodeActionKind, SymbolInformation, Hierarchy, SymbolInformation2 } from 'vs/workbench/api/node/extHostTypes';
 import { ISingleEditOperation } from 'vs/editor/common/model';
 import * as modes from 'vs/editor/common/modes';
 import { ExtHostHeapService } from 'vs/workbench/api/node/extHostHeapService';
@@ -44,14 +44,14 @@ class OutlineAdapter {
 				return undefined;
 			}
 			let [probe] = value;
-			if (!(probe instanceof HierarchicalSymbolInformation)) {
-				value = OutlineAdapter._asSymbolTree(<SymbolInformation[]>value);
+			if (!(probe instanceof Hierarchy)) {
+				value = OutlineAdapter._asSymbolHierarchy(<SymbolInformation[]>value);
 			}
-			return (<HierarchicalSymbolInformation[]>value).map(typeConvert.HierarchicalSymbolInformation.from);
+			return (<Hierarchy<SymbolInformation2>[]>value).map(typeConvert.HierarchicalSymbolInformation.from);
 		});
 	}
 
-	private static _asSymbolTree(info: SymbolInformation[]): vscode.HierarchicalSymbolInformation[] {
+	private static _asSymbolHierarchy(info: SymbolInformation[]): vscode.Hierarchy<SymbolInformation2>[] {
 		// first sort by start (and end) and then loop over all elements
 		// and build a tree based on containment.
 		info = info.slice(0).sort((a, b) => {
@@ -61,10 +61,10 @@ class OutlineAdapter {
 			}
 			return res;
 		});
-		let res: HierarchicalSymbolInformation[] = [];
-		let parentStack: HierarchicalSymbolInformation[] = [];
+		let res: Hierarchy<SymbolInformation2>[] = [];
+		let parentStack: Hierarchy<SymbolInformation2>[] = [];
 		for (let i = 0; i < info.length; i++) {
-			let element = new HierarchicalSymbolInformation(info[i].name, '', info[i].kind, info[i].location, info[i].location.range);
+			let element = new Hierarchy(new SymbolInformation2(info[i].name, '', info[i].kind, info[i].location.range, info[i].location));
 			while (true) {
 				if (parentStack.length === 0) {
 					parentStack.push(element);
@@ -72,7 +72,7 @@ class OutlineAdapter {
 					break;
 				}
 				let parent = parentStack[parentStack.length - 1];
-				if (parent.range.contains(element.range)) {
+				if (parent.parent.range.contains(element.parent.range)) {
 					parent.children.push(element);
 					parentStack.push(element);
 					break;

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

@@ -364,27 +364,27 @@ export namespace SymbolInformation {
 }
 
 export namespace HierarchicalSymbolInformation {
-	export function from(info: vscode.HierarchicalSymbolInformation): modes.SymbolInformation {
+	export function from(info: vscode.Hierarchy<vscode.SymbolInformation2>): modes.SymbolInformation {
 		let result: modes.SymbolInformation = {
-			name: info.name,
-			detail: info.detail,
-			location: location.from(info.location),
-			definingRange: Range.from(info.range),
-			kind: SymbolKind.from(info.kind)
+			name: info.parent.name,
+			detail: info.parent.detail,
+			location: location.from(info.parent.location),
+			definingRange: Range.from(info.parent.range),
+			kind: SymbolKind.from(info.parent.kind)
 		};
 		if (info.children) {
 			result.children = info.children.map(from);
 		}
 		return result;
 	}
-	export function to(info: modes.SymbolInformation): types.HierarchicalSymbolInformation {
-		let result = new types.HierarchicalSymbolInformation(
+	export function to(info: modes.SymbolInformation): types.Hierarchy<vscode.SymbolInformation2> {
+		let result = new types.Hierarchy<vscode.SymbolInformation2>(new types.SymbolInformation2(
 			info.name,
 			info.detail,
 			SymbolKind.to(info.kind),
+			Range.to(info.definingRange),
 			location.to(info.location),
-			Range.to(info.definingRange)
-		);
+		));
 		if (info.children) {
 			result.children = info.children.map(to);
 		}

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

@@ -876,19 +876,24 @@ export class SymbolInformation {
 	}
 }
 
-export class HierarchicalSymbolInformation {
-	name: string;
-	location: Location;
+export class SymbolInformation2 extends SymbolInformation {
+
 	detail: string;
-	kind: SymbolKind;
 	range: Range;
-	children: HierarchicalSymbolInformation[];
 
-	constructor(name: string, detail: string, kind: SymbolKind, location: Location, range: Range) {
-		this.name = name;
-		this.kind = kind;
-		this.location = location;
+	constructor(name: string, detail: string, kind: SymbolKind, range: Range, location: Location) {
+		super(name, kind, undefined, location);
+		this.detail = detail;
 		this.range = range;
+	}
+}
+
+export class Hierarchy<T> {
+	parent: T;
+	children: Hierarchy<T>[];
+
+	constructor(parent: T) {
+		this.parent = parent;
 		this.children = [];
 	}
 }