@adecore/lsp 0.22.1 → 0.23.1

package/dist/workspace-operations.js

@@ -0,0 +1,232 @@
+import { ErrorCodes, LspError } from './connection.js';
+import { applyTextEdits } from './edits.js';
+/* The key a URI is known by: a folder spelled with a trailing slash is the same folder, except the root. */
+function keyOf(uri) {
+    const root = /^[^/:]+:\/\/[^/]*\/+$/.test(uri);
+    return root ? uri : uri.replace(/\/+$/, '');
+}
+function isUnder(uri, folder) {
+    return uri.startsWith(folder.endsWith('/') ? folder : `${folder}/`);
+}
+function ancestorsOf(uri) {
+    const found = [];
+    let end = uri.lastIndexOf('/');
+    while (end > 0) {
+        found.push(uri.slice(0, end));
+        end = uri.lastIndexOf('/', end - 1);
+    }
+    return found;
+}
+/*
+ * Plans a workspace edit with its resource operations without changing anything, and refuses (an `LspError`)
+ * the first thing that does not fit. Folders are matched by URI prefix, as written, with a trailing slash
+ * ignored: the URIs of one edit are expected to be spelled the same. Each URI is read from `source` at most once.
+ *
+ * Checks, in the order the edit gives its changes:
+ * - A version in a text edit must equal the source's version. A file no editor holds has no version to check,
+ *   so a version on it is refused with `ContentModified`. When the source reports no version for an open file,
+ *   the version is not enforced and the host's check of the text stands in. A file the plan makes is not checked.
+ * - An operation outside `source.operations` is refused.
+ * - A create over a file that is there is refused, unless it says `overwrite` (planned as an overwrite) or
+ *   `ignoreIfExists` (left out). A rename onto a target that is there works the same way; a rename of
+ *   something that is not there is always refused. Without `source.exists`, that is left to the host.
+ * - A delete of something that is not there is refused unless it says `ignoreIfNotExists`. Emptiness of a
+ *   folder cannot be told, so deleting a folder, or anything that exists and is no text file when the source
+ *   cannot say which, needs `recursive`.
+ * - Text edits to a URI after it was deleted or renamed away are refused. Edits to a renamed file are read
+ *   from where it stood, and edits to a file the plan makes become its text.
+ */
+export async function planWorkspaceOperations(edit, source) {
+    const probes = new Map();
+    const folders = new Map();
+    // null is a tombstone: the URI, and everything under it, is gone.
+    const overlay = new Map();
+    // Renames in order, to find where a file under a moved folder was read from.
+    const moves = [];
+    const steps = [];
+    const probe = (uri) => {
+        let found = probes.get(uri);
+        if (found === undefined) {
+            found = (async () => {
+                const text = await source.read(uri);
+                return { text, exists: text !== null ? true : source.exists === undefined ? null : await source.exists(uri) };
+            })();
+            probes.set(uri, found);
+        }
+        return found;
+    };
+    const folderAt = (uri) => {
+        let found = folders.get(uri);
+        if (found === undefined) {
+            found = source.isFolder === undefined ? Promise.resolve(true) : source.isFolder(uri);
+            folders.set(uri, found);
+        }
+        return found;
+    };
+    const originOf = (uri) => {
+        let origin = uri;
+        for (let i = moves.length - 1; i >= 0; i--) {
+            const move = moves[i];
+            if (origin === move.newUri || isUnder(origin, move.newUri)) {
+                origin = move.oldUri + origin.slice(move.newUri.length);
+            }
+        }
+        return origin;
+    };
+    const lookup = async (uri) => {
+        if (overlay.has(uri)) {
+            return overlay.get(uri);
+        }
+        for (const ancestor of ancestorsOf(uri)) {
+            if (overlay.has(ancestor)) {
+                const node = overlay.get(ancestor);
+                if (node === null || node.kind === 'text') {
+                    return null;
+                }
+                break;
+            }
+        }
+        const origin = originOf(uri);
+        const found = await probe(origin);
+        let node = null;
+        if (found.text !== null) {
+            node = { kind: 'text', text: found.text.text, version: found.text.version, open: found.text.open, readUri: origin, create: null };
+        }
+        else if (found.exists !== false) {
+            node = { kind: found.exists === null ? 'maybe' : 'other', text: '', version: null, open: false, readUri: origin, create: null };
+        }
+        if (node !== null) {
+            overlay.set(uri, node);
+        }
+        return node;
+    };
+    const demand = (kind, uri) => {
+        if (!source.operations.includes(kind)) {
+            const verb = kind === 'create' ? 'Creating' : kind === 'rename' ? 'Moving' : 'Deleting';
+            throw new LspError(`${verb} ${uri} is not supported here`);
+        }
+    };
+    const forget = (uri) => {
+        for (const key of [...overlay.keys()]) {
+            if (key === uri || isUnder(key, uri)) {
+                overlay.delete(key);
+            }
+        }
+    };
+    const keyed = (change) => {
+        if ('textDocument' in change) {
+            return { ...change, textDocument: { ...change.textDocument, uri: keyOf(change.textDocument.uri) } };
+        }
+        if (change.kind === 'rename') {
+            return { ...change, oldUri: keyOf(change.oldUri), newUri: keyOf(change.newUri) };
+        }
+        return { ...change, uri: keyOf(change.uri) };
+    };
+    const changes = edit.documentChanges ?? Object.entries(edit.changes ?? {}).map(([uri, edits]) => ({ textDocument: { uri, version: null }, edits }));
+    for (const original of changes) {
+        const change = keyed(original);
+        if ('textDocument' in change) {
+            const { uri, version } = change.textDocument;
+            const node = await lookup(uri);
+            if (node === null || node.kind !== 'text') {
+                throw new LspError(`${uri} cannot be read as text`);
+            }
+            if (version !== null && node.create === null) {
+                if (!node.open) {
+                    throw new LspError(`The version of ${uri} cannot be checked because no editor holds it`, ErrorCodes.ContentModified);
+                }
+                if (node.version !== null && node.version !== version) {
+                    throw new LspError(`Workspace edit version mismatch: ${uri}`, ErrorCodes.ContentModified);
+                }
+            }
+            const after = applyTextEdits(node.text, change.edits);
+            if (node.create !== null) {
+                node.create.text = after;
+            }
+            else {
+                steps.push({
+                    kind: 'edits',
+                    uri,
+                    readUri: node.readUri,
+                    edits: change.edits,
+                    before: node.text,
+                    after,
+                    version: node.version,
+                    open: node.open
+                });
+            }
+            node.text = after;
+        }
+        else if (change.kind === 'create') {
+            demand('create', change.uri);
+            const found = await lookup(change.uri);
+            const there = found?.kind === 'maybe' ? null : found;
+            const overwrite = change.options?.overwrite === true;
+            if (there !== null && !overwrite) {
+                if (change.options?.ignoreIfExists === true) {
+                    continue;
+                }
+                throw new LspError(`${change.uri} already exists`);
+            }
+            if (there !== null && there.kind === 'other') {
+                throw new LspError(`${change.uri} already exists and is not a text file`);
+            }
+            const made = { kind: 'create', uri: change.uri, text: '', overwrite: there !== null };
+            steps.push(made);
+            overlay.set(change.uri, { kind: 'text', text: '', version: null, open: false, readUri: null, create: made });
+        }
+        else if (change.kind === 'rename') {
+            demand('rename', change.oldUri);
+            const { oldUri, newUri } = change;
+            const from = await lookup(oldUri);
+            if (from === null) {
+                throw new LspError(`${oldUri} does not exist`);
+            }
+            if (oldUri === newUri) {
+                continue;
+            }
+            const target = await lookup(newUri);
+            const taken = target?.kind === 'maybe' ? null : target;
+            const overwrite = change.options?.overwrite === true;
+            if (taken !== null && !overwrite) {
+                if (change.options?.ignoreIfExists === true) {
+                    continue;
+                }
+                throw new LspError(`${newUri} already exists`);
+            }
+            const carried = [];
+            for (const [key, node] of overlay) {
+                if (key !== oldUri && isUnder(key, oldUri)) {
+                    carried.push([newUri + key.slice(oldUri.length), node]);
+                }
+            }
+            forget(newUri);
+            forget(oldUri);
+            overlay.set(oldUri, null);
+            overlay.set(newUri, from);
+            for (const [key, node] of carried) {
+                overlay.set(key, node);
+            }
+            moves.push({ oldUri, newUri });
+            steps.push({ kind: 'rename', oldUri, newUri, overwrite: taken !== null });
+        }
+        else {
+            demand('delete', change.uri);
+            const found = await lookup(change.uri);
+            if (found === null) {
+                if (change.options?.ignoreIfNotExists === true) {
+                    continue;
+                }
+                throw new LspError(`${change.uri} does not exist`);
+            }
+            const recursive = change.options?.recursive === true;
+            if (found.kind !== 'text' && !recursive && (await folderAt(found.readUri ?? change.uri))) {
+                throw new LspError(`${change.uri} is a folder, or cannot be told from one, and is only deleted with recursive set`);
+            }
+            forget(change.uri);
+            overlay.set(change.uri, null);
+            steps.push({ kind: 'delete', uri: change.uri, recursive });
+        }
+    }
+    return { steps: steps.map((step) => (step.kind === 'create' ? { ...step } : step)) };
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@adecore/lsp",
-  "version": "0.22.1",
+  "version": "0.23.1",
   "type": "module",
   "exports": {
     ".": {

package/src/completion-defaults.ts

@@ -0,0 +1,97 @@
+import type { CompletionItem, CompletionList, Range } from './protocol.ts';
+
+function validRange(range: Range, singleLine = true): boolean {
+    if (range === null || typeof range !== 'object') {
+        return false;
+    }
+    const { start, end } = range;
+    return (
+        start !== undefined &&
+        start !== null &&
+        typeof start === 'object' &&
+        end !== undefined &&
+        end !== null &&
+        typeof end === 'object' &&
+        [start.line, start.character, end.line, end.character].every((value) => Number.isSafeInteger(value) && value >= 0) &&
+        (!singleLine || start.line === end.line) &&
+        (start.line < end.line || (start.line === end.line && start.character <= end.character))
+    );
+}
+
+function validEditRange(range: Range | { insert: Range; replace: Range }, singleLine = true): boolean {
+    if (range === null || typeof range !== 'object' || Array.isArray(range)) {
+        return false;
+    }
+    if ('start' in range) {
+        return validRange(range, singleLine);
+    }
+    return (
+        validRange(range.insert) &&
+        validRange(range.replace) &&
+        range.insert.start.line === range.replace.start.line &&
+        range.insert.start.character === range.replace.start.character &&
+        range.insert.end.character <= range.replace.end.character
+    );
+}
+
+export function applyCompletionDefaults(
+    item: CompletionItem,
+    defaults?: CompletionList['itemDefaults'],
+    options?: { onInvalidRange?: (error: RangeError) => void }
+): CompletionItem {
+    if (typeof item?.label !== 'string') {
+        throw new TypeError('A completion item must have a string label.');
+    }
+    for (const value of [item.filterText, item.sortText, item.insertText, item.textEditText]) {
+        if (value !== undefined && typeof value !== 'string') {
+            throw new TypeError('Completion ranking and insertion text must be strings.');
+        }
+    }
+    if (item.textEdit !== undefined) {
+        const edit = item.textEdit;
+        if (
+            edit === null ||
+            typeof edit !== 'object' ||
+            typeof edit.newText !== 'string' ||
+            !('range' in edit ? validEditRange(edit.range, false) : validEditRange(edit))
+        ) {
+            throw new RangeError('Invalid completion item edit.');
+        }
+    }
+    if (defaults === undefined) {
+        return item;
+    }
+    const next = { ...item };
+    if (next.commitCharacters === undefined && defaults.commitCharacters !== undefined) {
+        next.commitCharacters = defaults.commitCharacters;
+    }
+    if (next.insertTextFormat === undefined && defaults.insertTextFormat !== undefined) {
+        next.insertTextFormat = defaults.insertTextFormat;
+    }
+    if (next.insertTextMode === undefined && defaults.insertTextMode !== undefined) {
+        next.insertTextMode = defaults.insertTextMode;
+    }
+    if (next.data === undefined && defaults.data !== undefined) {
+        next.data = defaults.data;
+    }
+    if (next.textEdit === undefined && defaults.editRange !== undefined) {
+        const range = defaults.editRange;
+        const newText = item.textEditText ?? item.label;
+        if (typeof newText !== 'string') {
+            throw new TypeError('Completion edit text must be a string.');
+        }
+        const invalid = (message: string): CompletionItem => {
+            const error = new RangeError(message);
+            if (options?.onInvalidRange === undefined) {
+                throw error;
+            }
+            options.onInvalidRange(error);
+            return next;
+        };
+        if (!validEditRange(range)) {
+            return invalid('Invalid completion default edit range.');
+        }
+        next.textEdit = 'start' in range ? { range, newText } : { insert: range.insert, replace: range.replace, newText };
+    }
+    return next;
+}

package/src/document.ts

@@ -2,6 +2,9 @@ import { ErrorCodes, LspError, StaleResultError } from './connection.ts';
 import { applyContentChanges, minimalChange } from './edits.ts';
 import type { LspSession } from './session.ts';
 import type {
+    CallHierarchyIncomingCall,
+    CallHierarchyItem,
+    CallHierarchyOutgoingCall,
     CodeAction,
     CodeActionContext,
     CodeLens,
@@ -210,6 +213,11 @@ export class LspDocument {
         return this.feature('textDocument/rangeFormatting', { range, options: formatting }, options);
     }
 
+    /* `ch` is the character that was typed; `position` is where the caret is after it. */
+    onTypeFormatting(position: Position, ch: string, formatting: FormattingOptions, options?: DocumentRequestOptions): Promise<TextEdit[] | null> {
+        return this.feature('textDocument/onTypeFormatting', { position, ch, options: formatting }, options);
+    }
+
     foldingRanges(options?: DocumentRequestOptions): Promise<FoldingRange[] | null> {
         return this.feature('textDocument/foldingRange', {}, options);
     }
@@ -238,6 +246,19 @@ export class LspDocument {
         return this.resolve('inlayHint/resolve', hint, options);
     }
 
+    prepareCallHierarchy(position: Position, options?: DocumentRequestOptions): Promise<CallHierarchyItem[] | null> {
+        return this.feature('textDocument/prepareCallHierarchy', { position }, options);
+    }
+
+    /* The callers of an item the server gave. Neighbouring expansions run beside each other, so a newer one does not cancel an older unless `cancelPrevious` says so. */
+    incomingCalls(item: CallHierarchyItem, options?: DocumentRequestOptions): Promise<CallHierarchyIncomingCall[] | null> {
+        return this.perform('callHierarchy/incomingCalls', { item }, { cancelPrevious: false, ...options });
+    }
+
+    outgoingCalls(item: CallHierarchyItem, options?: DocumentRequestOptions): Promise<CallHierarchyOutgoingCall[] | null> {
+        return this.perform('callHierarchy/outgoingCalls', { item }, { cancelPrevious: false, ...options });
+    }
+
     diagnostics(previousResultId?: string, identifier?: string, options?: DocumentRequestOptions): Promise<DocumentDiagnosticReport> {
         return this.feature('textDocument/diagnostic', { previousResultId, identifier }, options);
     }

package/src/file-operations.ts

@@ -1,19 +1,29 @@
 import { globMatch } from './glob.ts';
-import type { FileOperationFilter, FileRename } from './protocol.ts';
+import type { FileCreate, FileDelete, FileOperationFilter, FileRename } from './protocol.ts';
 
 /* A file or folder that moves, which says what it is since a filter may take only one of the two. */
 export interface RenamedFile extends FileRename {
     directory: boolean;
 }
 
-function filterTakes(filter: FileOperationFilter, file: RenamedFile): boolean {
+/* A file or folder that is made. */
+export interface CreatedFile extends FileCreate {
+    directory: boolean;
+}
+
+/* A file or folder that is deleted. */
+export interface DeletedFile extends FileDelete {
+    directory: boolean;
+}
+
+function filterTakes(filter: FileOperationFilter, uri: string, directory: boolean): boolean {
     const { matches, glob, options } = filter.pattern;
-    if (matches !== undefined && (matches === 'folder') !== file.directory) {
+    if (matches !== undefined && (matches === 'folder') !== directory) {
         return false;
     }
     let url: URL;
     try {
-        url = new URL(file.oldUri);
+        url = new URL(uri);
     } catch {
         return false;
     }
@@ -26,5 +36,15 @@ function filterTakes(filter: FileOperationFilter, file: RenamedFile): boolean {
 
 /* The renames a server asked to hear about, by the filters it registered. A rename is matched on the place it leaves. */
 export function renamesTaken(filters: readonly FileOperationFilter[], files: readonly RenamedFile[]): FileRename[] {
-    return files.filter((file) => filters.some((filter) => filterTakes(filter, file))).map(({ oldUri, newUri }) => ({ oldUri, newUri }));
+    return files.filter((file) => filters.some((filter) => filterTakes(filter, file.oldUri, file.directory))).map(({ oldUri, newUri }) => ({ oldUri, newUri }));
+}
+
+/* The files made that a server asked to hear about, by the filters it registered. */
+export function createsTaken(filters: readonly FileOperationFilter[], files: readonly CreatedFile[]): FileCreate[] {
+    return files.filter((file) => filters.some((filter) => filterTakes(filter, file.uri, file.directory))).map(({ uri }) => ({ uri }));
+}
+
+/* The files deleted that a server asked to hear about, by the filters it registered. A folder is matched as one, not by what was in it. */
+export function deletesTaken(filters: readonly FileOperationFilter[], files: readonly DeletedFile[]): FileDelete[] {
+    return files.filter((file) => filters.some((filter) => filterTakes(filter, file.uri, file.directory))).map(({ uri }) => ({ uri }));
 }

package/src/index.ts

@@ -1,4 +1,5 @@
 export { ErrorCodes, JsonRpcConnection, LspError, StaleResultError, type RequestHandler } from './connection.ts';
+export { applyCompletionDefaults } from './completion-defaults.ts';
 export { LspDocument } from './document.ts';
 export {
     applyContentChanges,
@@ -11,7 +12,19 @@ export {
     type DocumentSnapshot,
     type PlannedDocumentEdit
 } from './edits.ts';
-export { renamesTaken, type RenamedFile } from './file-operations.ts';
+export {
+    planWorkspaceOperations,
+    type PlannedCreateStep,
+    type PlannedDeleteStep,
+    type PlannedRenameStep,
+    type PlannedTextStep,
+    type ResourceOperationKind,
+    type WorkspaceEditPlan,
+    type WorkspaceEditSource,
+    type WorkspaceEditStep,
+    type WorkspaceEditText
+} from './workspace-operations.ts';
+export { createsTaken, deletesTaken, renamesTaken, type CreatedFile, type DeletedFile, type RenamedFile } from './file-operations.ts';
 export { watchesFile, type FileChangeType } from './watched-files.ts';
 export { LspSession, type LspSessionOptions, type SessionState } from './session.ts';
 export type { DiagnosticsReport, LanguageDocument, LanguageRequestOptions, LanguageService } from './service.ts';

package/src/protocol.ts

@@ -204,6 +204,30 @@ export interface WorkspaceSymbol {
     data?: unknown;
 }
 
+/* A function, method or class that calls are traced through; `data` is the server's own and goes back to it untouched. */
+export interface CallHierarchyItem {
+    name: string;
+    kind: SymbolKind;
+    tags?: 1[];
+    detail?: string;
+    uri: string;
+    range: Range;
+    selectionRange: Range;
+    data?: unknown;
+}
+
+/* A caller of an item. `fromRanges` are the call sites, in the file of `from`. */
+export interface CallHierarchyIncomingCall {
+    from: CallHierarchyItem;
+    fromRanges: Range[];
+}
+
+/* An item that another one calls. `fromRanges` are the call sites, in the file of the item that was asked about. */
+export interface CallHierarchyOutgoingCall {
+    to: CallHierarchyItem;
+    fromRanges: Range[];
+}
+
 export type DocumentSymbolResult = DocumentSymbol[] | SymbolInformation[] | null;
 export type WorkspaceSymbolResult = SymbolInformation[] | WorkspaceSymbol[] | null;
 
@@ -273,6 +297,19 @@ export interface FileRename {
     newUri: string;
 }
 
+/* One entry of `workspace/willCreateFiles` and `didCreateFiles`. */
+export interface FileCreate {
+    uri: string;
+}
+
+/* One entry of `workspace/willDeleteFiles` and `didDeleteFiles`. */
+export interface FileDelete {
+    uri: string;
+}
+
+/* The file operations a server can ask to hear about, each in a `will` form that may answer with an edit and a `did` form that only informs. */
+export type FileOperation = 'willRename' | 'didRename' | 'willCreate' | 'didCreate' | 'willDelete' | 'didDelete';
+
 export interface FileOperationFilter {
     scheme?: string;
     pattern: { glob: string; matches?: 'file' | 'folder'; options?: { ignoreCase?: boolean } };
@@ -403,6 +440,9 @@ export interface ProviderOptions {
     resolveProvider?: boolean;
     prepareProvider?: boolean;
     triggerCharacters?: string[];
+    /* Of on type formatting: the first character that asks, and the others that do. */
+    firstTriggerCharacter?: string;
+    moreTriggerCharacter?: string[];
     retriggerCharacters?: string[];
     commands?: string[];
     watchers?: FileSystemWatcher[];
@@ -447,6 +487,8 @@ export interface ServerCapabilities {
     selectionRangeProvider?: boolean | ProviderOptions;
     semanticTokensProvider?: ProviderOptions & { legend: SemanticTokensLegend };
     inlayHintProvider?: boolean | ProviderOptions;
+    callHierarchyProvider?: boolean | ProviderOptions;
+    documentOnTypeFormattingProvider?: ProviderOptions;
     diagnosticProvider?: ProviderOptions;
     [capability: string]: unknown;
 }

package/src/service.ts

@@ -1,4 +1,7 @@
 import type {
+    CallHierarchyIncomingCall,
+    CallHierarchyItem,
+    CallHierarchyOutgoingCall,
     CodeAction,
     CodeActionContext,
     CodeLens,
@@ -30,6 +33,7 @@ import type {
     WorkspaceEdit,
     WorkspaceSymbolResult
 } from './protocol.ts';
+import type { CreatedFile, DeletedFile } from './file-operations.ts';
 
 export interface LanguageDocument {
     /* The `file:` URI the language servers know the file by, which `pathToFileUri` makes of a path. */
@@ -67,6 +71,8 @@ export interface LanguageService {
     /* Applies `didChange` entries in order. Every call raises the version by one. */
     changeDocument(uri: string, changes: readonly ContentChange[]): Promise<void>;
     closeDocument(uri: string): Promise<void>;
+    /* The version the servers hold an open document at, for checking a workspace edit; null when it is not open. Without it such versions cannot be checked. */
+    versionOf?(uri: string): number | null;
 
     /* Whether any server of the document answers `method` now, and the options it gave (trigger characters, a legend, resolve support). */
     supports(method: string, uri: string): boolean;
@@ -94,6 +100,8 @@ export interface LanguageService {
     executeCommand(uri: string, command: Command, options?: LanguageRequestOptions): Promise<unknown>;
     formatting(uri: string, formatting: FormattingOptions, options?: LanguageRequestOptions): Promise<TextEdit[] | null>;
     rangeFormatting(uri: string, range: Range, formatting: FormattingOptions, options?: LanguageRequestOptions): Promise<TextEdit[] | null>;
+    /* Optional so a service from before it still fits; `providerOptions('textDocument/onTypeFormatting', uri)` has the trigger characters. */
+    onTypeFormatting?(uri: string, position: Position, ch: string, formatting: FormattingOptions, options?: LanguageRequestOptions): Promise<TextEdit[] | null>;
     semanticTokens(uri: string, options?: LanguageRequestOptions): Promise<SemanticTokens | null>;
     semanticTokensDelta(uri: string, previousResultId: string, options?: LanguageRequestOptions): Promise<SemanticTokens | SemanticTokensDelta | null>;
     semanticTokensRange(uri: string, range: Range, options?: LanguageRequestOptions): Promise<SemanticTokens | null>;
@@ -104,6 +112,20 @@ export interface LanguageService {
     foldingRanges(uri: string, options?: LanguageRequestOptions): Promise<FoldingRange[] | null>;
     /* One chain per position, the smallest range first, each in its `parent`. */
     selectionRanges(uri: string, positions: readonly Position[], options?: LanguageRequestOptions): Promise<SelectionRange[] | null>;
+    /* The call hierarchy methods are optional so a service from before them still fits; `supports('textDocument/prepareCallHierarchy', uri)` says whether a server answers. */
+    prepareCallHierarchy?(uri: string, position: Position, options?: LanguageRequestOptions): Promise<CallHierarchyItem[] | null>;
+    /* `uri` is the document the hierarchy was prepared in, which names the server to ask. */
+    incomingCalls?(uri: string, item: CallHierarchyItem, options?: LanguageRequestOptions): Promise<CallHierarchyIncomingCall[] | null>;
+    outgoingCalls?(uri: string, item: CallHierarchyItem, options?: LanguageRequestOptions): Promise<CallHierarchyOutgoingCall[] | null>;
+    /*
+     * File operation notifications are optional so a service from before them still fits. Each asks the servers
+     * that registered for the operation and keeps the files their filters take; `will*` answers the edits the
+     * servers want made first (null when there are none) and `did*` informs them afterwards.
+     */
+    willCreateFiles?(files: readonly CreatedFile[], options?: LanguageRequestOptions): Promise<WorkspaceEdit | null>;
+    didCreateFiles?(files: readonly CreatedFile[]): Promise<void>;
+    willDeleteFiles?(files: readonly DeletedFile[], options?: LanguageRequestOptions): Promise<WorkspaceEdit | null>;
+    didDeleteFiles?(files: readonly DeletedFile[]): Promise<void>;
     codeLenses(uri: string, options?: LanguageRequestOptions): Promise<CodeLens[] | null>;
     resolveCodeLens(uri: string, lens: CodeLens, options?: LanguageRequestOptions): Promise<CodeLens>;
 }