Support Type Hierarchy

_specifications/specification-3-17.md

@@ -1927,6 +1927,13 @@ export interface TextDocumentClientCapabilities {
 	 * @since 3.16.0
 	 */
 	moniker?: MonikerClientCapabilities;
+
+	/**
+	 * Capabilities specific to the various type hierarchy requests.
+	 *
+	 * @since 3.17.0
+	 */
+	typeHierarchy?: TypeHierarchyClientCapabilities;
 }
 ```
 
@@ -2419,6 +2426,14 @@ interface ServerCapabilities {
 		}
 	}
 
+	/**
+	 * The server provides type hierarchy support.
+	 *
+	 * @since 3.17.0
+	 */
+	typeHierarchyProvider?: boolean | TypeHierarchyOptions
+		| TypeHierarchyRegistrationOptions;
+
 	/**
 	 * Experimental server capabilities.
 	 */
@@ -8173,6 +8188,211 @@ export interface Moniker {
 }
 ```
 
+#### <a href="#textDocument_prepareTypeHierarchy" name="textDocument_prepareTypeHierarchy" class="anchor">Prepare Type Hierarchy Request (:leftwards_arrow_with_hook:)</a>
+
+> *Since version 3.17.0*
+
+The type hierarchy request is sent from the client to the server to return a type hierarchy for the language element of given text document positions. The type hierarchy requests are executed in two steps:
+
+  1. first a type hierarchy item is prepared for the given text document position
+  1. the client request the server to resolve the given item with its supertypes or/and subtypes
+
+_Client Capability_:
+
+* property name (optional): `textDocument.typeHierarchy`
+* property type: `TypeHierarchyClientCapabilities` defined as follows:
+
+```typescript
+interface TypeHierarchyClientCapabilities {
+	/**
+	 * Whether implementation supports dynamic registration. If this is set to
+	 * `true` the client supports the new `(TextDocumentRegistrationOptions &
+	 * StaticRegistrationOptions)` return value for the corresponding server
+	 * capability as well.
+	 */
+	dynamicRegistration?: boolean;
+}
+```
+
+_Server Capability_:
+
+* property name (optional): `typeHierarchyProvider`
+* property type: `boolean | TypeHierarchyOptions | TypeHierarchyRegistrationOptions` where `TypeHierarchyOptions` is defined as follows:
+
+```typescript
+export interface TypeHierarchyOptions extends WorkDoneProgressOptions {
+	/**
+	 * The server has support for supporting inheritance tree.
+	 */
+	inheritanceTreeSuppport?: boolean;
+}
+```
+
+_Registration Options_: `TypeHierarchyRegistrationOptions` defined as follows:
+
+```typescript
+export interface TypeHierarchyRegistrationOptions extends
+	TextDocumentRegistrationOptions, TypeHierarchyOptions,
+	StaticRegistrationOptions {
+}
+```
+
+_Request_:
+
+* method: 'textDocument/prepareTypeHierarchy'
+* params: `TypeHierarchyPrepareParams` defined as follows:
+
+```typescript
+export interface TypeHierarchyPrepareParams extends TextDocumentPositionParams,
+	WorkDoneProgressParams {
+}
+```
+
+_Response_:
+
+* result: `TypeHierarchyItem[] | null` defined as follows:
+
+```typescript
+export interface TypeHierarchyItem {
+	/**
+	 * The name of this item.
+	 */
+	name: string;
+
+	/**
+	 * The kind of this item.
+	 */
+	kind: SymbolKind;
+
+	/**
+	 * Tags for this item.
+	 */
+	tags?: SymbolTag[];
+
+	/**
+	 * More detail for this item, e.g. the signature of a function.
+	 */
+	detail?: string;
+
+	/**
+	 * The resource identifier of this item.
+	 */
+	uri: DocumentUri;
+
+	/**
+	 * The range enclosing this symbol not including leading/trailing whitespace
+	 * but everything else, e.g. comments and code.
+	 */
+	range?: Range;
+
+	/**
+	 * The range that should be selected and revealed when this symbol is being
+	 * picked, e.g. the name of a function. Must be contained by the
+	 * [`range`](#TypeHierarchyItem.range).
+	 */
+	selectionRange: Range;
+
+	/**
+	 * Indicates if this item has supertypes. When `undefined` the supertypes
+	 * of this item have not been resolved yet.
+	 */
+	hasSupertypes?: boolean;
+
+	/**
+	 * Indicates if this item has subtypes. When `undefined` the subtypes
+	 * of this item have not been resolved yet.
+	 */
+	hasSubtypes?: boolean;
+
+	/**
+	 * A data entry field that is preserved between a call hierarchy prepare and
+	 * incoming calls or outgoing calls requests.
+	 */
+	data?: unknown;
+}
+```
+
+* error: code and message set in case an exception happens during the 'textDocument/prepareTypeHierarchy' request
+
+#### <a href="#typeHierarchy_supertypes" name="typeHierarchy_supertypes" class="anchor">Type Hierarchy Supertypes(:leftwards_arrow_with_hook:)</a>
+
+> *Since version 3.17.0*
+
+The request is sent from the client to the server to resolve the supertypes for a given type hierarchy item. The request doesn't define its own client and server capabilities. It is only issued if a server registers for the [`textDocument/prepareTypeHierarchy` request](#textDocument_prepareTypeHierarchy).
+
+_Request_:
+
+* method: 'typeHierarchy/supertypes'
+* params: `TypeHierarchySupertypesParams` defined as follows:
+
+```typescript
+export interface TypeHierarchySupertypesParams extends
+	WorkDoneProgressParams, PartialResultParams {
+	item: TypeHierarchyItem;
+}
+```
+_Response_:
+
+* result: `TypeHierarchyItem[] | null`
+* partial result: `TypeHierarchyItem[]`
+* error: code and message set in case an exception happens during the 'typeHierarchy/supertypes' request
+
+#### <a href="#typeHierarchy_subtypes" name="typeHierarchy_subtypes" class="anchor">Type Hierarchy Subtypes(:leftwards_arrow_with_hook:)</a>
+
+> *Since version 3.17.0*
+
+The request is sent from the client to the server to resolve the subtypes for a given type hierarchy item. The request doesn't define its own client and server capabilities. It is only issued if a server registers for the [`textDocument/prepareTypeHierarchy` request](#textDocument_prepareTypeHierarchy).
+
+_Request_:
+
+* method: 'typeHierarchy/subtypes'
+* params: `TypeHierarchySubtypesParams` defined as follows:
+
+```typescript
+export interface TypeHierarchySubtypesParams extends
+	WorkDoneProgressParams, PartialResultParams {
+	item: TypeHierarchyItem;
+}
+```
+_Response_:
+
+* result: `TypeHierarchyItem[] | null`
+* partial result: `TypeHierarchyItem[]`
+* error: code and message set in case an exception happens during the 'typeHierarchy/subtypes' request
+
+#### <a href="#typeHierarchy_inheritanceTree" name="typeHierarchy_inheritanceTree" class="anchor">Type Hierarchy Inheritance Tree(:leftwards_arrow_with_hook:)</a>
+
+> *Since version 3.17.0*
+
+The request is sent from the client to the server to resolve the inheritance tree for a given type hierarchy item. The response result of this request is `TreeItem<T>`.
+* `TreeItem<T>` defined as follows:
+```typescript
+export interface TreeItem<T> {
+	data: T;
+	/**
+	 * The children of this TreeItem. When `undefined` the children have not been resolved yet.
+	 */
+	children?: TreeItem<T>[];
+}
+```
+The result represents the inheritance tree related to the specified type hierarchy item. Only single inheritance can be represented this way. The root type is expected as the return value. The request doesn't define its own client and server capabilities. It is only issued if a server has the capability for `TypeHierarchyOptions/inheritanceTreeSuppport`.
+
+_Request_:
+
+* method: 'typeHierarchy/inheritanceTree'
+* params: `TypeHierarchyInheritanceTreeParams` defined as follows:
+
+```typescript
+export interface TypeHierarchyInheritanceTreeParams extends
+	WorkDoneProgressParams {
+	item: TypeHierarchyItem;
+}
+```
+_Response_:
+
+* result: `TreeItem<TypeHierarchyItem> | null`
+* error: code and message set in case an exception happens during the 'typeHierarchy/resolve' request
+
 ##### Notes
 
 Server implementations of this method should ensure that the moniker calculation matches to those used in the corresponding LSIF implementation to ensure symbols can be associated correctly across IDE sessions and LSIF indexes.