call hierarchy api

[jrieken]

This PR refines the call hierarchy API proposal and adopts the UX for it. The new proposal is

	export enum CallHierarchyDirection {
		CallsFrom = 1,
		CallsTo = 2,
	}

	export class CallHierarchySymbol {
		kind: SymbolKind;
		tags?: ReadonlyArray<SymbolTag>;
		name: string;
		detail?: string;
		uri: Uri;
		range: Range;
		selectionRange: Range;

		constructor(kind: SymbolKind, name: string, detail: string, uri: Uri, range: Range, selectionRange: Range);
	}

	export class CallHierarchyItem {
		source: CallHierarchySymbol;
		targets: ReadonlyArray<CallHierarchySymbol>;
	}

	export interface CallHierarchyItemProvider {
		provideCallHierarchyItems(document: TextDocument, position: Position, direction: CallHierarchyDirection, token: CancellationToken): ProviderResult<CallHierarchyItem[]>;
	}

	export namespace languages {
		export function registerCallHierarchyProvider(selector: DocumentSelector, provider: CallHierarchyItemProvider): Disposable;
	}

[mjbvz]

/cc @rbuckton Since I know you were were looking into microsoft/TypeScript#31863

[jrieken]

Another round of API ideas (closer to the original)

		class CallHierarchyItem {
			kind: SymbolKind;
			name: string;
			detail?: string;
			uri: Uri;
			range: Range;
			selectionRange: Range;
		}

		interface CallsTo {
			source: CallHierarchyItem,
			sourceRanges: Range[]
		}

		interface CallsFrom {
			sourceRanges: Range[],
			target: CallHierarchyItem
		}

		interface CallHierarchyItemProvider {

			resolveCallHierarchyItem(document: TextDocument, postion: Position, token: CancellationToken): ProviderResult<CallHierarchyItem>;

			provideCallsTo(target: CallHierarchyItem, token: CancellationToken): ProviderResult<CallsTo[]>;

			provideCallsFrom(source: CallHierarchyItem, token: CancellationToken): ProviderResult<CallsFrom[]>;
		}

[rbuckton]

Will call hierarchy only be limited to calls to/from, or is it possible it will evolve to support other concepts?

For example:

• constructs/constructed by (i.e. via new)
• read by/written by (i.e. fields or accessors)

[jrieken]

Will call hierarchy only be limited to calls to/from, or is it possible it will evolve to support other concepts?

Anything callable and anything that makes calls. The obvious are functions/methods but constructors and getters/setters are also valid. Generally, VS Code doesn't care/know about what's valid and it will simply ask the language brains for incoming/outgoing calls for a document position.

[jrieken]

fyi - closing this in favour of #70231 (comment). That explains the latest proposal which we are very likely to settle on. Let's continue the discussions there.