@adecore/editor-react 0.42.0 → 0.43.0

package/src/editor-language.ts

@@ -1,6 +1,10 @@
 import { KEYMAP, type Keymap } from '@adecore/editor/keymap';
 import type { Editor, EditorKeyHandler, EditorPosition } from '@adecore/editor';
-import type { Location } from '@adecore/lsp';
+import type { LanguageService, Location, TextDocumentSaveReason } from '@adecore/lsp';
+import { DocumentColorsFeature } from './document-colors.ts';
+import { DocumentLinksFeature } from './document-links.ts';
+import { InlineCompletionFeature } from './inline-completion.ts';
+import { LinkedEditingFeature } from './linked-editing.ts';
 import { CallHierarchyFeature } from './call-hierarchy.ts';
 import { CodeActionsFeature } from './code-actions.ts';
 import { CodeVisionFeature } from './code-vision.ts';
@@ -14,7 +18,9 @@ import { HighlightsFeature } from './highlights.ts';
 import { HistoryFeature } from './history.ts';
 import { HoverFeature } from './hover.ts';
 import { KeyDispatcher } from './key-priority.ts';
+import { MarkupFeature } from './markup.ts';
 import { NavigationFeature, locationRow } from './navigation.ts';
+import { PasteHistoryFeature } from './paste-history.ts';
 import { PeekFeature } from './peek.ts';
 import { PickFeature } from './pick.ts';
 import { SymbolPickerFeature } from './symbol-picker.ts';
@@ -32,10 +38,15 @@ import { SymbolsFeature } from './symbols.ts';
 import type { Place } from './navigation-history.ts';
 import type { LanguageDocumentHandle, ProjectLanguage } from './project-language.ts';
 
+/* How long the edits servers want before a save are waited for. */
+const SAVE_PARTICIPANT_MS = 1_000;
+
 /* What an app tunes about the features of one editor. */
 export interface EditorLanguageOptions {
     /* Where a document counts as large for semantic tokens. */
     semanticTokens?: SemanticTokensOptions;
+    /* False for a document no server serves: it counts as open in the project and the features stay inert. True by default. */
+    serve?: boolean;
 }
 
 /*
@@ -51,6 +62,9 @@ export class EditorLanguage {
     readonly document: LanguageDocumentHandle;
     readonly languageId: string;
 
+    /* Whether a server serves this document; read it where a host meant "a language server is behind this editor". */
+    readonly served: boolean;
+
     /* What the features of this editor have open over it: the hover card, the suggestions, the signature. */
     readonly popups = createPopupStore();
 
@@ -60,6 +74,7 @@ export class EditorLanguage {
     readonly completion: CompletionFeature;
     readonly signature: SignatureFeature;
     readonly snippets: SnippetFeature;
+    readonly markup: MarkupFeature;
     readonly highlights: HighlightsFeature;
     readonly pick: PickFeature;
     readonly codeActions: CodeActionsFeature;
@@ -75,8 +90,14 @@ export class EditorLanguage {
     readonly codeVision: CodeVisionFeature;
     readonly formatOnType: FormatOnTypeFeature;
     readonly renderedDocs: RenderedDocsFeature;
+    readonly pasteHistory: PasteHistoryFeature;
+    readonly links: DocumentLinksFeature;
+    readonly colors: DocumentColorsFeature;
+    readonly linkedEditing: LinkedEditingFeature;
+    readonly inlineCompletion: InlineCompletionFeature;
     private readonly disposers: Array<() => void> = [];
     private readonly keys = new KeyDispatcher();
+    private readonly timers: Timers;
     private disposed = false;
 
     constructor(project: ProjectLanguage, editor: Editor, uri: string, languageId: string, timers: Timers = realTimers, options: EditorLanguageOptions = {}) {
@@ -86,13 +107,16 @@ export class EditorLanguage {
         this.shortcuts = shortcutsOf(this.keymap, this.apple);
         this.project = project;
         this.languageId = languageId;
-        this.document = project.acquire(uri, languageId, editor);
+        this.served = options.serve ?? true;
+        this.document = project.acquire(uri, languageId, editor, { serve: this.served });
+        this.timers = timers;
         this.onDispose(editor.onKeyDown((event) => this.keys.dispatch(event)));
         this.pick = new PickFeature(this, timers);
         this.diagnostics = new DiagnosticsFeature(this);
         this.hover = new HoverFeature(this, timers);
         this.completion = new CompletionFeature(this, timers);
         this.snippets = new SnippetFeature(this, timers);
+        this.markup = new MarkupFeature(this);
         this.signature = new SignatureFeature(this, timers);
         this.highlights = new HighlightsFeature(this, timers);
         this.symbols = new SymbolsFeature(this, timers);
@@ -101,6 +125,11 @@ export class EditorLanguage {
         this.inlayHints = new InlayHintsFeature(this, timers);
         this.codeActions = new CodeActionsFeature(this, timers);
         this.rename = new RenameFeature(this);
+        // Before navigation, whose Mod+click goes to a definition: a link under the pointer goes first.
+        this.links = new DocumentLinksFeature(this, timers);
+        this.colors = new DocumentColorsFeature(this, timers);
+        this.linkedEditing = new LinkedEditingFeature(this, timers);
+        this.inlineCompletion = new InlineCompletionFeature(this, timers);
         this.navigation = new NavigationFeature(this);
         this.peek = new PeekFeature(this, timers);
         this.callHierarchy = new CallHierarchyFeature(this, timers);
@@ -111,7 +140,17 @@ export class EditorLanguage {
         this.codeVision = new CodeVisionFeature(this, (listener) => this.symbols.onResult(listener), timers);
         this.formatOnType = new FormatOnTypeFeature(this);
         this.renderedDocs = new RenderedDocsFeature(this, timers);
+        this.pasteHistory = new PasteHistoryFeature(this);
         new FoldingFeature(this, (listener) => this.symbols.onResult(listener), timers);
+
+        const copies = editor.onCopy?.((copy) => project.clipboard.add(copy.text, { wholeLines: copy.wholeLines }));
+
+        if (copies !== undefined) {
+            this.onDispose(copies);
+        }
+
+        editor.setWordSources?.(() => this.otherTexts());
+        this.onDispose(() => editor.setWordSources?.(null));
         this.placeOpenedCaret(editor.getCaret());
         this.onDispose(editor.onCaret((position) => this.placeOpenedCaret(position)));
     }
@@ -120,6 +159,11 @@ export class EditorLanguage {
         return this.document.uri;
     }
 
+    /* The service this document is asked through: the project's, or one that answers nothing when no server serves it. */
+    get service(): LanguageService {
+        return this.document.service;
+    }
+
     get isDisposed(): boolean {
         return this.disposed;
     }
@@ -173,7 +217,7 @@ export class EditorLanguage {
             () => undefined
         );
 
-        const providers = this.project.service.onProvidersChanged((uri) => {
+        const providers = this.service.onProvidersChanged((uri) => {
             if (uri === this.uri) {
                 listener();
             }
@@ -193,6 +237,31 @@ export class EditorLanguage {
         return this.keys.add(handler, priority);
     }
 
+    /*
+     * Lets the servers in before the host writes the file: tells them a save is coming and applies the edits they
+     * want made first, such as organized imports. A server that has not answered within a second is passed over,
+     * as the specification allows. Call it, then save, then let the service send `didSave`.
+     */
+    async prepareSave(reason: TextDocumentSaveReason = 1): Promise<void> {
+        const { service } = this.project;
+        await service.willSave?.(this.uri, reason).catch(() => undefined);
+        if (service.willSaveWaitUntil === undefined) {
+            return;
+        }
+        const controller = new AbortController();
+        const timer = this.timers.set(() => controller.abort(), SAVE_PARTICIPANT_MS);
+        try {
+            const edits = await service.willSaveWaitUntil(this.uri, reason, { signal: controller.signal });
+            if (!controller.signal.aborted && edits !== null && edits.length > 0) {
+                this.editor.applyEdits(edits.map((edit) => ({ range: edit.range, text: edit.newText })));
+            }
+        } catch {
+            // A server that fails or is too slow does not keep the file from being saved.
+        } finally {
+            this.timers.clear(timer);
+        }
+    }
+
     /* Runs `dispose` when the editor lets go of its document. */
     onDispose(dispose: () => void): void {
         this.disposers.push(dispose);
@@ -212,6 +281,14 @@ export class EditorLanguage {
         this.document.release();
     }
 
+    /* The texts of the other open editors of the project, which Hippie completion takes words from. */
+    private otherTexts(): string[] {
+        return this.project
+            .openEditors()
+            .filter((open) => open.uri !== this.uri)
+            .map((open) => open.editor.getText());
+    }
+
     /* A file opened from another one lands on the line; this puts the caret on the column the jump meant. */
     private placeOpenedCaret(position: EditorPosition): void {
         const column = this.project.takeCaret(this.uri, position.line);

package/src/emmet-module.d.ts

@@ -0,0 +1,44 @@
+// The package ships `dist/index.d.ts`, but its `exports` point TypeScript at none, so the part used here is declared again.
+declare module 'emmet' {
+    export interface MarkupAbbreviationNode {
+        name?: string;
+        children: MarkupAbbreviationNode[];
+    }
+
+    export interface MarkupAbbreviation {
+        type: 'Abbreviation';
+        children: MarkupAbbreviationNode[];
+    }
+
+    export interface ExtractedAbbreviation {
+        abbreviation: string;
+        location: number;
+        start: number;
+        end: number;
+    }
+
+    export interface ExtractOptions {
+        lookAhead: boolean;
+        type: 'markup' | 'stylesheet';
+        prefix: string;
+    }
+
+    export interface UserConfig {
+        syntax?: string;
+        text?: string | string[];
+        options?: {
+            'output.field'?: (index: number, placeholder: string, offset: number, line: number, column: number) => string;
+            'output.text'?: (text: string, offset: number, line: number, column: number) => string;
+            'output.indent'?: string;
+        };
+    }
+
+    export interface Config extends UserConfig {
+        type: 'markup' | 'stylesheet';
+    }
+
+    export function extract(line: string, pos?: number, options?: Partial<ExtractOptions>): ExtractedAbbreviation | undefined;
+    export function markupAbbreviation(abbreviation: string, options?: { text?: string | string[] }): MarkupAbbreviation;
+    export function markup(abbreviation: string | MarkupAbbreviation, config: Config): string;
+    export function resolveConfig(config?: UserConfig): Config;
+}

package/src/emmet.ts

@@ -0,0 +1,73 @@
+// A reference and no import, so an app that type-checks this source reads the declaration of the package too.
+// oxlint-disable-next-line typescript/triple-slash-reference
+/// <reference path="./emmet-module.d.ts" />
+import { extract, markup, markupAbbreviation, resolveConfig, type MarkupAbbreviationNode } from 'emmet';
+import type { MarkupSyntax } from './markup-context.ts';
+
+export interface AbbreviationOptions {
+    readonly syntax: MarkupSyntax;
+    /* One level of indentation inside the expansion. */
+    readonly indent: string;
+    /* Lines the abbreviation wraps; a repeated element without a count takes one line each. */
+    readonly wrap?: readonly string[];
+}
+
+export interface FoundAbbreviation {
+    readonly abbreviation: string;
+    /* UTF-16 columns of the line, `end` past the caret when brackets the editor closed follow it. */
+    readonly start: number;
+    readonly end: number;
+}
+
+/* A text of an expansion is snippet syntax, where these mean a tab stop or end one. */
+function escapeText(text: string): string {
+    return text.replace(/[$}\\]/g, '\\$&');
+}
+
+function field(index: number, placeholder: string): string {
+    return placeholder === '' ? `\${${index}}` : `\${${index}:${escapeText(placeholder)}}`;
+}
+
+/* `lipsum` is the other name of `lorem` that IntelliJ and the Emmet documentation accept. */
+function renameLipsum(node: MarkupAbbreviationNode): void {
+    if (node.name !== undefined && /^lipsum(?=\d|$)/i.test(node.name)) {
+        node.name = 'lorem' + node.name.slice(6);
+    }
+    for (const child of node.children) {
+        renameLipsum(child);
+    }
+}
+
+/* The abbreviation that ends at `character` of a line, or null where nothing before the caret reads as one. */
+export function abbreviationBefore(line: string, character: number): FoundAbbreviation | null {
+    const found = extract(line, character, { type: 'markup', lookAhead: true });
+    if (found === undefined || !/^[A-Za-z!.#([{]/.test(found.abbreviation)) {
+        return null;
+    }
+    return { abbreviation: found.abbreviation, start: found.start, end: found.end };
+}
+
+/*
+ * The expansion of an abbreviation as snippet text, its places to fill as tab stops; null when it does not
+ * read as one. Lorem ipsum words after the first sentence differ per expansion.
+ */
+export function expandAbbreviation(abbreviation: string, options: AbbreviationOptions): string | null {
+    const text = options.wrap === undefined ? undefined : [...options.wrap];
+    try {
+        const tree = markupAbbreviation(abbreviation, { text });
+        for (const child of tree.children) {
+            renameLipsum(child);
+        }
+        const expanded = markup(
+            tree,
+            resolveConfig({
+                syntax: options.syntax === 'xml' ? 'xml' : 'html',
+                text,
+                options: { 'output.field': field, 'output.text': escapeText, 'output.indent': options.indent }
+            })
+        );
+        return expanded === '' ? null : expanded;
+    } catch {
+        return null;
+    }
+}

package/src/folding.ts

@@ -58,15 +58,15 @@ export class FoldingFeature {
 
     constructor(language: EditorLanguage, onSymbols: (listener: (result: DocumentSymbolResult) => void) => () => void, timers: Timers = realTimers) {
         this.language = language;
-        const { editor, project, uri } = language;
+        const { editor, uri } = language;
 
         this.refresher = new Refresher(
             async (signal) => {
-                if (!project.service.supports(METHOD, uri)) {
+                if (!language.service.supports(METHOD, uri)) {
                     return;
                 }
 
-                const ranges = await project.service.foldingRanges(uri, { signal });
+                const ranges = await language.service.foldingRanges(uri, { signal });
 
                 if (!signal.aborted) {
                     this.ranges = foldRangesOf(ranges);

package/src/format-on-type.ts

@@ -52,9 +52,9 @@ export class FormatOnTypeFeature {
 
     /* Whether the server of this document formats on type and the service can ask it. */
     get supported(): boolean {
-        const { project, uri } = this.language;
+        const { uri } = this.language;
 
-        return project.service.onTypeFormatting !== undefined && project.service.supports(METHOD, uri);
+        return this.language.service.onTypeFormatting !== undefined && this.language.service.supports(METHOD, uri);
     }
 
     configure(enabled: boolean): void {
@@ -67,7 +67,7 @@ export class FormatOnTypeFeature {
 
     /* The characters that ask the server, the first one and the more. */
     triggerCharacters(): readonly string[] {
-        const options = this.language.project.service.providerOptions(METHOD, this.language.uri);
+        const options = this.language.service.providerOptions(METHOD, this.language.uri);
 
         return options === undefined
             ? []
@@ -99,12 +99,12 @@ export class FormatOnTypeFeature {
     }
 
     private async ask(revision: number, typed: string, caret: { line: number; character: number }, signal: AbortSignal): Promise<void> {
-        const { editor, project, uri, document } = this.language;
+        const { editor, uri, document } = this.language;
 
         try {
             // The change of the typed character reaches the server before this question does.
             await document.ready;
-            const edits = await project.service.onTypeFormatting!(uri, caret, typed, { ...editor.getIndentation() }, { signal });
+            const edits = await this.language.service.onTypeFormatting!(uri, caret, typed, { ...editor.getIndentation() }, { signal });
             const here = editor.getCaret();
             const stale = revision !== this.revision || this.language.isDisposed || comparePositions(here, caret) !== 0;
 

package/src/highlights.ts

@@ -46,17 +46,17 @@ export class HighlightsFeature {
 
     constructor(language: EditorLanguage, timers: Timers = realTimers) {
         this.language = language;
-        const { editor, project, uri } = language;
+        const { editor, uri } = language;
 
         this.refresher = new Refresher(
             async (signal) => {
-                if (!project.service.supports(METHOD, uri) || !this.onName()) {
+                if (!language.service.supports(METHOD, uri) || !this.onName()) {
                     this.clear();
 
                     return;
                 }
 
-                const result = await project.service.documentHighlights(uri, editor.getCaret(), { signal });
+                const result = await language.service.documentHighlights(uri, editor.getCaret(), { signal });
 
                 if (!signal.aborted) {
                     this.set(result === null ? [] : editorHighlightsOf(result));

package/src/history.ts

@@ -1,3 +1,5 @@
+import type { EditorPosition, EditorTextChange } from '@adecore/editor';
+import type { EditPlace } from './edit-locations.ts';
 import type { EditorLanguage } from './editor-language.ts';
 import { KEY_PRIORITY } from './key-priority.ts';
 import type { Place } from './navigation-history.ts';
@@ -6,6 +8,7 @@ import { isShortcut } from './shortcut-keys.ts';
 /* Back, Forward and the list of recent locations over the history the whole project shares. */
 export class HistoryFeature {
     private readonly language: EditorLanguage;
+    private editing = false;
 
     constructor(language: EditorLanguage) {
         this.language = language;
@@ -29,10 +32,42 @@ export class HistoryFeature {
                 return true;
             }
 
+            if (isShortcut(this.language.shortcuts.lastEditLocation, event)) {
+                this.lastEdit();
+
+                return true;
+            }
+
+            if (isShortcut(this.language.shortcuts.nextEditLocation, event)) {
+                this.nextEdit();
+
+                return true;
+            }
+
             return false;
         }, KEY_PRIORITY.history);
 
-        language.onDispose(off);
+        // A jump of the editor's own, such as Method Down, is a place Back returns to like any other jump.
+        const navigations = language.editor.onNavigate?.((from) => language.project.history.record({ uri: language.uri, position: from }));
+        const changes = language.editor.onTextChange((change) => this.edited(change));
+        const carets = language.editor.onCaret((position) => this.moved(position));
+
+        language.onDispose(() => {
+            off();
+            navigations?.();
+            changes();
+            carets();
+        });
+    }
+
+    /* Goes to where the project was edited before the carets' place; false when there is no such place. */
+    lastEdit(): boolean {
+        return this.visitEdit(this.language.project.edits.previous(this.currentEdit()));
+    }
+
+    /* Goes to where the project was edited after the place Last Edit Location came back to. */
+    nextEdit(): boolean {
+        return this.visitEdit(this.language.project.edits.next(this.currentEdit()));
     }
 
     /* Returns to where the caret was before the last jump; false when there is no such place. */
@@ -55,6 +90,51 @@ export class HistoryFeature {
         );
     }
 
+    private currentEdit(): EditPlace {
+        return { uri: this.language.uri, selections: this.language.editor.getSelections() };
+    }
+
+    /* Every edit moves the places of the file; one a person made counts as an edit location once the caret has settled. */
+    private edited(change: EditorTextChange): void {
+        const { editor, project, uri } = this.language;
+
+        project.edits.map(uri, change.changes);
+        this.editing = true;
+
+        queueMicrotask(() => {
+            this.editing = false;
+
+            if (change.source !== 'external' && editor.hasFocus?.() !== false && !this.language.isDisposed) {
+                project.edits.record(this.currentEdit());
+            }
+        });
+    }
+
+    /* A caret that moves on its own ends the walk through the edits, unless an edit moved it. */
+    private moved(position: EditorPosition): void {
+        if (!this.editing) {
+            this.language.project.edits.moved(this.language.uri, position);
+        }
+    }
+
+    private visitEdit(place: EditPlace | null): boolean {
+        if (place === null) {
+            return false;
+        }
+
+        const { editor, project, uri } = this.language;
+
+        if (place.uri === uri) {
+            editor.setSelections(place.selections, 'center');
+            editor.focus();
+        } else {
+            // Another file opens on one caret, the primary.
+            project.openPlace({ uri: place.uri, position: place.selections.at(-1)!.end });
+        }
+
+        return true;
+    }
+
     private visit(place: Place | null): boolean {
         if (place === null) {
             return false;

package/src/host-types.ts

@@ -2,9 +2,11 @@ import type { WorkerRequestPort } from '@adecore/editor/worker-client';
 import type { EditorPosition, EditorRange } from '@adecore/editor';
 import type { i18n } from 'i18next';
 import type { Keymap } from '@adecore/editor/keymap';
+import type { ClipboardHistory } from './clipboard-history.ts';
 import type { ProjectFiles } from './workspace-edit.ts';
 import type { Place } from './navigation-history.ts';
 import type { ProblemSource } from './project-problems.ts';
+import type { ServerMessage } from '@adecore/lsp';
 
 export interface DiskText {
     text: string;
@@ -64,6 +66,10 @@ export interface LanguageHost {
     readonly files?: ProjectFiles;
     readonly apple?: boolean;
     readonly keymap?: Keymap;
+    /* What Paste from History lists. A new `ClipboardHistory` that lives as long as the project without one; pass one to choose its size or to keep its entries. */
+    readonly clipboard?: ClipboardHistory;
+    /* How many places Last Edit Location and Next Edit Location remember; 150 without one. */
+    readonly editHistoryLimit?: number;
     /* The height in pixels of the list-and-preview area of the peek and the call hierarchy, so a person's drag outlives the panel; 180 without one. */
     readonly panelBodyHeight?: number;
     /* A person finished resizing a peek or call hierarchy panel; the height is already within what the editor allows. */
@@ -71,9 +77,13 @@ export interface LanguageHost {
     /* Where `project.problems` reads its reports, such as a machine that also reports files no editor here holds; the service's diagnostics without one. */
     readonly problemSource?: ProblemSource;
     openPlace?(place: Place): void;
+    /* Opens a web address outside the editor, from a link in the text or a server; a new browser window without it. */
+    openExternal?(url: string): void;
     pathOfUri?(uri: string): string | null;
     serverNames?(uri: string): readonly string[];
     notify?(notification: EditorNotification): void;
+    /* A message of a server for a person, or a line for its log; without it the messages are not shown. */
+    onServerMessage?(message: ServerMessage): void;
     /* Synchronous overrides; undefined delegates to built-ins or an editable unknown-variable placeholder. */
     resolveSnippetVariable?(name: string, context: SnippetVariableContext): string | undefined;
     suggestNames?(request: RenameSuggestionsRequest, signal: AbortSignal): Promise<readonly string[]>;

package/src/index.ts

@@ -3,7 +3,7 @@ export { KEY_PRIORITY } from './key-priority.ts';
 export { realTimers, type Timers } from './timers.ts';
 export { type SemanticTokensOptions } from './semantic-tokens.ts';
 export { ProjectLanguage, type FileOperationTarget } from './project-language.ts';
-export type { LanguageDocumentHandle } from './project-language.ts';
+export type { AcquireOptions, LanguageDocumentHandle } from './project-language.ts';
 
 export type {
     SnippetVariableContext,
@@ -23,6 +23,10 @@ export type { LanguagePopupsProps } from './LanguagePopups.tsx';
 export { AnchoredPopup } from './AnchoredPopup.tsx';
 export { SignatureCard } from './SignatureCard.tsx';
 export { type RenderedDocsFeature } from './rendered-docs.ts';
+export { type DocumentLinksFeature } from './document-links.ts';
+export { type DocumentColorsFeature } from './document-colors.ts';
+export { type LinkedEditingFeature } from './linked-editing.ts';
+export { type InlineCompletionFeature, type InlineSuggestion } from './inline-completion.ts';
 export type { RenderedDocEntry, RenderedDocsSettings } from './rendered-docs.ts';
 export type { DocTagEntry, DocTagSection, ParsedDocComment } from './doc-comment-model.ts';
 export { EditorRenderingProvider } from './rendering.tsx';
@@ -58,14 +62,19 @@ export type {
     PickPreview,
     SymbolsView,
     MenuView,
-    AuthorsView
+    AuthorsView,
+    WrapView
 } from './popups.ts';
-
+export { type MarkupFeature } from './markup.ts';
+export type { MarkupSettings } from './markup.ts';
 export { RowHost, LineActionHost } from './row-host.ts';
 export type { HostedRow, HostedAction } from './row-host.ts';
 export { type HighlightLayers, highlightLayers } from './highlight-layers.ts';
 export { type NavigationHistory } from './navigation-history.ts';
 export type { Place } from './navigation-history.ts';
+export { EditLocations, type EditPlace } from './edit-locations.ts';
+export { ClipboardHistory, type ClipboardEntry, type ClipboardHistoryOptions } from './clipboard-history.ts';
+export { type PasteHistoryFeature } from './paste-history.ts';
 export { openingPlace, viewStates, followViewStates, viewStateKey, forgetMovesFrom } from './view-state.ts';
 export type { ViewState, RevealLineRequest } from './view-state.ts';
 export { lspLanguageIdOf, shikiLanguageOf, shikiLanguageOfPath } from './language-ids.ts';

package/src/inlay-hints.ts

@@ -391,7 +391,7 @@ export class InlayHintsFeature {
 
     /* Whether asking the server could still change what the hint offers. */
     private resolvable(entry: Entry): boolean {
-        return !entry.answered && entry.epoch === this.epoch && this.language.project.service.supports(RESOLVE_METHOD, this.language.uri);
+        return !entry.answered && entry.epoch === this.epoch && this.language.service.supports(RESOLVE_METHOD, this.language.uri);
     }
 
     /* Underlines the part under the pointer when a press would do something with it: a command always, a place while the key is down. */
@@ -479,7 +479,7 @@ export class InlayHintsFeature {
                 this.cancelHover();
                 this.language.goTo(action.location);
             } else if (action.kind === 'run') {
-                await project.service.executeCommand(uri, action.command);
+                await this.language.service.executeCommand(uri, action.command);
             } else if (entry.epoch === this.epoch && editsFit(editor, action.edits)) {
                 this.cancelHover();
                 const applied = editor.applyEdits(action.edits.map((edit) => ({ range: edit.range, text: edit.newText })));