@theia/plugin-ext 1.31.0-next.3 → 1.31.0-next.33

package/src/plugin/languages/inlay-hints.ts

@@ -0,0 +1,149 @@
+// *****************************************************************************
+// Copyright (C) 2022 Ericsson and others.
+//
+// This program and the accompanying materials are made available under the
+// terms of the Eclipse Public License v. 2.0 which is available at
+// http://www.eclipse.org/legal/epl-2.0.
+//
+// This Source Code may also be made available under the following Secondary
+// Licenses when the conditions for such availability set forth in the Eclipse
+// Public License v. 2.0 are satisfied: GNU General Public License, version 2
+// with the GNU Classpath Exception which is available at
+// https://www.gnu.org/software/classpath/license.html.
+//
+// SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
+// *****************************************************************************
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+// copied and modified from https://github.com/microsoft/vscode/blob/1.65.0/src/vs/workbench/api/common/extHostLanguageFeatures.ts#L1178-L1288
+
+import * as theia from '@theia/plugin';
+import * as Converter from '../type-converters';
+import { Cache } from '../../common/cache';
+import { ChainedCacheId, InlayHint, InlayHintLabelPart, Range } from '../../common/plugin-api-rpc-model';
+import { CommandRegistryImpl } from '../command-registry';
+import { DisposableCollection } from '@theia/core/lib/common/disposable';
+import { DocumentsExtImpl } from '../documents';
+import { InlayHintDto, InlayHintsDto } from '../../common';
+import { URI } from '@theia/core/shared/vscode-uri';
+import { isLocationArray } from './util';
+
+export class InlayHintsAdapter {
+
+    private cache = new Cache<theia.InlayHint>('InlayHints');
+    private readonly disposables = new Map<number, DisposableCollection>();
+
+    constructor(
+        private readonly provider: theia.InlayHintsProvider,
+        private readonly documents: DocumentsExtImpl,
+        private readonly commands: CommandRegistryImpl
+    ) { }
+
+    async provideInlayHints(resource: URI, range: Range, token: theia.CancellationToken): Promise<InlayHintsDto | undefined> {
+        const documentData = this.documents.getDocumentData(resource);
+        if (!documentData) {
+            return Promise.reject(new Error(`There are no documents for ${resource}`));
+        }
+
+        const doc = documentData.document;
+        const ran = Converter.toRange(range);
+        const hints = await this.provider.provideInlayHints(doc, ran, token);
+
+        if (!Array.isArray(hints) || hints.length === 0) {
+            return undefined;
+        }
+
+        if (token.isCancellationRequested) {
+            return undefined;
+        }
+
+        const pid = this.cache.add(hints);
+        this.disposables.set(pid, new DisposableCollection());
+        const result: InlayHintsDto = { hints: [], cacheId: pid };
+
+        for (let i = 0; i < hints.length; i++) {
+            if (this.isValidInlayHint(hints[i], ran)) {
+                result.hints.push(this.convertInlayHint(hints[i], [pid, i]));
+            }
+        }
+
+        return result;
+    }
+
+    async resolveInlayHint(id: ChainedCacheId, token: theia.CancellationToken): Promise<InlayHint | undefined> {
+        if (typeof this.provider.resolveInlayHint !== 'function') {
+            return undefined;
+        }
+        const item = this.cache.get(...id);
+        if (!item) {
+            return undefined;
+        }
+        const hint = await this.provider.resolveInlayHint!(item, token);
+        if (!hint) {
+            return undefined;
+        }
+        if (!this.isValidInlayHint(hint)) {
+            return undefined;
+        }
+        return this.convertInlayHint(hint, id);
+    }
+
+    private isValidInlayHint(hint: theia.InlayHint, range?: theia.Range): boolean {
+        if (hint.label.length === 0 || Array.isArray(hint.label) && hint.label.every(part => part.value.length === 0)) {
+            return false;
+        }
+        if (range && !range.contains(hint.position)) {
+            return false;
+        }
+        return true;
+    }
+
+    private convertInlayHint(hint: theia.InlayHint, id: ChainedCacheId): InlayHintDto {
+
+        const disposables = this.disposables.get(id[0]);
+        if (!disposables) {
+            throw Error('DisposableCollection is missing...');
+        }
+
+        const result: InlayHintDto = {
+            label: '', // fill-in below.
+            cacheId: id,
+            tooltip: hint.tooltip,
+            position: Converter.fromPosition(hint.position),
+            textEdits: hint.textEdits && hint.textEdits.map(Converter.fromTextEdit),
+            kind: hint.kind && Converter.InlayHintKind.from(hint.kind),
+            paddingLeft: hint.paddingLeft,
+            paddingRight: hint.paddingRight,
+        };
+
+        if (typeof hint.label === 'string') {
+            result.label = hint.label;
+        } else {
+            result.label = hint.label.map(part => {
+                const partResult: InlayHintLabelPart = { label: part.value };
+                if (part.tooltip) {
+                    partResult.tooltip = typeof partResult === 'string' ? part.tooltip : Converter.fromMarkdown(part.tooltip);
+                }
+                if (isLocationArray(part.location)) {
+                    partResult.location = Converter.fromLocation(part.location);
+                }
+                if (part.command) {
+                    partResult.command = this.commands.converter.toSafeCommand(part.command, disposables);
+                }
+                return partResult;
+            });
+        }
+
+        return result;
+    }
+
+    async releaseHints(id: number): Promise<void> {
+        this.disposables.get(id)?.dispose();
+        this.disposables.delete(id);
+        this.cache.delete(id);
+    }
+
+}

package/src/plugin/languages/inline-values.ts

@@ -0,0 +1,50 @@
+// *****************************************************************************
+// Copyright (C) 2022 STMicroelectronics and others.
+//
+// This program and the accompanying materials are made available under the
+// terms of the Eclipse Public License v. 2.0 which is available at
+// http://www.eclipse.org/legal/epl-2.0.
+//
+// This Source Code may also be made available under the following Secondary
+// Licenses when the conditions for such availability set forth in the Eclipse
+// Public License v. 2.0 are satisfied: GNU General Public License, version 2
+// with the GNU Classpath Exception which is available at
+// https://www.gnu.org/software/classpath/license.html.
+//
+// SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
+// *****************************************************************************
+
+import { URI } from '@theia/core/shared/vscode-uri';
+import * as theia from '@theia/plugin';
+import { InlineValue, InlineValueContext, Range } from '../../common/plugin-api-rpc-model';
+import { DocumentsExtImpl } from '../documents';
+import * as Converter from '../type-converters';
+
+export class InlineValuesAdapter {
+
+    constructor(
+        private readonly provider: theia.InlineValuesProvider,
+        private readonly documents: DocumentsExtImpl
+    ) { }
+
+    async provideInlineValues(resource: URI, range: Range, context: InlineValueContext, token: theia.CancellationToken): Promise<InlineValue[] | undefined> {
+        const documentData = this.documents.getDocumentData(resource);
+        if (!documentData) {
+            return Promise.reject(new Error(`There is no document data for ${resource}`));
+        }
+
+        const document = documentData.document;
+        const viewPort = Converter.toRange(range);
+        const ctx = Converter.toInlineValueContext(context);
+
+        return Promise.resolve(this.provider.provideInlineValues(document, viewPort, ctx, token)).then(inlineValue => {
+            if (!inlineValue) {
+                return undefined;
+            }
+            if (Array.isArray(inlineValue)) {
+                return inlineValue.map(iv => Converter.fromInlineValue(iv));
+            }
+            return undefined;
+        });
+    }
+}

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

@@ -0,0 +1,117 @@
+// *****************************************************************************
+// Copyright (C) 2022 Ericsson and others.
+//
+// This program and the accompanying materials are made available under the
+// terms of the Eclipse Public License v. 2.0 which is available at
+// http://www.eclipse.org/legal/epl-2.0.
+//
+// This Source Code may also be made available under the following Secondary
+// Licenses when the conditions for such availability set forth in the Eclipse
+// Public License v. 2.0 are satisfied: GNU General Public License, version 2
+// with the GNU Classpath Exception which is available at
+// https://www.gnu.org/software/classpath/license.html.
+//
+// SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
+// *****************************************************************************
+
+import { URI } from '@theia/core/shared/vscode-uri';
+import * as theia from '@theia/plugin';
+import { IdGenerator } from '../../common/id-generator';
+import * as rpc from '../../common/plugin-api-rpc';
+import * as model from '../../common/plugin-api-rpc-model';
+import { DocumentsExtImpl } from '../documents';
+import { fromRange, SymbolKind } from '../type-converters';
+import * as types from '../types-impl';
+
+export class TypeHierarchyAdapter {
+
+    private readonly idGenerator = new IdGenerator('');
+    protected readonly cache = new Map<string, Map<string, theia.TypeHierarchyItem>>();
+
+    constructor(
+        private readonly provider: theia.TypeHierarchyProvider,
+        private readonly documents: DocumentsExtImpl,
+    ) { }
+
+    private fromTypeHierarchyItem(item: theia.TypeHierarchyItem, sessionId: string): model.TypeHierarchyItem {
+        const sessionCache = this.cache.get(sessionId)!;
+        const itemId = sessionCache.size.toString(36);
+
+        const definition: model.TypeHierarchyItem = {
+            _itemId: itemId,
+            _sessionId: sessionId,
+
+            kind: SymbolKind.fromSymbolKind(item.kind),
+            tags: item.tags,
+            name: item.name,
+            detail: item.detail,
+            uri: item.uri,
+
+            range: fromRange(item.range),
+            selectionRange: fromRange(item.selectionRange),
+        };
+        sessionCache.set(itemId, item);
+        return definition;
+    }
+
+    async prepareSession(uri: URI, position: rpc.Position, token: theia.CancellationToken): Promise<model.TypeHierarchyItem[] | undefined> {
+        const documentData = this.documents.getDocumentData(uri);
+        if (!documentData) {
+            return Promise.reject(new Error(`There is no document for ${uri}`));
+        }
+
+        const definition = await this.provider.prepareTypeHierarchy(documentData.document,
+            new types.Position(
+                position.lineNumber,
+                position.column
+            ),
+            token
+        );
+
+        if (!definition) {
+            return undefined;
+        }
+
+        const sessionId = this.idGenerator.nextId();
+
+        this.cache.set(sessionId, new Map());
+        return Array.isArray(definition) ? definition.map(item => this.fromTypeHierarchyItem(item, sessionId)) : [this.fromTypeHierarchyItem(definition, sessionId)];
+    }
+
+    async provideSupertypes(sessionId: string, itemId: string, token: theia.CancellationToken): Promise<model.TypeHierarchyItem[] | undefined> {
+        const item = this.fetchItemFromCatch(sessionId, itemId);
+        if (!item) {
+            throw new Error('missing type hierarchy item');
+        }
+        const supertypes = await this.provider.provideTypeHierarchySupertypes(item, token);
+        if (!supertypes) {
+            return undefined;
+        }
+        return supertypes.map(supertype => this.fromTypeHierarchyItem(supertype, sessionId));
+    }
+
+    async provideSubtypes(sessionId: string, itemId: string, token: theia.CancellationToken): Promise<model.TypeHierarchyItem[] | undefined> {
+        const item = this.fetchItemFromCatch(sessionId, itemId);
+        if (!item) {
+            throw new Error('missing type hierarchy item');
+        }
+        const subTypes = await this.provider.provideTypeHierarchySubtypes(item, token);
+        if (!subTypes) {
+            return undefined;
+        }
+        return subTypes.map(subtype => this.fromTypeHierarchyItem(subtype, sessionId));
+    }
+
+    private fetchItemFromCatch(sessionId: string, itemId: string): theia.TypeHierarchyItem | undefined {
+        return this.cache.get(sessionId!)?.get(itemId!);
+    }
+
+    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

@@ -25,6 +25,8 @@ import {
     WorkspaceEditDto,
     PluginInfo,
     Plugin,
+    InlayHintsDto,
+    InlayHintDto,
 } from '../common/plugin-api-rpc';
 import { RPCProtocol } from '../common/rpc-protocol';
 import * as theia from '@theia/plugin';
@@ -62,13 +64,17 @@ import {
     CallHierarchyIncomingCall,
     CallHierarchyOutgoingCall,
     LinkedEditingRanges,
-    EvaluatableExpression
+    EvaluatableExpression,
+    InlineValue,
+    InlineValueContext,
+    TypeHierarchyItem
 } from '../common/plugin-api-rpc-model';
 import { CompletionAdapter } from './languages/completion';
 import { Diagnostics } from './languages/diagnostics';
 import { SignatureHelpAdapter } from './languages/signature';
 import { HoverAdapter } from './languages/hover';
 import { EvaluatableExpressionAdapter } from './languages/evaluatable-expression';
+import { InlineValuesAdapter } from './languages/inline-values';
 import { DocumentHighlightAdapter } from './languages/document-highlight';
 import { DocumentFormattingAdapter } from './languages/document-formatting';
 import { RangeFormattingAdapter } from './languages/range-formatting';
@@ -91,6 +97,7 @@ import { Event } from '@theia/core/lib/common/event';
 import { CommandRegistryImpl } from './command-registry';
 import { DeclarationAdapter } from './languages/declaration';
 import { CallHierarchyAdapter } from './languages/call-hierarchy';
+import { TypeHierarchyAdapter } from './languages/type-hierarchy';
 import { BinaryBuffer } from '@theia/core/lib/common/buffer';
 import { DocumentSemanticTokensAdapter, DocumentRangeSemanticTokensAdapter } from './languages/semantic-highlighting';
 import { isReadonlyArray } from '../common/arrays';
@@ -98,11 +105,13 @@ import { DisposableCollection, disposableTimeout, Disposable as TheiaDisposable
 import { Severity } from '@theia/core/lib/common/severity';
 import { LinkedEditingRangeAdapter } from './languages/linked-editing-range';
 import { serializeEnterRules, serializeIndentation, serializeRegExp } from './languages-utils';
+import { InlayHintsAdapter } from './languages/inlay-hints';
 
 type Adapter = CompletionAdapter |
     SignatureHelpAdapter |
     HoverAdapter |
     EvaluatableExpressionAdapter |
+    InlineValuesAdapter |
     DocumentHighlightAdapter |
     DocumentFormattingAdapter |
     RangeFormattingAdapter |
@@ -120,11 +129,13 @@ type Adapter = CompletionAdapter |
     FoldingProviderAdapter |
     SelectionRangeProviderAdapter |
     ColorProviderAdapter |
+    InlayHintsAdapter |
     RenameAdapter |
     CallHierarchyAdapter |
     DocumentRangeSemanticTokensAdapter |
     DocumentSemanticTokensAdapter |
-    LinkedEditingRangeAdapter;
+    LinkedEditingRangeAdapter |
+    TypeHierarchyAdapter;
 
 export class LanguagesExtImpl implements LanguagesExt {
 
@@ -365,6 +376,25 @@ export class LanguagesExtImpl implements LanguagesExt {
     }
     // ### EvaluatableExpression Provider end
 
+    // ### InlineValues Provider begin
+    registerInlineValuesProvider(selector: theia.DocumentSelector, provider: theia.InlineValuesProvider, pluginInfo: PluginInfo): theia.Disposable {
+        const eventHandle = typeof provider.onDidChangeInlineValues === 'function' ? this.nextCallId() : undefined;
+        const callId = this.addNewAdapter(new InlineValuesAdapter(provider, this.documents));
+        this.proxy.$registerInlineValuesProvider(callId, pluginInfo, this.transformDocumentSelector(selector));
+        let result = this.createDisposable(callId);
+
+        if (eventHandle !== undefined) {
+            const subscription = provider.onDidChangeInlineValues!(_ => this.proxy.$emitInlineValuesEvent(eventHandle));
+            result = Disposable.from(result, subscription);
+        }
+        return result;
+    }
+
+    $provideInlineValues(handle: number, resource: UriComponents, range: Range, context: InlineValueContext, token: theia.CancellationToken): Promise<InlineValue[] | undefined> {
+        return this.withAdapter(handle, InlineValuesAdapter, adapter => adapter.provideInlineValues(URI.revive(resource), range, context, token), undefined);
+    }
+    // ### InlineValue Provider end
+
     // ### Document Highlight Provider begin
     registerDocumentHighlightProvider(selector: theia.DocumentSelector, provider: theia.DocumentHighlightProvider, pluginInfo: PluginInfo): theia.Disposable {
         const callId = this.addNewAdapter(new DocumentHighlightAdapter(provider, this.documents));
@@ -579,6 +609,35 @@ export class LanguagesExtImpl implements LanguagesExt {
     }
     // ### Color Provider end
 
+    // ### InlayHints Provider begin
+    registerInlayHintsProvider(selector: theia.DocumentSelector, provider: theia.InlayHintsProvider, pluginInfo: PluginInfo): theia.Disposable {
+        const eventHandle = typeof provider.onDidChangeInlayHints === 'function' ? this.nextCallId() : undefined;
+        const callId = this.addNewAdapter(new InlayHintsAdapter(provider, this.documents, this.commands));
+        this.proxy.$registerInlayHintsProvider(callId, pluginInfo, this.transformDocumentSelector(selector));
+
+        let result = this.createDisposable(callId);
+
+        if (eventHandle !== undefined) {
+            const subscription = provider.onDidChangeInlayHints!(() => this.proxy.$emitInlayHintsEvent(eventHandle));
+            result = Disposable.from(result, subscription);
+        }
+
+        return result;
+    }
+
+    $provideInlayHints(handle: number, resource: UriComponents, range: Range, token: theia.CancellationToken): Promise<InlayHintsDto | undefined> {
+        return this.withAdapter(handle, InlayHintsAdapter, adapter => adapter.provideInlayHints(URI.revive(resource), range, token), undefined);
+    }
+
+    $resolveInlayHint(handle: number, id: ChainedCacheId, token: theia.CancellationToken): Promise<InlayHintDto | undefined> {
+        return this.withAdapter(handle, InlayHintsAdapter, adapter => adapter.resolveInlayHint(id, token), undefined);
+    }
+
+    $releaseInlayHints(handle: number, id: number): void {
+        this.withAdapter(handle, InlayHintsAdapter, async adapter => adapter.releaseHints(id), undefined);
+    }
+    // ### InlayHints Provider end
+
     // ### Folding Range Provider begin
     registerFoldingRangeProvider(selector: theia.DocumentSelector, provider: theia.FoldingRangeProvider, pluginInfo: PluginInfo): theia.Disposable {
         const callId = this.addNewAdapter(new FoldingProviderAdapter(provider, this.documents));
@@ -656,6 +715,53 @@ export class LanguagesExtImpl implements LanguagesExt {
     }
     // ### Call Hierarchy Provider end
 
+    // ### Type hierarchy Provider begin
+    registerTypeHierarchyProvider(selector: theia.DocumentSelector, provider: theia.TypeHierarchyProvider): theia.Disposable {
+        const callId = this.addNewAdapter(new TypeHierarchyAdapter(provider, this.documents));
+        this.proxy.$registerTypeHierarchyProvider(callId, this.transformDocumentSelector(selector));
+        return this.createDisposable(callId);
+    }
+
+    $prepareTypeHierarchy(handle: number, resource: UriComponents, location: Position, token: theia.CancellationToken
+    ): Promise<TypeHierarchyItem[] | undefined> {
+        return this.withAdapter(
+            handle,
+            TypeHierarchyAdapter,
+            adapter => adapter.prepareSession(URI.revive(resource), location, token),
+            undefined
+        );
+    }
+
+    $provideSuperTypes(handle: number, sessionId: string, itemId: string, token: theia.CancellationToken):
+        Promise<TypeHierarchyItem[] | undefined> {
+        return this.withAdapter(
+            handle,
+            TypeHierarchyAdapter,
+            adapter => adapter.provideSupertypes(sessionId, itemId, token),
+            undefined
+        );
+    }
+
+    $provideSubTypes(handle: number, sessionId: string, itemId: string, token: theia.CancellationToken):
+        Promise<TypeHierarchyItem[] | undefined> {
+        return this.withAdapter(
+            handle,
+            TypeHierarchyAdapter,
+            adapter => adapter.provideSubtypes(sessionId, itemId, token),
+            undefined
+        );
+    }
+
+    $releaseTypeHierarchy(handle: number, session?: string): Promise<boolean> {
+        return this.withAdapter(
+            handle,
+            TypeHierarchyAdapter,
+            adapter => adapter.releaseSession(session),
+            false);
+    }
+
+    // ### Type hierarchy Provider end
+
     // ### Linked Editing Range Provider begin
     registerLinkedEditingRangeProvider(selector: theia.DocumentSelector, provider: theia.LinkedEditingRangeProvider): theia.Disposable {
         const handle = this.addNewAdapter(new LinkedEditingRangeAdapter(this.documents, provider));

package/src/plugin/plugin-context.ts

@@ -79,6 +79,10 @@ import {
     SignatureHelpTriggerKind,
     Hover,
     EvaluatableExpression,
+    InlineValueEvaluatableExpression,
+    InlineValueText,
+    InlineValueVariableLookup,
+    InlineValueContext,
     DocumentHighlightKind,
     DocumentHighlight,
     DocumentLink,
@@ -130,6 +134,7 @@ import {
     CallHierarchyItem,
     CallHierarchyIncomingCall,
     CallHierarchyOutgoingCall,
+    TypeHierarchyItem,
     TimelineItem,
     EnvironmentVariableMutatorType,
     SemanticTokensLegend,
@@ -145,7 +150,11 @@ import {
     LinkedEditingRanges,
     LanguageStatusSeverity,
     TextDocumentChangeReason,
-    InputBoxValidationSeverity
+    InputBoxValidationSeverity,
+    TerminalLink,
+    InlayHint,
+    InlayHintKind,
+    InlayHintLabelPart
 } from './types-impl';
 import { AuthenticationExtImpl } from './authentication-ext';
 import { SymbolKind } from '../common/plugin-api-rpc-model';
@@ -235,14 +244,17 @@ export function createAPIFactory(
                 return authenticationExt.onDidChangeSessions;
             }
         };
+        function commandIsDeclaredInPackage(id: string, model: PluginPackage): boolean {
+            const rawCommands = model.contributes?.commands;
+            if (!rawCommands) { return false; }
+            return Array.isArray(rawCommands) ? rawCommands.some(candidate => candidate.command === id) : rawCommands.command === id;
+        }
         const commands: typeof theia.commands = {
             // eslint-disable-next-line @typescript-eslint/no-explicit-any
             registerCommand(command: theia.CommandDescription | string, handler?: <T>(...args: any[]) => T | Thenable<T | undefined>, thisArg?: any): Disposable {
                 // use of the ID when registering commands
                 if (typeof command === 'string') {
-                    const rawCommands = plugin.rawModel.contributes && plugin.rawModel.contributes.commands;
-                    const contributedCommands = rawCommands ? Array.isArray(rawCommands) ? rawCommands : [rawCommands] : undefined;
-                    if (handler && contributedCommands && contributedCommands.some(item => item.command === command)) {
+                    if (handler && commandIsDeclaredInPackage(command, plugin.rawModel)) {
                         return commandRegistry.registerHandler(command, handler, thisArg);
                     }
                     return commandRegistry.registerCommand({ id: command }, handler, thisArg);
@@ -254,7 +266,7 @@ export function createAPIFactory(
                 return commandRegistry.executeCommand<T>(commandId, ...args);
             },
             registerTextEditorCommand(command: string, handler: (textEditor: theia.TextEditor, edit: theia.TextEditorEdit, ...arg: any[]) => void, thisArg?: any): Disposable {
-                return commandRegistry.registerCommand({ id: command }, (...args: any[]): any => {
+                const internalHandler = (...args: any[]): any => {
                     const activeTextEditor = editors.getActiveEditor();
                     if (!activeTextEditor) {
                         console.warn('Cannot execute ' + command + ' because there is no active text editor.');
@@ -271,7 +283,10 @@ export function createAPIFactory(
                     }, err => {
                         console.warn('An error occurred while running command ' + command, err);
                     });
-                });
+                };
+                return commandIsDeclaredInPackage(command, plugin.rawModel)
+                    ? commandRegistry.registerHandler(command, internalHandler)
+                    : commandRegistry.registerCommand({ id: command }, internalHandler);
             },
             // eslint-disable-next-line @typescript-eslint/no-explicit-any
             registerHandler(commandId: string, handler: (...args: any[]) => any, thisArg?: any): Disposable {
@@ -289,7 +304,7 @@ export function createAPIFactory(
             }
         };
 
-        const { onDidChangeActiveTerminal, onDidCloseTerminal, onDidOpenTerminal } = terminalExt;
+        const { onDidChangeActiveTerminal, onDidChangeTerminalState, onDidCloseTerminal, onDidOpenTerminal } = terminalExt;
         const showInformationMessage = messageRegistryExt.showMessage.bind(messageRegistryExt, MainMessageType.Info);
         const showWarningMessage = messageRegistryExt.showMessage.bind(messageRegistryExt, MainMessageType.Warning);
         const showErrorMessage = messageRegistryExt.showMessage.bind(messageRegistryExt, MainMessageType.Error);
@@ -439,6 +454,7 @@ export function createAPIFactory(
                 shellArgs?: string[]): theia.Terminal {
                 return terminalExt.createTerminal(nameOrOptions, shellPath, shellArgs);
             },
+            onDidChangeTerminalState,
             onDidCloseTerminal,
             onDidOpenTerminal,
             createTextEditorDecorationType(options: theia.DecorationRenderOptions): theia.TextEditorDecorationType {
@@ -466,8 +482,8 @@ export function createAPIFactory(
             createInputBox(): theia.InputBox {
                 return quickOpenExt.createInputBox(plugin);
             },
-            registerTerminalLinkProvider(provider: theia.TerminalLinkProvider): void {
-                /* NOOP. To be implemented at later stage */
+            registerTerminalLinkProvider(provider: theia.TerminalLinkProvider): theia.Disposable {
+                return terminalExt.registerTerminalLinkProvider(provider);
             },
             get activeColorTheme(): theia.ColorTheme {
                 return themingExt.activeColorTheme;
@@ -700,6 +716,9 @@ export function createAPIFactory(
             registerEvaluatableExpressionProvider(selector: theia.DocumentSelector, provider: theia.EvaluatableExpressionProvider): theia.Disposable {
                 return languagesExt.registerEvaluatableExpressionProvider(selector, provider, pluginToPluginInfo(plugin));
             },
+            registerInlineValuesProvider(selector: theia.DocumentSelector, provider: theia.InlineValuesProvider): theia.Disposable {
+                return languagesExt.registerInlineValuesProvider(selector, provider, pluginToPluginInfo(plugin));
+            },
             registerDocumentHighlightProvider(selector: theia.DocumentSelector, provider: theia.DocumentHighlightProvider): theia.Disposable {
                 return languagesExt.registerDocumentHighlightProvider(selector, provider, pluginToPluginInfo(plugin));
             },
@@ -739,6 +758,9 @@ export function createAPIFactory(
             registerColorProvider(selector: theia.DocumentSelector, provider: theia.DocumentColorProvider): theia.Disposable {
                 return languagesExt.registerColorProvider(selector, provider, pluginToPluginInfo(plugin));
             },
+            registerInlayHintsProvider(selector: theia.DocumentSelector, provider: theia.InlayHintsProvider): theia.Disposable {
+                return languagesExt.registerInlayHintsProvider(selector, provider, pluginToPluginInfo(plugin));
+            },
             registerFoldingRangeProvider(selector: theia.DocumentSelector, provider: theia.FoldingRangeProvider): theia.Disposable {
                 return languagesExt.registerFoldingRangeProvider(selector, provider, pluginToPluginInfo(plugin));
             },
@@ -759,6 +781,9 @@ export function createAPIFactory(
             registerCallHierarchyProvider(selector: theia.DocumentSelector, provider: theia.CallHierarchyProvider): theia.Disposable {
                 return languagesExt.registerCallHierarchyProvider(selector, provider);
             },
+            registerTypeHierarchyProvider(selector: theia.DocumentSelector, provider: theia.TypeHierarchyProvider): theia.Disposable {
+                return languagesExt.registerTypeHierarchyProvider(selector, provider);
+            },
             registerLinkedEditingRangeProvider(selector: theia.DocumentSelector, provider: theia.LinkedEditingRangeProvider): theia.Disposable {
                 return languagesExt.registerLinkedEditingRangeProvider(selector, provider);
             },
@@ -961,6 +986,10 @@ export function createAPIFactory(
             SignatureHelpTriggerKind,
             Hover,
             EvaluatableExpression,
+            InlineValueEvaluatableExpression,
+            InlineValueText,
+            InlineValueVariableLookup,
+            InlineValueContext,
             DocumentHighlightKind,
             DocumentHighlight,
             DocumentLink,
@@ -1013,6 +1042,7 @@ export function createAPIFactory(
             CallHierarchyItem,
             CallHierarchyIncomingCall,
             CallHierarchyOutgoingCall,
+            TypeHierarchyItem,
             TimelineItem,
             EnvironmentVariableMutatorType,
             SemanticTokensLegend,
@@ -1024,10 +1054,14 @@ export function createAPIFactory(
             ColorThemeKind,
             SourceControlInputBoxValidationType,
             FileDecoration,
+            TerminalLink,
             CancellationError,
             ExtensionMode,
             LinkedEditingRanges,
-            InputBoxValidationSeverity
+            InputBoxValidationSeverity,
+            InlayHint,
+            InlayHintKind,
+            InlayHintLabelPart
         };
     };
 }