@mirascript/monaco 0.1.0

package/src/lsp/providers/base.ts

@@ -0,0 +1,40 @@
+import type { VmContext } from '@mirascript/mirascript';
+import { DefaultVmContext } from '@mirascript/mirascript/subtle';
+import type { VmContextProvider } from '../../index.js';
+import { type editor, Emitter, type IEvent } from '../../monaco-api.js';
+import type { CompileResult } from '../compile-result.js';
+import { compile } from '../worker-helper.js';
+
+let contextProvider: VmContextProvider | undefined;
+/** 设置全局变量提供者 */
+export function setContextProvider(provider: VmContextProvider | undefined): void {
+    contextProvider = provider;
+}
+
+/** 提供编辑器 LSP 支持 */
+export abstract class Provider {
+    /** 获取编译结果 */
+    async getCompileResult(model: editor.ITextModel): Promise<CompileResult | undefined> {
+        if (model.uri.scheme === 'mirascript') {
+            return undefined; // 不处理标准库
+        }
+        return await compile(model);
+    }
+    /** 获取执行上下文（全局变量） */
+    async getContext(model: editor.ITextModel): Promise<Readonly<VmContext>> {
+        return (await contextProvider?.(model)) ?? DefaultVmContext;
+    }
+
+    readonly displayName = 'MiraScript LSP';
+    readonly _debugDisplayName = 'MiraScript LSP';
+    private _onDidChange: Emitter<this> | null = null;
+    /** @inheritdoc */
+    get onDidChange(): IEvent<this> & IEvent<void> {
+        this._onDidChange ??= new Emitter<this>();
+        return this._onDidChange.event as IEvent<this> & IEvent<void>;
+    }
+    /** 触发 onDidChange */
+    emitDidChange(): void {
+        this._onDidChange?.fire(this);
+    }
+}

package/src/lsp/providers/code-action-provider.ts

@@ -0,0 +1,28 @@
+import type { editor, languages, Range, CancellationToken } from '../../monaco-api.js';
+import { Provider } from './base.js';
+
+/**
+ * 代码操作
+ */
+export class CodeActionProvider extends Provider implements languages.CodeActionProvider {
+    /** @inheritdoc */
+    provideCodeActions(
+        model: editor.ITextModel,
+        range: Range,
+        context: languages.CodeActionContext,
+        token: CancellationToken,
+    ): languages.ProviderResult<languages.CodeActionList> {
+        return {
+            actions: [],
+            dispose: () => void 0,
+        };
+    }
+
+    /** @inheritdoc */
+    resolveCodeAction?(
+        codeAction: languages.CodeAction,
+        token: CancellationToken,
+    ): languages.ProviderResult<languages.CodeAction> {
+        throw new Error('Method not implemented.');
+    }
+}

package/src/lsp/providers/color-provider.ts

@@ -0,0 +1,129 @@
+import type { editor, languages, CancellationToken } from '../../monaco-api.js';
+import { Provider } from './base.js';
+import { DiagnosticCode } from '@mirascript/wasm';
+
+const REG_COLOR_STR = /^(@*)(['"`])(#(?:[0-9a-f]{6}|[0-9a-f]{3}|[0-9a-f]{8}|[0-9a-f]{4}))\2\1$/iu;
+
+/** 解析颜色 */
+function parseColorString(text: string):
+    | {
+          ats: string;
+          quote: string;
+          colorString: string;
+          color: languages.IColor;
+      }
+    | undefined {
+    const colorMatch = REG_COLOR_STR.exec(text);
+    if (!colorMatch) {
+        return undefined;
+    }
+    const ats = colorMatch[1] || '';
+    const quote = colorMatch[2] || '';
+    const colorString = colorMatch[3]!;
+    let color: languages.IColor;
+    if (colorString.startsWith('#')) {
+        const colorCode = colorString.slice(1);
+
+        if (colorCode.length === 3) {
+            // 处理 #RGB 格式
+            color = {
+                red: Number.parseInt(colorCode[0]! + colorCode[0]!, 16) / 255,
+                green: Number.parseInt(colorCode[1]! + colorCode[1]!, 16) / 255,
+                blue: Number.parseInt(colorCode[2]! + colorCode[2]!, 16) / 255,
+                alpha: 1,
+            };
+        } else if (colorCode.length === 6) {
+            color = {
+                red: Number.parseInt(colorCode.slice(0, 2), 16) / 255,
+                green: Number.parseInt(colorCode.slice(2, 4), 16) / 255,
+                blue: Number.parseInt(colorCode.slice(4, 6), 16) / 255,
+                alpha: 1, // 假设不透明
+            };
+        } else if (colorCode.length === 8) {
+            // 处理 #RRGGBBAA 格式
+            color = {
+                red: Number.parseInt(colorCode.slice(0, 2), 16) / 255,
+                green: Number.parseInt(colorCode.slice(2, 4), 16) / 255,
+                blue: Number.parseInt(colorCode.slice(4, 6), 16) / 255,
+                alpha: Number.parseInt(colorCode.slice(6, 8), 16) / 255,
+            };
+        } else if (colorCode.length === 4) {
+            // 处理 #RGBA 格式
+            color = {
+                red: Number.parseInt(colorCode[0]! + colorCode[0]!, 16) / 255,
+                green: Number.parseInt(colorCode[1]! + colorCode[1]!, 16) / 255,
+                blue: Number.parseInt(colorCode[2]! + colorCode[2]!, 16) / 255,
+                alpha: Number.parseInt(colorCode[3]! + colorCode[3]!, 16) / 255,
+            };
+        } else {
+            return undefined; // 不支持的颜色格式
+        }
+    } else {
+        return undefined; // 不是以 # 开头的颜色字符串
+    }
+
+    return {
+        ats,
+        quote,
+        colorString,
+        color,
+    };
+}
+
+/** @inheritdoc */
+export class ColorProvider extends Provider implements languages.DocumentColorProvider {
+    /** @inheritdoc */
+    async provideDocumentColors(
+        model: editor.ITextModel,
+        token: CancellationToken,
+    ): Promise<languages.IColorInformation[] | undefined> {
+        const compiled = await this.getCompileResult(model);
+        if (!compiled) return undefined;
+        const info: languages.IColorInformation[] = [];
+        for (const { range, code } of compiled.groupedTags(model).ranges) {
+            if (code !== DiagnosticCode.String) continue;
+            if (range.startLineNumber !== range.endLineNumber) {
+                // 只处理单行字符串
+                continue;
+            }
+            const text = model.getValueInRange(range);
+            const parsed = parseColorString(text);
+            if (!parsed) continue;
+            info.push({
+                range: {
+                    startLineNumber: range.startLineNumber,
+                    startColumn: range.startColumn + parsed.ats.length + parsed.quote.length,
+                    endLineNumber: range.endLineNumber,
+                    endColumn: range.endColumn - parsed.ats.length - parsed.quote.length,
+                },
+                color: parsed.color,
+            });
+        }
+        return info;
+    }
+    /** @inheritdoc */
+    provideColorPresentations(
+        model: editor.ITextModel,
+        colorInfo: languages.IColorInformation,
+        token: CancellationToken,
+    ): languages.ProviderResult<languages.IColorPresentation[]> {
+        const { color } = colorInfo;
+        return [
+            {
+                label: `#${Math.round(color.red * 255)
+                    .toString(16)
+                    .padStart(2, '0')}${Math.round(color.green * 255)
+                    .toString(16)
+                    .padStart(2, '0')}${Math.round(color.blue * 255)
+                    .toString(16)
+                    .padStart(2, '0')}${
+                    color.alpha >= 1
+                        ? ''
+                        : Math.round(color.alpha * 255)
+                              .toString(16)
+                              .padStart(2, '0')
+                }`,
+            },
+        ];
+    }
+}

package/src/lsp/providers/completion-item-provider.ts

@@ -0,0 +1,497 @@
+import {
+    getVmFunctionInfo,
+    type VmValue,
+    isVmExtern,
+    isVmModule,
+    type VmFunctionInfo,
+    type VmExtern,
+} from '@mirascript/mirascript';
+import { DiagnosticCode, lib, operations } from '@mirascript/mirascript/subtle';
+import {
+    type editor,
+    languages,
+    type CancellationToken,
+    type IPosition,
+    type IRange,
+    type Position,
+    Range,
+} from '../../monaco-api.js';
+import { Provider } from './base.js';
+import { codeblock, getDeep, valueDoc, paramsList, strictContainsPosition, wordAt } from '../utils.js';
+import { keywords, reservedKeywords } from '../../constants.js';
+import type { LocalDefinition } from '../compile-result.js';
+
+const DESC_GLOBAL = '(global)';
+const DESC_LOCAL = '(local)';
+const DESC_FIELD = '(field)';
+
+const SUGGEST_KEYWORDS: string[] = [];
+
+const loadSuggestKeywords = () => {
+    if (SUGGEST_KEYWORDS.length > 0) return SUGGEST_KEYWORDS; // 已加载过
+    const reserved = reservedKeywords();
+    for (const kw of keywords()) {
+        if (reserved.includes(kw)) continue; // 跳过保留关键字
+        SUGGEST_KEYWORDS.push(kw);
+    }
+    return SUGGEST_KEYWORDS;
+};
+
+const COMMON_GLOBAL_SUGGESTIONS = (
+    range: languages.CompletionItemRanges,
+    extension: boolean,
+): languages.CompletionItem[] => {
+    const suggestions: languages.CompletionItem[] = [
+        {
+            label: 'type',
+            kind: languages.CompletionItemKind.Keyword,
+            insertText: 'type',
+            commitCharacters: ['('],
+            documentation: {
+                value: `使用 \`type()\` 调用获取表达式的类型。${codeblock('type(expression);\nexpression::type();')}`,
+            },
+            range,
+        },
+        {
+            label: 'global',
+            kind: languages.CompletionItemKind.Keyword,
+            insertText: 'global',
+            commitCharacters: ['.', '['],
+            documentation: {
+                value: `使用 \`global\` 获取全局变量。${codeblock('global.variableName;\nglobal["variableName"];\n"variableName" in global;')}`,
+            },
+            range,
+        },
+    ];
+    if (!extension) {
+        suggestions.push(
+            {
+                label: { label: 'if', description: 'If 表达式' },
+                kind: languages.CompletionItemKind.Snippet,
+                insertText: 'if ${1:condition} {\n\t$0\n}',
+                insertTextRules: languages.CompletionItemInsertTextRule.InsertAsSnippet,
+                documentation: {
+                    value: `使用 \`if\` 表达式进行条件判断。${codeblock('if condition {\n\t// code\n}')}`,
+                },
+                range,
+            },
+            {
+                label: { label: 'ifelse', description: 'If-Else 表达式' },
+                kind: languages.CompletionItemKind.Snippet,
+                insertText: 'if ${1:condition} {\n\t$0\n} else {\n\t\n}',
+                insertTextRules: languages.CompletionItemInsertTextRule.InsertAsSnippet,
+                documentation: {
+                    value: `使用 \`ifelse\` 表达式进行条件判断。${codeblock('if condition {\n\t// code\n} else {\n\t// code\n}')}`,
+                },
+                range,
+            },
+            {
+                label: { label: 'match', description: 'Match 表达式' },
+                kind: languages.CompletionItemKind.Snippet,
+                insertText:
+                    'match ${1:value} {\n\tcase ${2:case1} {\n\t\t$0\n\t}\n\tcase ${3:case2} {\n\t\t\n\t}\n\tcase _ {\n\t\t\n\t}\n}',
+                insertTextRules: languages.CompletionItemInsertTextRule.InsertAsSnippet,
+                documentation: {
+                    value: `使用 \`match\` 表达式进行模式匹配。${codeblock('match value {\n\tcase case1 {\n\t\t// code\n\t}\n\tcase case2 {\n\t\t// code\n\t}\n\tcase _ {\n\t\t// code\n\t}\n}')}`,
+                },
+                range,
+            },
+            {
+                label: { label: 'loop', description: 'Loop 表达式' },
+                kind: languages.CompletionItemKind.Snippet,
+                insertText: 'loop {\n\t$0\n}',
+                insertTextRules: languages.CompletionItemInsertTextRule.InsertAsSnippet,
+                documentation: {
+                    value: `使用 \`loop\` 表达式进行无限循环。${codeblock('loop {\n\t// code\n}')}`,
+                },
+                range,
+            },
+            {
+                label: { label: 'while', description: 'While 表达式' },
+                kind: languages.CompletionItemKind.Snippet,
+                insertText: 'while ${1:condition} {\n\t$0\n}',
+                insertTextRules: languages.CompletionItemInsertTextRule.InsertAsSnippet,
+                documentation: {
+                    value: `使用 \`while\` 表达式进行条件循环。${codeblock('while condition {\n\t// code\n}')}`,
+                },
+                range,
+            },
+            {
+                label: { label: 'whileelse', description: 'While-Else 表达式' },
+                kind: languages.CompletionItemKind.Snippet,
+                insertText: 'while ${1:condition} {\n\t$0\n} else {\n\t\n}',
+                insertTextRules: languages.CompletionItemInsertTextRule.InsertAsSnippet,
+                documentation: {
+                    value: `使用 \`whileelse\` 表达式进行条件循环。${codeblock('while condition {\n\t// code\n} else {\n\t// code\n}')}`,
+                },
+                range,
+            },
+            {
+                label: { label: 'for', description: 'For 表达式' },
+                kind: languages.CompletionItemKind.Snippet,
+                insertText: 'for ${1:item} in ${2:collection} {\n\t$0\n}',
+                insertTextRules: languages.CompletionItemInsertTextRule.InsertAsSnippet,
+                documentation: {
+                    value: `使用 \`for\` 表达式进行迭代循环。${codeblock('for item in collection {\n\t// code\n}')}`,
+                },
+                range,
+            },
+            {
+                label: { label: 'forelse', description: 'For-Else 表达式' },
+                kind: languages.CompletionItemKind.Snippet,
+                insertText: 'for ${1:item} in ${2:collection} {\n\t$0\n} else {\n\t\n}',
+                insertTextRules: languages.CompletionItemInsertTextRule.InsertAsSnippet,
+                documentation: {
+                    value: `使用 \`forelse\` 表达式进行迭代循环。${codeblock('for item in collection {\n\t// code\n} else {\n\t// code\n}')}`,
+                },
+                range,
+            },
+            {
+                label: { label: 'fn', description: 'Fn 语句' },
+                kind: languages.CompletionItemKind.Snippet,
+                insertText: 'fn ${1:name}(${2:params}) {\n\t$0\n}',
+                insertTextRules: languages.CompletionItemInsertTextRule.InsertAsSnippet,
+                documentation: {
+                    value: `使用 \`fn\` 语句进行函数声明。${codeblock('fn name(params) {\n\t// code\n}')}`,
+                },
+                range,
+            },
+        );
+
+        for (const kw of loadSuggestKeywords()) {
+            const exist = suggestions.find(
+                (item) => item.label === kw && item.kind === languages.CompletionItemKind.Keyword,
+            );
+            if (exist) continue;
+            suggestions.push(kwSuggestion(kw, range));
+        }
+    }
+    return suggestions;
+};
+
+/** 构造关键字选项 */
+function kwSuggestion(kw: string, range: languages.CompletionItemRanges): languages.CompletionItem {
+    return {
+        label: kw,
+        kind: languages.CompletionItemKind.Keyword,
+        insertText: kw,
+        range,
+    };
+}
+
+/** 扩展完成项 */
+interface CustomCompletionItem extends languages.CompletionItem {
+    /** 是否为字段 */
+    isField: boolean;
+    /** 对应的变量值 */
+    vmValue?: VmValue;
+}
+
+/** 构造 filterText */
+function filterText(key: string, char: string | undefined): string {
+    if (char == null || key.startsWith(char)) return key;
+    return key.startsWith('@') || key.startsWith('$') ? key.slice(1) : key;
+}
+
+/** 构造选项 */
+function completion(
+    model: editor.ITextModel,
+    description: string,
+    key: string,
+    value: VmValue | undefined,
+    fn: VmFunctionInfo | LocalDefinition['fn'] | undefined,
+    field: boolean,
+): Pick<CustomCompletionItem, 'label' | 'kind' | 'commitCharacters' | 'vmValue' | 'isField'> {
+    let detail = '';
+    let kind: languages.CompletionItemKind;
+    if (fn == null && typeof value == 'function') {
+        fn = getVmFunctionInfo(value);
+    }
+    if (fn != null) {
+        detail = paramsList(model, fn);
+        kind = field ? languages.CompletionItemKind.Function : languages.CompletionItemKind.Method;
+    } else if (isVmModule(value)) {
+        kind = languages.CompletionItemKind.Module;
+    } else if (isVmExtern(value) && typeof value.value == 'function') {
+        if (value.value.prototype != null && (key[0] ?? '').toUpperCase() === key[0]) {
+            kind = languages.CompletionItemKind.Class;
+        } else {
+            detail = '(..)';
+            kind = value.caller ? languages.CompletionItemKind.Method : languages.CompletionItemKind.Function;
+        }
+    } else if (!field && key.startsWith('@')) {
+        kind = languages.CompletionItemKind.Constant;
+    } else {
+        kind = field ? languages.CompletionItemKind.Field : languages.CompletionItemKind.Variable;
+    }
+    return {
+        label: { label: key, description, detail },
+        kind,
+        commitCharacters: fn ? ['!', '('] : ['!', '.', '[', '('],
+        vmValue: value,
+        isField: field,
+    };
+}
+
+/** 获取所有键 */
+function externKeys(value: VmExtern): string[] {
+    const keys = new Set<string>();
+    let e: unknown = value.value;
+    while (e && (typeof e == 'object' || typeof e == 'function')) {
+        for (const key of Object.getOwnPropertyNames(e)) {
+            if (value.has(key)) {
+                keys.add(key);
+            }
+        }
+        e = Object.getPrototypeOf(e);
+    }
+    return Array.from(keys);
+}
+
+/**
+ * 自动完成
+ */
+export class CompletionItemProvider extends Provider implements languages.CompletionItemProvider {
+    readonly triggerCharacters: string[] = ['.', ':'];
+    /** 查找全局变量 */
+    private async completeGlobal(
+        model: editor.ITextModel,
+        char: string | undefined,
+        locals: readonly CustomCompletionItem[],
+        range: languages.CompletionItemRanges,
+    ): Promise<CustomCompletionItem[]> {
+        const global = await this.getContext(model);
+        const suggestions: CustomCompletionItem[] = [];
+        const localKeys = new Set(locals.map((item) => item.insertText));
+        for (const key of new Set(global.keys())) {
+            const element = global.get(key);
+            if (element === undefined) continue;
+
+            if (isVmModule(element)) {
+                for (const f of element.keys()) {
+                    if (char && !f.toLowerCase().includes(char)) {
+                        continue;
+                    }
+                    const field = element.get(f);
+                    if (field === undefined) continue;
+
+                    suggestions.push({
+                        insertText: localKeys.has(key) ? `global.${key}.${f}` : `${key}.${f}`,
+                        filterText: filterText(f, char),
+                        range,
+                        ...completion(model, DESC_GLOBAL, `${key}.${f}`, field, undefined, true),
+                    });
+                }
+            }
+
+            if (char && !key.toLowerCase().includes(char)) {
+                continue;
+            }
+
+            suggestions.push({
+                insertText: localKeys.has(key) ? `global.${key}` : key, // 如果有同名局部变量，使用 global. 前缀
+                filterText: filterText(key, char),
+                range,
+                ...completion(model, DESC_GLOBAL, key, element, undefined, false),
+            });
+        }
+        return suggestions;
+    }
+    /** 查找局部变量 */
+    private async completeLocal(
+        model: editor.ITextModel,
+        position: IPosition,
+        char: string | undefined,
+        range: languages.CompletionItemRanges,
+    ): Promise<CustomCompletionItem[]> {
+        const compiled = await this.getCompileResult(model);
+        if (!compiled) return [];
+        const suggestions: CustomCompletionItem[] = [];
+
+        let scope = compiled.scopeAt(model, position);
+        const locals = new Set<string>();
+        while (scope) {
+            for (const { definition, fn } of scope.locals) {
+                const name = model.getValueInRange(definition.range);
+                if (locals.has(name)) continue; // 子作用域可能会覆盖父作用域的变量
+                if (char && !name.toLowerCase().includes(char)) {
+                    continue;
+                }
+                locals.add(name);
+                suggestions.push({
+                    insertText: name,
+                    filterText: filterText(name, char),
+                    range,
+                    ...completion(model, DESC_LOCAL, name, undefined, fn, false),
+                });
+            }
+            if (!scope.parent) break;
+            scope = scope.parent;
+        }
+        return suggestions;
+    }
+
+    /** 查找变量字段 */
+    private async completeFields(
+        model: editor.ITextModel,
+        position: Position,
+        char: string | undefined,
+        range: languages.CompletionItemRanges,
+    ): Promise<CustomCompletionItem[]> {
+        const compiled = await this.getCompileResult(model);
+        if (!compiled) return [];
+        const access = compiled.fieldAccessAt(model, position);
+        if (!access || access.fields.length === 0) return [];
+        const { def, fields } = access;
+        if ('definition' in def.def) {
+            // TODO: suggests local item fields
+            return [];
+        }
+        const vmGlobal = await this.getContext(model);
+        fields.pop(); // 移除最后一个部分，因为它是当前输入位置的字段名
+        const value = getDeep(vmGlobal.get(def.def.name), fields);
+        if (value == null || typeof value != 'object') {
+            return [];
+        }
+        const keys = isVmExtern(value) ? externKeys(value) : lib.keys(value);
+        const result: CustomCompletionItem[] = [];
+        for (const k of keys) {
+            const key = String(k);
+            if (char && !String(key).toLowerCase().includes(char)) {
+                continue;
+            }
+            const field = operations.$Get(value, key);
+            result.push({
+                insertText: key,
+                range,
+                ...completion(model, DESC_FIELD, key, field, undefined, true),
+            });
+        }
+        return result;
+    }
+
+    /** 获取完成范围 */
+    private toCompletionItemRanges(position: IPosition, range: IRange): languages.CompletionItemRanges {
+        return {
+            replace: range,
+            insert: Range.fromPositions(Range.getStartPosition(range), position),
+        };
+    }
+
+    /** @inheritdoc */
+    async provideCompletionItems(
+        model: editor.ITextModel,
+        position: Position,
+        context: languages.CompletionContext,
+        token: CancellationToken,
+    ): Promise<languages.CompletionList | undefined> {
+        const compiled = await this.getCompileResult(model);
+        if (!compiled) return undefined;
+
+        if (context.triggerCharacter === '.') {
+            const prevWord = model.getWordAtPosition({
+                lineNumber: position.lineNumber,
+                column: position.column - 1,
+            });
+            if (prevWord?.word === 'global') {
+                const globals = await this.completeGlobal(
+                    model,
+                    undefined,
+                    [],
+                    undefined as unknown as languages.CompletionItemRanges,
+                );
+                return { suggestions: globals };
+            }
+        }
+
+        const word = wordAt(model, position);
+        const prev = model.getValueInRange({
+            startLineNumber: position.lineNumber,
+            startColumn: (word?.range.startColumn ?? position.column) - 2,
+            endLineNumber: position.lineNumber,
+            endColumn: word?.range.startColumn ?? position.column,
+        });
+
+        if (context.triggerCharacter === ':' && prev !== '::') {
+            return undefined; // 不是 :: 触发的
+        }
+
+        // suggest variables
+        let char: string | undefined;
+        let range: IRange;
+        const def = compiled.variableAccessAt(model, position);
+        if (def) {
+            if (def.ref == null) {
+                // 输入位置是变量定义
+                const suggestions: languages.CompletionItem[] = [];
+                if (
+                    word &&
+                    compiled.tags.some(
+                        (t) => strictContainsPosition(t.range, position) && t.code === DiagnosticCode.MatchExpression,
+                    )
+                ) {
+                    suggestions.push(
+                        kwSuggestion('case', this.toCompletionItemRanges(position, word.range)),
+                        kwSuggestion('if', this.toCompletionItemRanges(position, word.range)),
+                    );
+                }
+                return { suggestions };
+            }
+            const d = def.def;
+            range = d.references[def.ref]!.range;
+            char = model.getValueInRange({
+                startLineNumber: range.startLineNumber,
+                startColumn: range.startColumn,
+                endLineNumber: range.startLineNumber,
+                endColumn: range.startColumn + 1,
+            });
+        } else if (word) {
+            range = word.range;
+            char = word.word[0];
+        } else {
+            range = {
+                startLineNumber: position.lineNumber,
+                startColumn: position.column,
+                endLineNumber: position.lineNumber,
+                endColumn: position.column,
+            };
+        }
+        char = char?.toLowerCase();
+
+        const completionRange = this.toCompletionItemRanges(position, range);
+
+        if (/[^.]\.$/u.test(prev)) {
+            const suggestions = await this.completeFields(model, position, char, completionRange);
+            return { suggestions };
+        }
+
+        const suggestions = COMMON_GLOBAL_SUGGESTIONS(completionRange, prev === '::');
+        const locals = await this.completeLocal(model, position, char, completionRange);
+        const globals = await this.completeGlobal(model, char, locals, completionRange);
+        suggestions.push(...locals, ...globals);
+
+        return { suggestions };
+    }
+
+    /** @inheritdoc */
+    resolveCompletionItem(
+        item: languages.CompletionItem,
+        token: CancellationToken,
+    ): languages.CompletionItem | undefined {
+        if (typeof item.label == 'string') {
+            // not a dynamic completion item
+            return item;
+        }
+        const { vmValue, isField } = item as CustomCompletionItem;
+        const { label } = item.label;
+        if (vmValue != null) {
+            if (item.documentation) return item;
+            const last = label.split('.').pop()!;
+            const def = valueDoc(last, vmValue, isField ? 'field' : 'hint');
+            item.documentation = {
+                value: `${codeblock('\0' + def.script)}\n${def.doc.join('\n')}`,
+            };
+        }
+        return item;
+    }
+}