@mirascript/monaco 0.1.87 → 0.1.88

package/src/basic/textmate-to-monaco.ts

@@ -0,0 +1,49 @@
+const REMAP_PREFIXES: ReadonlyArray<[string, string]> = [
+    ['constant.character.escape.', 'string.escape.'],
+    ['constant.numeric.', 'number.'],
+    ['constant.language.', 'keyword.'],
+    ['support.variable.', 'variable.'],
+    ['entity.name.type.', 'type.'],
+    ['support.type.', 'type.'],
+    ['entity.name.namespace.', 'namespace.'],
+    ['entity.name.function.', 'function.'],
+];
+
+/** Remap scope */
+function remapScope(scope: string): string {
+    for (const [prefix, remap] of REMAP_PREFIXES) {
+        if (scope.startsWith(prefix)) {
+            return remap + scope.slice(prefix.length);
+        }
+    }
+    return scope;
+}
+
+const STYLED_SCOPE_PREFIXES = [
+    'invalid.',
+    'comment.',
+    'string.',
+    'keyword.',
+    'constant.',
+    'variable.',
+    'entity.',
+    'storage.',
+    'support.',
+    'markup.',
+    'meta.embedded.',
+];
+/** Is styled scope */
+function isStyledScope(scope: string): boolean {
+    return STYLED_SCOPE_PREFIXES.some((prefix) => scope.startsWith(prefix));
+}
+
+/** Select the deepest scope that a native Monaco theme can style. */
+export function textmateScopesToMonaco(scopes: readonly string[]): string {
+    let fallback;
+    for (let index = scopes.length - 1; index >= 0; index -= 1) {
+        const scope = scopes[index]!;
+        fallback ||= scope;
+        if (isStyledScope(scope)) return remapScope(scope);
+    }
+    return fallback ? remapScope(fallback) : 'source.mira';
+}

package/src/basic/tokens-provider.ts

@@ -1,135 +1,18 @@
-import type { HighlighterCore, Grammar } from '@shikijs/core';
+import type { Grammar } from '@shikijs/core';
 import type { StateStack } from '@shikijs/vscode-textmate';
 import { languages, type IDisposable } from '../monaco-api.js';
 import { CONTRIBUTE_IDS } from '../contribute.js';
+import { getHighlighter, getInitialState } from './highlighter-manager.js';
+import { textmateScopesToMonaco } from './textmate-to-monaco.js';
 
 const TOKENIZE_MAX_LINE_LENGTH = 20000;
 const TOKENIZE_TIME_LIMIT = 500;
 
-const REMAP_PREFIXES: ReadonlyArray<[string, string]> = [
-    ['constant.character.escape.', 'string.escape.'],
-    ['constant.numeric.', 'number.'],
-    ['constant.language.', 'keyword.'],
-    ['support.variable.', 'variable.'],
-    ['entity.name.type.', 'type.'],
-    ['support.type.', 'type.'],
-    ['entity.name.namespace.', 'namespace.'],
-    ['entity.name.function.', 'function.'],
-];
-
-/** Remap scope */
-function remapScope(scope: string): string {
-    for (const [prefix, remap] of REMAP_PREFIXES) {
-        if (scope.startsWith(prefix)) {
-            return remap + scope.slice(prefix.length);
-        }
-    }
-    return scope;
-}
-
-const STYLED_SCOPE_PREFIXES = [
-    'invalid.',
-    'comment.',
-    'string.',
-    'keyword.',
-    'constant.',
-    'variable.',
-    'entity.',
-    'storage.',
-    'support.',
-    'markup.',
-];
-/** Is styled scope */
-function isStyledScope(scope: string): boolean {
-    return STYLED_SCOPE_PREFIXES.some((prefix) => scope.startsWith(prefix));
-}
-
-/** Select the deepest scope that a native Monaco theme can style. */
-function tokenScope(scopes: string[]): string {
-    let embedded = scopes.findLastIndex((scope) => scope.startsWith('meta.embedded.'));
-    if (embedded === -1) {
-        embedded = 0;
-    }
-    let fallback;
-    for (let index = scopes.length - 1; index >= embedded; index -= 1) {
-        const scope = scopes[index]!;
-        fallback ||= scope;
-        if (isStyledScope(scope)) return remapScope(scope);
-        if (scope.startsWith('meta.embedded.')) break;
-    }
-    return fallback ? remapScope(fallback) : 'source.mira';
-}
-
-/** Shared instance of highlighter. */
-class HighlighterManager implements IDisposable {
-    private highlighterPromise: Promise<HighlighterCore> | null = null;
-    private INITIAL!: StateStack;
-    /**
-     * Load the shared highlighter instance.
-     */
-    private async loadHighlighter(): Promise<HighlighterCore> {
-        const [
-            { createHighlighterCore },
-            { createJavaScriptRegexEngine },
-            { INITIAL },
-            { mirascript, mirascriptDoc, mirascriptTemplate },
-        ] = await Promise.all([
-            import('@shikijs/core'),
-            import('@shikijs/engine-javascript'),
-            import('@shikijs/vscode-textmate'),
-            import('@mirascript/textmate'),
-        ]);
-        this.INITIAL = INITIAL;
-        return await createHighlighterCore({
-            langs: [mirascript, mirascriptDoc, mirascriptTemplate],
-            themes: [],
-            engine: createJavaScriptRegexEngine(),
-        });
-    }
-
-    /**
-     * Get the shared highlighter instance.
-     */
-    private async getHighlighter(): Promise<HighlighterCore> {
-        this.highlighterPromise ??= this.loadHighlighter();
-        return this.highlighterPromise;
-    }
-
-    /** Get tokens provider factory of language */
-    getTokensProviderFactory(languageId: string): languages.TokensProviderFactory {
-        return {
-            create: async () => {
-                const highlighter = await this.getHighlighter();
-                const grammar = highlighter.getLanguage(languageId);
-                return new TokensProvider(grammar, this.INITIAL);
-            },
-        };
-    }
-    /** @inheritdoc */
-    dispose(): void {
-        const promise = this.highlighterPromise;
-        this.highlighterPromise = null;
-        if (promise) {
-            promise
-                .then((highlighter) => highlighter.dispose())
-                .catch(() => {
-                    // eslint-disable-next-line no-console
-                    console.error('Failed to dispose highlighter');
-                });
-        }
-    }
-}
-
 /** A Monaco tokens provider that uses TextMate grammars. */
 class TokensProvider implements languages.TokensProvider {
-    constructor(
-        private readonly grammar: Grammar,
-        private readonly INITIAL: StateStack,
-    ) {}
+    constructor(private readonly grammar: Grammar) {}
     /** @inheritdoc */
-    getInitialState(): StateStack {
-        return this.INITIAL;
-    }
+    getInitialState = getInitialState;
     /** @inheritdoc */
     tokenize(line: string, state: StateStack): languages.ILineTokens {
         if (line.length >= TOKENIZE_MAX_LINE_LENGTH) {
@@ -152,7 +35,7 @@ class TokensProvider implements languages.TokensProvider {
             endState: result.ruleStack,
             tokens: result.tokens.map((token) => ({
                 startIndex: token.startIndex,
-                scopes: tokenScope(token.scopes),
+                scopes: textmateScopesToMonaco(token.scopes),
             })),
         };
     }
@@ -160,10 +43,18 @@ class TokensProvider implements languages.TokensProvider {
 
 /** Register TextMate-backed token providers without changing Monaco themes. */
 export function registerMiraScriptTokensProvider(): IDisposable[] {
-    const manager = new HighlighterManager();
-    const disposables = CONTRIBUTE_IDS.map((id) =>
-        languages.registerTokensProviderFactory(id, manager.getTokensProviderFactory(id)),
+    const disposables = [
+        CONTRIBUTE_IDS.mirascript,
+        CONTRIBUTE_IDS.mirascriptDoc,
+        CONTRIBUTE_IDS.mirascriptTemplate,
+    ].map((id) =>
+        languages.registerTokensProviderFactory(id, {
+            create: async () => {
+                const highlighter = await getHighlighter();
+                const grammar = highlighter.getLanguage(id);
+                return new TokensProvider(grammar);
+            },
+        }),
     );
-    disposables.push(manager);
     return disposables;
 }

package/src/contribute.ts

@@ -1,7 +1,11 @@
 import { mirascriptLanguage, mirascriptDocLanguage, mirascriptTemplateLanguage } from '@mirascript/textmate/language';
 import { languages } from './monaco-api.js';
 
-export const CONTRIBUTE_IDS = [mirascriptLanguage.name, mirascriptTemplateLanguage.name, mirascriptDocLanguage.name];
+export const CONTRIBUTE_IDS = Object.freeze({
+    mirascript: mirascriptLanguage.name,
+    mirascriptTemplate: mirascriptTemplateLanguage.name,
+    mirascriptDoc: mirascriptDocLanguage.name,
+});
 
 /** 注册语言 */
 export function registerContribution(): void {

package/src/index.ts

@@ -1,6 +1,6 @@
 import type { VmContext } from '@mirascript/mirascript';
 import { type editor, languages, registerMonacoApi, type IDisposable, type MonacoApi } from './monaco-api.js';
-import { registerContribution } from './contribute.js';
+import { CONTRIBUTE_IDS, registerContribution } from './contribute.js';
 import type { LspFeaturesConfig } from './lsp/index.js';
 export type { monaco as monacoApi } from './monaco-api.js';
 
@@ -15,13 +15,13 @@ export class MiraScriptMonacoLoader implements IDisposable {
         const _loadBasicFeatures = () => void this.loadBasicFeatures();
         const _loadFullFeatures = () => void this.loadLSPFeatures();
 
-        languages.onLanguageEncountered('mirascript', _loadBasicFeatures);
-        languages.onLanguage('mirascript', _loadFullFeatures);
+        languages.onLanguageEncountered(CONTRIBUTE_IDS.mirascript, _loadBasicFeatures);
+        languages.onLanguage(CONTRIBUTE_IDS.mirascript, _loadFullFeatures);
 
-        languages.onLanguageEncountered('mirascript-template', _loadBasicFeatures);
-        languages.onLanguage('mirascript-template', _loadFullFeatures);
+        languages.onLanguageEncountered(CONTRIBUTE_IDS.mirascriptTemplate, _loadBasicFeatures);
+        languages.onLanguage(CONTRIBUTE_IDS.mirascriptTemplate, _loadFullFeatures);
 
-        languages.onLanguageEncountered('mirascript-doc', _loadBasicFeatures);
+        languages.onLanguageEncountered(CONTRIBUTE_IDS.mirascriptDoc, _loadBasicFeatures);
     }
     features: LspFeaturesConfig = {};
     private _basicFeaturesLoaded = false;

package/src/lsp/index.ts

@@ -6,7 +6,7 @@ import { Provider } from './providers/base.js';
 import { CodeActionProvider } from './providers/code-action-provider.js';
 import { CodeLensProvider } from './providers/code-lens-provider.js';
 import { ColorProvider } from './providers/color-provider.js';
-import { CompletionItemProvider } from './providers/completion-item-provider.js';
+import { CompletionItemProvider } from './providers/completion-item-provider/index.js';
 import { DefinitionReferenceProvider } from './providers/definition-reference-provider.js';
 import { DocumentHighlightProvider } from './providers/document-highlight-provider.js';
 import { DocumentSymbolProvider } from './providers/document-symbol-provider.js';

package/src/lsp/providers/completion-item-provider/common-global-suggestions.ts

@@ -0,0 +1,155 @@
+import { KEYWORDS as HELP_KEYWORDS } from '@mirascript/help';
+import { KEYWORDS, RESERVED_KEYWORDS } from '../../../constants.js';
+import { languages } from '../../../monaco-api.js';
+import { codeblock } from '../../utils.js';
+
+/** 构造关键字选项 */
+export function kwSuggestion(kw: string, range: languages.CompletionItemRanges): languages.CompletionItem {
+    const doc = (HELP_KEYWORDS as Record<string, string | undefined>)[kw];
+    return {
+        label: kw,
+        kind: languages.CompletionItemKind.Keyword,
+        insertText: kw,
+        documentation: doc ? { value: doc } : undefined,
+        range,
+    };
+}
+
+const SUGGEST_KEYWORDS: string[] = [];
+
+const loadSuggestKeywords = () => {
+    if (SUGGEST_KEYWORDS.length > 0) return SUGGEST_KEYWORDS; // 已加载过
+    for (const kw of KEYWORDS) {
+        if (RESERVED_KEYWORDS.includes(kw as never)) continue; // 跳过保留关键字
+        SUGGEST_KEYWORDS.push(kw);
+    }
+    return SUGGEST_KEYWORDS;
+};
+
+export 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: HELP_KEYWORDS.type },
+            range,
+        },
+        {
+            label: 'global',
+            kind: languages.CompletionItemKind.Keyword,
+            insertText: 'global',
+            commitCharacters: ['.', '['],
+            documentation: { value: HELP_KEYWORDS.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.some(
+                (item) => item.label === kw && item.kind === languages.CompletionItemKind.Keyword,
+            );
+            if (exist) continue;
+            suggestions.push(kwSuggestion(kw, range));
+        }
+    }
+    return suggestions;
+};

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

@@ -0,0 +1,64 @@
+import { isVmWrapper, type VmAny } from '@mirascript/mirascript';
+import { lib } from '@mirascript/mirascript/subtle';
+import { getDeep, getField } from '../../utils.js';
+import type { editor, languages, Position } from '../../../monaco-api.js';
+import { REG_IDENTIFIER_FULL, REG_ORDINAL_FULL } from '../../../constants.js';
+import { DESC_FIELD, type CustomCompletionItem } from './interface.js';
+import { Provider } from '../base.js';
+import { completion } from './utils.js';
+
+/** 列出属性 */
+function listFields(obj: VmAny, includeNonEnumerable: boolean): Array<string | number> {
+    if (obj == null || typeof obj != 'object') return [];
+    if (isVmWrapper(obj)) {
+        try {
+            return obj.keys(includeNonEnumerable);
+        } catch {
+            return [];
+        }
+    }
+    return lib.keys(obj);
+}
+
+/** 查找变量字段 */
+export async function completeFields(
+    model: editor.ITextModel,
+    position: Position,
+    char: string | undefined,
+    range: languages.CompletionItemRanges,
+): Promise<CustomCompletionItem[]> {
+    const compiled = await Provider.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 Provider.getContext(model);
+    fields.pop(); // 移除最后一个部分，因为它是当前输入位置的字段名
+    const [, value] = getDeep(vmGlobal, def.def.name, fields);
+    if (value == null || typeof value != 'object') {
+        return [];
+    }
+    const keys = listFields(value, true);
+    const result: CustomCompletionItem[] = [];
+    for (const k of keys) {
+        const key = String(k);
+        if (char && !String(key).toLowerCase().includes(char)) {
+            continue;
+        }
+        if (!REG_IDENTIFIER_FULL.test(key) && !REG_ORDINAL_FULL.test(key)) {
+            continue;
+        }
+        const field = getField(value, key);
+        result.push({
+            insertText: key,
+            range,
+            vmParent: isVmWrapper(value) ? value : undefined,
+            ...completion(model, DESC_FIELD, key, field, undefined, true),
+        });
+    }
+    return result;
+}

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

@@ -0,0 +1,82 @@
+import { isVmModule, serialize } from '@mirascript/mirascript';
+import type { editor, languages } from '../../../monaco-api.js';
+import { Provider } from '../base.js';
+import { isDeprecatedGlobal } from '../../utils.js';
+import { REG_IDENTIFIER_FULL, isKeyword } from '../../../constants.js';
+import { DESC_GLOBAL, type CustomCompletionItem } from './interface.js';
+import { completion, filterText } from './utils.js';
+
+/** 查找全局变量 */
+export async function completeGlobal(
+    model: editor.ITextModel,
+    char: string | undefined,
+    locals: readonly CustomCompletionItem[],
+    range: languages.CompletionItemRanges,
+    hasGlobalPrefix: boolean,
+): Promise<CustomCompletionItem[]> {
+    const global = await Provider.getContext(model);
+    const suggestions: CustomCompletionItem[] = [];
+    const localKeys = new Set(locals.map((item) => item.insertText));
+    for (const key of new Set(global.keys())) {
+        // skip deprecated globals in completion
+        if (!global.has(key) || isDeprecatedGlobal(global, key)) continue;
+
+        const element = global.get(key);
+
+        let prefix = key;
+        const edits: editor.ISingleEditOperation[] = [];
+        if (!REG_IDENTIFIER_FULL.test(key)) {
+            const kStr = serialize(key);
+            if (hasGlobalPrefix) {
+                prefix = `[${kStr}]`;
+                // 删除多余的 . 前缀
+                edits.push({
+                    range: {
+                        startLineNumber: range.replace.startLineNumber,
+                        startColumn: range.replace.startColumn - 1,
+                        endLineNumber: range.replace.endLineNumber,
+                        endColumn: range.replace.endColumn,
+                    },
+                    text: '',
+                });
+            } else {
+                prefix = `global[${serialize(key)}]`;
+            }
+        } else if (!hasGlobalPrefix && (localKeys.has(key) || isKeyword(key))) {
+            prefix = `global.${key}`;
+        }
+
+        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: `${prefix}.${f}`,
+                    filterText: filterText(f, char),
+                    range,
+                    additionalTextEdits: edits,
+                    vmParent: element,
+                    ...completion(model, DESC_GLOBAL, `${key}.${f}`, field, undefined, true),
+                });
+            }
+        }
+
+        if (char && !key.toLowerCase().includes(char)) {
+            continue;
+        }
+
+        suggestions.push({
+            insertText: prefix,
+            filterText: filterText(key, char),
+            range,
+            additionalTextEdits: edits,
+            vmParent: global,
+            ...completion(model, DESC_GLOBAL, key, element, undefined, false),
+        });
+    }
+    return suggestions;
+}

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

@@ -0,0 +1,57 @@
+import { DiagnosticCode } from '@mirascript/mirascript/subtle';
+import { type editor, languages, type IPosition } from '../../../monaco-api.js';
+import { DESC_LOCAL, type CustomCompletionItem } from './interface.js';
+import { completion, filterText } from './utils.js';
+import { Provider } from '../base.js';
+import type { LocalDefinition } from '../../compile-result.js';
+
+/** 创建局部变量 */
+function createLocalCompletionItem(
+    model: editor.ITextModel,
+    char: string | undefined,
+    range: languages.CompletionItemRanges,
+    locals: Set<string>,
+    { definition, fn }: LocalDefinition,
+): CustomCompletionItem | null {
+    const name = definition.code === DiagnosticCode.ParameterIt ? 'it' : model.getValueInRange(definition.range);
+    if (char && !name.toLowerCase().includes(char)) return null;
+    if (locals.has(name)) return null; // 子作用域可能会覆盖父作用域的变量
+
+    locals.add(name);
+    const suggestion = {
+        insertText: name,
+        filterText: filterText(name, char),
+        range,
+        ...completion(model, DESC_LOCAL, name, undefined, fn, false),
+    };
+    if (definition.code === DiagnosticCode.LocalModule) {
+        suggestion.kind = languages.CompletionItemKind.Module;
+    } else if (definition.code === DiagnosticCode.LocalFunction) {
+        suggestion.kind = languages.CompletionItemKind.Function;
+    }
+    return suggestion;
+}
+
+/** 查找局部变量 */
+export async function completeLocal(
+    model: editor.ITextModel,
+    position: IPosition,
+    char: string | undefined,
+    range: languages.CompletionItemRanges,
+): Promise<CustomCompletionItem[]> {
+    const compiled = await Provider.getCompileResult(model);
+    if (!compiled) return [];
+    const suggestions: CustomCompletionItem[] = [];
+
+    let scope = compiled.scopeAt(model, position);
+    const locals = new Set<string>();
+    while (scope) {
+        for (const def of scope.locals) {
+            const suggestion = createLocalCompletionItem(model, char, range, locals, def);
+            if (suggestion) suggestions.push(suggestion);
+        }
+        if (!scope.parent) break;
+        scope = scope.parent;
+    }
+    return suggestions;
+}