@theia/plugin-ext 1.25.0-next.39 → 1.25.0-next.41

package/src/main/browser/callhierarchy/callhierarchy-type-converters.ts

@@ -14,7 +14,7 @@
 // SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
 // *****************************************************************************
 
-import { Definition as CallHierarchyDefinition, Caller as CallHierarchyCaller, Callee as CallHierarchyCallee } from '@theia/callhierarchy/lib/browser';
+import { CallHierarchyItem, CallHierarchyIncomingCall, CallHierarchyOutgoingCall } from '@theia/callhierarchy/lib/browser';
 import * as model from '../../../common/plugin-api-rpc-model';
 import * as rpc from '../../../common/plugin-api-rpc';
 import * as callhierarchy from '@theia/core/shared/vscode-languageserver-protocol';
@@ -70,136 +70,124 @@ export function toRange(range: model.Range): callhierarchy.Range {
 }
 
 export namespace SymbolKindConverter {
-    // tslint:disable-next-line:no-null-keyword
-    const fromMapping: { [kind: number]: model.SymbolKind } = Object.create(null);
-    fromMapping[callhierarchy.SymbolKind.File] = model.SymbolKind.File;
-    fromMapping[callhierarchy.SymbolKind.Module] = model.SymbolKind.Module;
-    fromMapping[callhierarchy.SymbolKind.Namespace] = model.SymbolKind.Namespace;
-    fromMapping[callhierarchy.SymbolKind.Package] = model.SymbolKind.Package;
-    fromMapping[callhierarchy.SymbolKind.Class] = model.SymbolKind.Class;
-    fromMapping[callhierarchy.SymbolKind.Method] = model.SymbolKind.Method;
-    fromMapping[callhierarchy.SymbolKind.Property] = model.SymbolKind.Property;
-    fromMapping[callhierarchy.SymbolKind.Field] = model.SymbolKind.Field;
-    fromMapping[callhierarchy.SymbolKind.Constructor] = model.SymbolKind.Constructor;
-    fromMapping[callhierarchy.SymbolKind.Enum] = model.SymbolKind.Enum;
-    fromMapping[callhierarchy.SymbolKind.Interface] = model.SymbolKind.Interface;
-    fromMapping[callhierarchy.SymbolKind.Function] = model.SymbolKind.Function;
-    fromMapping[callhierarchy.SymbolKind.Variable] = model.SymbolKind.Variable;
-    fromMapping[callhierarchy.SymbolKind.Constant] = model.SymbolKind.Constant;
-    fromMapping[callhierarchy.SymbolKind.String] = model.SymbolKind.String;
-    fromMapping[callhierarchy.SymbolKind.Number] = model.SymbolKind.Number;
-    fromMapping[callhierarchy.SymbolKind.Boolean] = model.SymbolKind.Boolean;
-    fromMapping[callhierarchy.SymbolKind.Array] = model.SymbolKind.Array;
-    fromMapping[callhierarchy.SymbolKind.Object] = model.SymbolKind.Object;
-    fromMapping[callhierarchy.SymbolKind.Key] = model.SymbolKind.Key;
-    fromMapping[callhierarchy.SymbolKind.Null] = model.SymbolKind.Null;
-    fromMapping[callhierarchy.SymbolKind.EnumMember] = model.SymbolKind.EnumMember;
-    fromMapping[callhierarchy.SymbolKind.Struct] = model.SymbolKind.Struct;
-    fromMapping[callhierarchy.SymbolKind.Event] = model.SymbolKind.Event;
-    fromMapping[callhierarchy.SymbolKind.Operator] = model.SymbolKind.Operator;
-    fromMapping[callhierarchy.SymbolKind.TypeParameter] = model.SymbolKind.TypeParameter;
-
     export function fromSymbolKind(kind: callhierarchy.SymbolKind): model.SymbolKind {
-        return fromMapping[kind] || model.SymbolKind.Property;
+        switch (kind) {
+            case callhierarchy.SymbolKind.File: return model.SymbolKind.File;
+            case callhierarchy.SymbolKind.Module: return model.SymbolKind.Module;
+            case callhierarchy.SymbolKind.Namespace: return model.SymbolKind.Namespace;
+            case callhierarchy.SymbolKind.Package: return model.SymbolKind.Package;
+            case callhierarchy.SymbolKind.Class: return model.SymbolKind.Class;
+            case callhierarchy.SymbolKind.Method: return model.SymbolKind.Method;
+            case callhierarchy.SymbolKind.Property: return model.SymbolKind.Property;
+            case callhierarchy.SymbolKind.Field: return model.SymbolKind.Field;
+            case callhierarchy.SymbolKind.Constructor: return model.SymbolKind.Constructor;
+            case callhierarchy.SymbolKind.Enum: return model.SymbolKind.Enum;
+            case callhierarchy.SymbolKind.Interface: return model.SymbolKind.Interface;
+            case callhierarchy.SymbolKind.Function: return model.SymbolKind.Function;
+            case callhierarchy.SymbolKind.Variable: return model.SymbolKind.Variable;
+            case callhierarchy.SymbolKind.Constant: return model.SymbolKind.Constant;
+            case callhierarchy.SymbolKind.String: return model.SymbolKind.String;
+            case callhierarchy.SymbolKind.Number: return model.SymbolKind.Number;
+            case callhierarchy.SymbolKind.Boolean: return model.SymbolKind.Boolean;
+            case callhierarchy.SymbolKind.Array: return model.SymbolKind.Array;
+            case callhierarchy.SymbolKind.Object: return model.SymbolKind.Object;
+            case callhierarchy.SymbolKind.Key: return model.SymbolKind.Key;
+            case callhierarchy.SymbolKind.Null: return model.SymbolKind.Null;
+            case callhierarchy.SymbolKind.EnumMember: return model.SymbolKind.EnumMember;
+            case callhierarchy.SymbolKind.Struct: return model.SymbolKind.Struct;
+            case callhierarchy.SymbolKind.Event: return model.SymbolKind.Event;
+            case callhierarchy.SymbolKind.Operator: return model.SymbolKind.Operator;
+            case callhierarchy.SymbolKind.TypeParameter: return model.SymbolKind.TypeParameter;
+            default: return model.SymbolKind.Property;
+        }
     }
-
-    // tslint:disable-next-line:no-null-keyword
-    const toMapping: { [kind: number]: callhierarchy.SymbolKind } = Object.create(null);
-    toMapping[model.SymbolKind.File] = callhierarchy.SymbolKind.File;
-    toMapping[model.SymbolKind.Module] = callhierarchy.SymbolKind.Module;
-    toMapping[model.SymbolKind.Namespace] = callhierarchy.SymbolKind.Namespace;
-    toMapping[model.SymbolKind.Package] = callhierarchy.SymbolKind.Package;
-    toMapping[model.SymbolKind.Class] = callhierarchy.SymbolKind.Class;
-    toMapping[model.SymbolKind.Method] = callhierarchy.SymbolKind.Method;
-    toMapping[model.SymbolKind.Property] = callhierarchy.SymbolKind.Property;
-    toMapping[model.SymbolKind.Field] = callhierarchy.SymbolKind.Field;
-    toMapping[model.SymbolKind.Constructor] = callhierarchy.SymbolKind.Constructor;
-    toMapping[model.SymbolKind.Enum] = callhierarchy.SymbolKind.Enum;
-    toMapping[model.SymbolKind.Interface] = callhierarchy.SymbolKind.Interface;
-    toMapping[model.SymbolKind.Function] = callhierarchy.SymbolKind.Function;
-    toMapping[model.SymbolKind.Variable] = callhierarchy.SymbolKind.Variable;
-    toMapping[model.SymbolKind.Constant] = callhierarchy.SymbolKind.Constant;
-    toMapping[model.SymbolKind.String] = callhierarchy.SymbolKind.String;
-    toMapping[model.SymbolKind.Number] = callhierarchy.SymbolKind.Number;
-    toMapping[model.SymbolKind.Boolean] = callhierarchy.SymbolKind.Boolean;
-    toMapping[model.SymbolKind.Array] = callhierarchy.SymbolKind.Array;
-    toMapping[model.SymbolKind.Object] = callhierarchy.SymbolKind.Object;
-    toMapping[model.SymbolKind.Key] = callhierarchy.SymbolKind.Key;
-    toMapping[model.SymbolKind.Null] = callhierarchy.SymbolKind.Null;
-    toMapping[model.SymbolKind.EnumMember] = callhierarchy.SymbolKind.EnumMember;
-    toMapping[model.SymbolKind.Struct] = callhierarchy.SymbolKind.Struct;
-    toMapping[model.SymbolKind.Event] = callhierarchy.SymbolKind.Event;
-    toMapping[model.SymbolKind.Operator] = callhierarchy.SymbolKind.Operator;
-    toMapping[model.SymbolKind.TypeParameter] = callhierarchy.SymbolKind.TypeParameter;
-
     export function toSymbolKind(kind: model.SymbolKind): callhierarchy.SymbolKind {
-        return toMapping[kind] || model.SymbolKind.Property;
+        switch (kind) {
+            case model.SymbolKind.File: return callhierarchy.SymbolKind.File;
+            case model.SymbolKind.Module: return callhierarchy.SymbolKind.Module;
+            case model.SymbolKind.Namespace: return callhierarchy.SymbolKind.Namespace;
+            case model.SymbolKind.Package: return callhierarchy.SymbolKind.Package;
+            case model.SymbolKind.Class: return callhierarchy.SymbolKind.Class;
+            case model.SymbolKind.Method: return callhierarchy.SymbolKind.Method;
+            case model.SymbolKind.Property: return callhierarchy.SymbolKind.Property;
+            case model.SymbolKind.Field: return callhierarchy.SymbolKind.Field;
+            case model.SymbolKind.Constructor: return callhierarchy.SymbolKind.Constructor;
+            case model.SymbolKind.Enum: return callhierarchy.SymbolKind.Enum;
+            case model.SymbolKind.Interface: return callhierarchy.SymbolKind.Interface;
+            case model.SymbolKind.Function: return callhierarchy.SymbolKind.Function;
+            case model.SymbolKind.Variable: return callhierarchy.SymbolKind.Variable;
+            case model.SymbolKind.Constant: return callhierarchy.SymbolKind.Constant;
+            case model.SymbolKind.String: return callhierarchy.SymbolKind.String;
+            case model.SymbolKind.Number: return callhierarchy.SymbolKind.Number;
+            case model.SymbolKind.Boolean: return callhierarchy.SymbolKind.Boolean;
+            case model.SymbolKind.Array: return callhierarchy.SymbolKind.Array;
+            case model.SymbolKind.Object: return callhierarchy.SymbolKind.Object;
+            case model.SymbolKind.Key: return callhierarchy.SymbolKind.Key;
+            case model.SymbolKind.Null: return callhierarchy.SymbolKind.Null;
+            case model.SymbolKind.EnumMember: return callhierarchy.SymbolKind.EnumMember;
+            case model.SymbolKind.Struct: return callhierarchy.SymbolKind.Struct;
+            case model.SymbolKind.Event: return callhierarchy.SymbolKind.Event;
+            case model.SymbolKind.Operator: return callhierarchy.SymbolKind.Operator;
+            case model.SymbolKind.TypeParameter: return callhierarchy.SymbolKind.TypeParameter;
+            default: return callhierarchy.SymbolKind.Property;
+        }
     }
 }
 
-export function toDefinition(definition: model.CallHierarchyDefinition): CallHierarchyDefinition;
-export function toDefinition(definition: model.CallHierarchyDefinition | undefined): CallHierarchyDefinition | undefined;
-export function toDefinition(definition: model.CallHierarchyDefinition | undefined): CallHierarchyDefinition | undefined {
+export function toDefinition(definition: model.CallHierarchyItem): CallHierarchyItem;
+export function toDefinition(definition: model.CallHierarchyItem | undefined): CallHierarchyItem | undefined;
+export function toDefinition(definition: model.CallHierarchyItem | undefined): CallHierarchyItem | undefined {
     if (!definition) {
         return undefined;
     }
     return {
-        location: {
-            uri: fromUriComponents(definition.uri),
-            range: toRange(definition.range)
-        },
+        ...definition,
+        kind: SymbolKindConverter.toSymbolKind(definition.kind),
+        range: toRange(definition.range),
         selectionRange: toRange(definition.selectionRange),
-        symbolName: definition.name,
-        symbolKind: SymbolKindConverter.toSymbolKind(definition.kind),
-        containerName: undefined,
-        tags: definition.tags,
-        data: definition.data,
     };
 }
 
-export function fromDefinition(definition: CallHierarchyDefinition): model.CallHierarchyDefinition {
+export function fromDefinition(definition: CallHierarchyItem): model.CallHierarchyItem {
     return {
-        uri: toUriComponents(definition.location.uri),
-        range: fromRange(definition.location.range),
-        selectionRange: fromRange(definition.selectionRange),
-        name: definition.symbolName,
-        kind: SymbolKindConverter.fromSymbolKind(definition.symbolKind),
-        tags: definition.tags,
-        data: definition.data,
+        ...definition,
+        kind: SymbolKindConverter.fromSymbolKind(definition.kind),
+        range: fromRange(definition.range),
+        selectionRange: fromRange(definition.range),
     };
 }
 
-export function toCaller(caller: model.CallHierarchyReference): CallHierarchyCaller {
+export function toCaller(caller: model.CallHierarchyIncomingCall): CallHierarchyIncomingCall {
     return {
-        callerDefinition: toDefinition(caller.callerDefinition),
-        references: caller.references.map(toRange)
+        from: toDefinition(caller.from),
+        fromRanges: caller.fromRanges.map(toRange)
     };
 }
 
-export function fromCaller(caller: CallHierarchyCaller): model.CallHierarchyReference {
+export function fromCaller(caller: CallHierarchyIncomingCall): model.CallHierarchyIncomingCall {
     return {
-        callerDefinition: fromDefinition(caller.callerDefinition),
-        references: caller.references.map(fromRange)
+        from: fromDefinition(caller.from),
+        fromRanges: caller.fromRanges.map(fromRange)
     };
 }
 
-export function toCallee(callee: model.CallHierarchyReference): CallHierarchyCallee {
+export function toCallee(callee: model.CallHierarchyOutgoingCall): CallHierarchyOutgoingCall {
     return {
-        calleeDefinition: toDefinition(callee.callerDefinition),
-        references: callee.references.map(toRange),
+        to: toDefinition(callee.to),
+        fromRanges: callee.fromRanges.map(toRange),
     };
 }
 
-export function fromCallHierarchyCallerToModelCallHierarchyIncomingCall(caller: CallHierarchyCaller): model.CallHierarchyIncomingCall {
+export function fromCallHierarchyCallerToModelCallHierarchyIncomingCall(caller: CallHierarchyIncomingCall): model.CallHierarchyIncomingCall {
     return {
-        from: fromDefinition(caller.callerDefinition),
-        fromRanges: caller.references.map(fromRange),
+        from: fromDefinition(caller.from),
+        fromRanges: caller.fromRanges.map(fromRange),
     };
 }
 
-export function fromCallHierarchyCalleeToModelCallHierarchyOutgoingCall(callee: CallHierarchyCallee): model.CallHierarchyOutgoingCall {
+export function fromCallHierarchyCalleeToModelCallHierarchyOutgoingCall(callee: CallHierarchyOutgoingCall): model.CallHierarchyOutgoingCall {
     return {
-        to: fromDefinition(callee.calleeDefinition),
-        fromRanges: callee.references.map(fromRange),
+        to: fromDefinition(callee.to),
+        fromRanges: callee.fromRanges.map(fromRange),
     };
 }

package/src/main/browser/languages-main.ts

@@ -50,7 +50,7 @@ import * as theia from '@theia/plugin';
 import { UriComponents } from '../../common/uri-components';
 import { CancellationToken } from '@theia/core/lib/common';
 import { LanguageSelector, RelativePattern } from '@theia/callhierarchy/lib/common/language-selector';
-import { CallHierarchyService, CallHierarchyServiceProvider, Definition } from '@theia/callhierarchy/lib/browser';
+import { CallHierarchyService, CallHierarchyServiceProvider, CallHierarchyItem } from '@theia/callhierarchy/lib/browser';
 import { toDefinition, toUriComponents, fromDefinition, fromPosition, toCaller, toCallee } from './callhierarchy/callhierarchy-type-converters';
 import { Position, DocumentUri, DiagnosticTag } from '@theia/core/shared/vscode-languageserver-protocol';
 import { ObjectIdentifier } from '../../common/object-identifier';
@@ -804,8 +804,12 @@ export class LanguagesMainImpl implements LanguagesMain, Disposable {
             selector: language,
             getRootDefinition: (uri: DocumentUri, position: Position, cancellationToken: CancellationToken) =>
                 this.proxy.$provideRootDefinition(handle, toUriComponents(uri), fromPosition(position), cancellationToken)
-                    .then(def => Array.isArray(def) ? def.map(item => toDefinition(item)) : toDefinition(def)),
-            getCallers: (definition: Definition, cancellationToken: CancellationToken) => this.proxy.$provideCallers(handle, fromDefinition(definition), cancellationToken)
+                    .then(def => {
+                        if (!def) { return undefined; }
+                        const defs = Array.isArray(def) ? def : [def];
+                        return { dispose: () => this.proxy.$releaseCallHierarchy(handle, defs[0]?._sessionId), items: defs.map(item => toDefinition(item)) };
+                    }),
+            getCallers: (definition: CallHierarchyItem, cancellationToken: CancellationToken) => this.proxy.$provideCallers(handle, fromDefinition(definition), cancellationToken)
                 .then(result => {
                     if (!result) {
                         return undefined!;
@@ -818,7 +822,7 @@ export class LanguagesMainImpl implements LanguagesMain, Disposable {
                     return undefined!;
                 }),
 
-            getCallees: (definition: Definition, cancellationToken: CancellationToken) => this.proxy.$provideCallees(handle, fromDefinition(definition), cancellationToken)
+            getCallees: (definition: CallHierarchyItem, cancellationToken: CancellationToken) => this.proxy.$provideCallees(handle, fromDefinition(definition), cancellationToken)
                 .then(result => {
                     if (!result) {
                         return undefined;

package/src/plugin/languages/call-hierarchy.ts

@@ -16,11 +16,11 @@
 
 import { URI } from '@theia/core/shared/vscode-uri';
 import * as theia from '@theia/plugin';
-import * as Converter from '../type-converters';
 import { DocumentsExtImpl } from '../documents';
-import * as model from '../../common/plugin-api-rpc-model';
+import * as dto from '../../common/plugin-api-rpc-model';
 import * as rpc from '../../common/plugin-api-rpc';
 import * as types from '../types-impl';
+import { fromRange } from '../type-converters';
 
 export class CallHierarchyAdapter {
 
@@ -29,9 +29,12 @@ export class CallHierarchyAdapter {
         private readonly documents: DocumentsExtImpl
     ) { }
 
+    protected sessionIds = 0;
+    protected readonly cache = new Map<string, Map<string, theia.CallHierarchyItem>>();
+
     async provideRootDefinition(
         resource: URI, position: rpc.Position, token: theia.CancellationToken
-    ): Promise<model.CallHierarchyDefinition | model.CallHierarchyDefinition[] | undefined> {
+    ): Promise<dto.CallHierarchyItem[] | undefined> {
         const documentData = this.documents.getDocumentData(resource);
         if (!documentData) {
             return Promise.reject(new Error(`There is no document for ${resource}`));
@@ -48,83 +51,74 @@ export class CallHierarchyAdapter {
         if (!definition) {
             return undefined;
         }
-
-        return Array.isArray(definition) ? definition.map(item => this.fromCallHierarchyItem(item)) : this.fromCallHierarchyItem(definition);
+        const sessionId = (this.sessionIds++).toString(36);
+        this.cache.set(sessionId, new Map());
+        return Array.isArray(definition) ? definition.map(item => this.fromCallHierarchyItem(item, sessionId)) : [this.fromCallHierarchyItem(definition, sessionId)];
     }
 
-    async provideCallers(definition: model.CallHierarchyDefinition, token: theia.CancellationToken): Promise<model.CallHierarchyReference[] | undefined> {
+    async provideCallers(definition: dto.CallHierarchyItem, token: theia.CancellationToken): Promise<dto.CallHierarchyIncomingCall[] | undefined> {
         const callers = await this.provider.provideCallHierarchyIncomingCalls(this.toCallHierarchyItem(definition), token);
         if (!callers) {
             return undefined;
         }
 
-        return callers.map(item => this.fromCallHierarchyIncomingCall(item));
+        return callers.map(item => this.fromCallHierarchyIncomingCall(item, definition._sessionId!));
     }
 
-    async provideCallees(definition: model.CallHierarchyDefinition, token: theia.CancellationToken): Promise<model.CallHierarchyReference[] | undefined> {
+    async provideCallees(definition: dto.CallHierarchyItem, token: theia.CancellationToken): Promise<dto.CallHierarchyOutgoingCall[] | undefined> {
         const callees = await this.provider.provideCallHierarchyOutgoingCalls(this.toCallHierarchyItem(definition), token);
         if (!callees) {
             return undefined;
         }
 
-        return callees.map(item => this.fromCallHierarchyOutgoingCall(item));
+        return callees.map(item => this.fromCallHierarchyOutgoingCall(item, definition._sessionId!));
     }
 
-    private fromCallHierarchyItem(item: theia.CallHierarchyItem): model.CallHierarchyDefinition {
-        return {
+    private fromCallHierarchyItem(item: theia.CallHierarchyItem, sessionId: string): dto.CallHierarchyItem {
+        const sessionCache = this.cache.get(sessionId)!;
+        const itemId = sessionCache.size.toString(36);
+        const definition: dto.CallHierarchyItem = {
             uri: item.uri,
-            range: this.fromRange(item.range),
-            selectionRange: this.fromRange(item.selectionRange),
+            range: fromRange(item.range),
+            selectionRange: fromRange(item.selectionRange),
             name: item.name,
             kind: item.kind,
             tags: item.tags,
-            data: item.data,
-        };
-    }
-
-    private fromRange(range: theia.Range): model.Range {
-        return {
-            startLineNumber: range.start.line + 1,
-            startColumn: range.start.character + 1,
-            endLineNumber: range.end.line + 1,
-            endColumn: range.end.character + 1,
+            _itemId: itemId,
+            _sessionId: sessionId,
         };
+        sessionCache.set(itemId, item);
+        return definition;
     }
 
-    private toRange(range: model.Range): types.Range {
-        return new types.Range(
-            range.startLineNumber - 1,
-            range.startColumn - 1,
-            range.endLineNumber - 1,
-            range.endColumn - 1,
-        );
-    }
-
-    private toCallHierarchyItem(definition: model.CallHierarchyDefinition): theia.CallHierarchyItem {
-        const item = new types.CallHierarchyItem(
-            Converter.SymbolKind.toSymbolKind(definition.kind),
-            definition.name,
-            definition.detail ? definition.detail : '',
-            URI.revive(definition.uri),
-            this.toRange(definition.range),
-            this.toRange(definition.selectionRange),
-        );
-        item.tags = definition.tags;
-        item.data = definition.data;
-        return item;
+    private toCallHierarchyItem(definition: dto.CallHierarchyItem): theia.CallHierarchyItem {
+        const cached = this.cache.get(definition._sessionId!)?.get(definition._itemId!);
+        if (!cached) {
+            throw new Error(`Found no cached item corresponding to ${definition.name} in ${definition.uri.path} with ID ${definition.data}.`);
+        }
+        return cached;
     }
 
-    private fromCallHierarchyIncomingCall(caller: theia.CallHierarchyIncomingCall): model.CallHierarchyReference {
+    private fromCallHierarchyIncomingCall(caller: theia.CallHierarchyIncomingCall, sessionId: string): dto.CallHierarchyIncomingCall {
         return {
-            callerDefinition: this.fromCallHierarchyItem(caller.from),
-            references: caller.fromRanges.map(l => this.fromRange(l))
+            from: this.fromCallHierarchyItem(caller.from, sessionId),
+            fromRanges: caller.fromRanges.map(r => fromRange(r))
         };
     }
 
-    protected fromCallHierarchyOutgoingCall(caller: theia.CallHierarchyOutgoingCall): model.CallHierarchyReference {
+    protected fromCallHierarchyOutgoingCall(caller: theia.CallHierarchyOutgoingCall, sessionId: string): dto.CallHierarchyOutgoingCall {
         return {
-            callerDefinition: this.fromCallHierarchyItem(caller.to),
-            references: caller.fromRanges.map(this.fromRange.bind(this)),
+            to: this.fromCallHierarchyItem(caller.to, sessionId),
+            fromRanges: caller.fromRanges.map(r => fromRange(r)),
         };
     }
+
+    releaseSession(session?: string): Promise<boolean> {
+        if (session !== undefined) {
+            return Promise.resolve(this.cache.delete(session));
+        } else {
+            this.cache.clear();
+            return Promise.resolve(true);
+        }
+    }
 }

package/src/plugin/languages.ts

@@ -59,9 +59,10 @@ import {
     CodeAction,
     FoldingRange,
     SelectionRange,
-    CallHierarchyDefinition,
-    CallHierarchyReference,
-    ChainedCacheId
+    ChainedCacheId,
+    CallHierarchyItem,
+    CallHierarchyIncomingCall,
+    CallHierarchyOutgoingCall,
 } from '../common/plugin-api-rpc-model';
 import { CompletionAdapter } from './languages/completion';
 import { Diagnostics } from './languages/diagnostics';
@@ -612,17 +613,21 @@ export class LanguagesExtImpl implements LanguagesExt {
 
     $provideRootDefinition(
         handle: number, resource: UriComponents, location: Position, token: theia.CancellationToken
-    ): Promise<CallHierarchyDefinition | CallHierarchyDefinition[] | undefined> {
+    ): Promise<CallHierarchyItem[] | undefined> {
         return this.withAdapter(handle, CallHierarchyAdapter, adapter => adapter.provideRootDefinition(URI.revive(resource), location, token), undefined);
     }
 
-    $provideCallers(handle: number, definition: CallHierarchyDefinition, token: theia.CancellationToken): Promise<CallHierarchyReference[] | undefined> {
+    $provideCallers(handle: number, definition: CallHierarchyItem, token: theia.CancellationToken): Promise<CallHierarchyIncomingCall[] | undefined> {
         return this.withAdapter(handle, CallHierarchyAdapter, adapter => adapter.provideCallers(definition, token), undefined);
     }
 
-    $provideCallees(handle: number, definition: CallHierarchyDefinition, token: theia.CancellationToken): Promise<CallHierarchyReference[] | undefined> {
+    $provideCallees(handle: number, definition: CallHierarchyItem, token: theia.CancellationToken): Promise<CallHierarchyOutgoingCall[] | undefined> {
         return this.withAdapter(handle, CallHierarchyAdapter, adapter => adapter.provideCallees(definition, token), undefined);
     }
+
+    $releaseCallHierarchy(handle: number, session?: string): Promise<boolean> {
+        return this.withAdapter(handle, CallHierarchyAdapter, adapter => adapter.releaseSession(session), false);
+    }
     // ### Call Hierarchy Provider end
 
     // #region semantic coloring

package/src/plugin/type-converters.ts

@@ -675,7 +675,7 @@ export function toLocation(value: model.Location): types.Location {
     return new types.Location(URI.revive(value.uri), toRange(value.range));
 }
 
-export function fromCallHierarchyItem(item: theia.CallHierarchyItem): model.CallHierarchyItem {
+export function fromCallHierarchyItem(item: types.CallHierarchyItem): model.CallHierarchyItem {
     return <model.CallHierarchyItem>{
         kind: SymbolKind.fromSymbolKind(item.kind),
         name: item.name,
@@ -684,7 +684,8 @@ export function fromCallHierarchyItem(item: theia.CallHierarchyItem): model.Call
         range: fromRange(item.range),
         selectionRange: fromRange(item.selectionRange),
         tags: item.tags,
-        data: item.data,
+        _itemId: item._itemId,
+        _sessionId: item._sessionId,
     };
 }
 
@@ -698,7 +699,9 @@ export function toCallHierarchyItem(value: model.CallHierarchyItem): types.CallH
         toRange(value.selectionRange),
     );
     item.tags = value.tags;
-    item.data = value.data;
+    item._itemId = value._itemId;
+    item._sessionId = value._sessionId;
+
     return item;
 }
 

package/src/plugin/types-impl.ts

@@ -2437,7 +2437,6 @@ export class CallHierarchyItem {
     range: Range;
     selectionRange: Range;
     tags?: readonly SymbolTag[];
-    data?: unknown;
 
     constructor(kind: SymbolKind, name: string, detail: string, uri: URI, range: Range, selectionRange: Range) {
         this.kind = kind;
@@ -2448,7 +2447,7 @@ export class CallHierarchyItem {
         this.selectionRange = selectionRange;
     }
 
-    static isCallHierarchyItem(thing: {}): thing is theia.CallHierarchyItem {
+    static isCallHierarchyItem(thing: {}): thing is CallHierarchyItem {
         if (thing instanceof CallHierarchyItem) {
             return true;
         }