@mirascript/monaco 0.1.0

package/src/lsp/providers/definition-reference-provider.ts

@@ -0,0 +1,107 @@
+import type { VmAny } from '@mirascript/mirascript';
+import {
+    editor,
+    Uri,
+    type languages,
+    type CancellationToken,
+    type IRange,
+    type Position,
+    Range,
+} from '../../monaco-api.js';
+import { Provider } from './base.js';
+import { valueDoc } from '../utils.js';
+import { DOC_HEADER } from '../../constants.js';
+
+/**
+ * 转到定义/引用
+ */
+export class DefinitionReferenceProvider
+    extends Provider
+    implements languages.DefinitionProvider, languages.ReferenceProvider
+{
+    constructor(
+        private readonly globalModel = editor.createModel(``, 'mirascript', Uri.parse('mirascript:///lib/global.mira')),
+    ) {
+        super();
+    }
+    /** 准备要显示的定义 */
+    private prepareGlobal(name: string, value: VmAny): { uri: Uri; range: IRange } {
+        const { globalModel } = this;
+        const { script, doc } = valueDoc(name, value, 'declare');
+        const code = [
+            `/**${DOC_HEADER}**/`,
+            '',
+            `/**`,
+            ...doc.flatMap((sec) => sec.split('\n')).map((line) => ` * ${line}`),
+            ` */`,
+            script,
+            '',
+        ];
+        globalModel.setValue(code.join('\n'));
+        return {
+            uri: globalModel.uri,
+            range: {
+                startColumn: 1,
+                startLineNumber: code.length - 1,
+                endColumn: 1,
+                endLineNumber: code.length - 1,
+            },
+        };
+    }
+    /** @inheritdoc */
+    async provideDefinition(
+        model: editor.ITextModel,
+        position: Position,
+        token: CancellationToken,
+    ): Promise<languages.LocationLink[] | undefined> {
+        const compiled = await this.getCompileResult(model);
+        if (!compiled) return undefined;
+        const globals = await this.getContext(model);
+        const d = compiled.variableAccessAt(model, position);
+        if (!d) return [];
+        const { def, ref } = d;
+        let originSelectionRange;
+        if (ref != null) {
+            originSelectionRange = def.references[ref]?.range;
+        } else if ('definition' in def) {
+            originSelectionRange = def.definition.range;
+        }
+        let link: languages.LocationLink;
+        if ('name' in def) {
+            link = this.prepareGlobal(def.name, globals.get(def.name));
+        } else {
+            link = { uri: model.uri, range: def.definition.range };
+        }
+        link.originSelectionRange = originSelectionRange;
+        return [link];
+    }
+    /** @inheritdoc */
+    async provideReferences(
+        model: editor.ITextModel,
+        position: Position,
+        context: languages.ReferenceContext,
+        token: CancellationToken,
+    ): Promise<languages.Location[] | undefined> {
+        const compiled = await this.getCompileResult(model);
+        if (!compiled) return undefined;
+        const globals = await this.getContext(model);
+        const d = compiled.variableAccessAt(model, position);
+        if (!d) return [];
+        const { def } = d;
+        const links: languages.Location[] = def.references.map((u) => ({
+            uri: model.uri,
+            range: u.range,
+        }));
+        if (context.includeDeclaration) {
+            if ('name' in def) {
+                links.push(this.prepareGlobal(def.name, globals.get(def.name)));
+            } else if (!Range.isEmpty(def.definition.range)) {
+                links.push({
+                    uri: model.uri,
+                    range: def.definition.range,
+                });
+            }
+        }
+        return links;
+    }
+}

package/src/lsp/providers/document-highlight-provider.ts

@@ -0,0 +1,71 @@
+import { DiagnosticCode } from '@mirascript/mirascript/subtle';
+import { type Position, languages, type editor, type CancellationToken, Range } from '../../monaco-api.js';
+import { keywords } from '../../constants.js';
+import { Provider } from './base.js';
+
+/** @inheritdoc */
+export class DocumentHighlightProvider extends Provider implements languages.DocumentHighlightProvider {
+    /** @inheritdoc */
+    async provideDocumentHighlights(
+        model: editor.ITextModel,
+        position: Position,
+        token: CancellationToken,
+    ): Promise<languages.DocumentHighlight[] | undefined> {
+        const word = model.getWordAtPosition(position);
+        if (word && keywords().includes(word.word)) {
+            const result = await this.highlightKeyword(model, position, word.word);
+            if (result) return result;
+        }
+        return this.getDocumentHighlightsFromDefinition(model, position);
+    }
+
+    /** 从 definition 生成 DocumentHighlight 列表 */
+    private async getDocumentHighlightsFromDefinition(
+        model: editor.ITextModel,
+        position: Position,
+    ): Promise<languages.DocumentHighlight[] | undefined> {
+        const compiled = await this.getCompileResult(model);
+        if (!compiled) return undefined;
+        const def = compiled.variableAccessAt(model, position)?.def;
+        if (!def) return undefined;
+        const links: languages.DocumentHighlight[] = def.references.map((u) => {
+            const { code, range } = u;
+            let kind = languages.DocumentHighlightKind.Read;
+            if (
+                code === DiagnosticCode.WriteLocal ||
+                code === DiagnosticCode.ReadWriteLocal ||
+                code === DiagnosticCode.RedeclareLocal
+            ) {
+                kind = languages.DocumentHighlightKind.Write;
+            }
+            return {
+                kind,
+                range,
+            };
+        });
+        if ('definition' in def && !Range.isEmpty(def.definition.range)) {
+            links.push({
+                kind: languages.DocumentHighlightKind.Write,
+                range: def.definition.range,
+            });
+        }
+        return links;
+    }
+
+    /** 高亮关键字 */
+    private async highlightKeyword(
+        model: editor.ITextModel,
+        position: Position,
+        word: string,
+    ): Promise<languages.DocumentHighlight[] | undefined> {
+        const compiled = await this.getCompileResult(model);
+        if (!compiled) return undefined;
+        const kw = compiled.tagsReferences.find((kw) => Range.containsPosition(kw.range, position));
+        if (!kw) return undefined;
+
+        return kw.diagnostic.references.map((r) => ({
+            kind: languages.DocumentHighlightKind.Text,
+            range: r.range,
+        }));
+    }
+}

package/src/lsp/providers/document-symbol-provider.ts

@@ -0,0 +1,65 @@
+import { languages, Range, type CancellationToken, type editor } from '../../monaco-api.js';
+import { DiagnosticCode } from '@mirascript/wasm';
+import { Provider } from './base.js';
+import type { SourceScope } from '../compile-result.js';
+
+/** @inheritdoc */
+export class DocumentSymbolProvider extends Provider implements languages.DocumentSymbolProvider {
+    /** 构建树 */
+    private handleScope(model: editor.ITextModel, scope: SourceScope): languages.DocumentSymbol[] {
+        const symbols: languages.DocumentSymbol[] = [];
+        const unhandledChildren = new Set(scope.children);
+        for (const { definition } of scope.locals) {
+            const { range } = definition;
+            let kind: languages.SymbolKind = languages.SymbolKind.Variable;
+            let name: string | undefined;
+            let children: languages.DocumentSymbol[] = [];
+            let allRange = range;
+            // eslint-disable-next-line @typescript-eslint/switch-exhaustiveness-check
+            switch (definition.code) {
+                case DiagnosticCode.ParameterIt:
+                    if (definition.references.length === 0) {
+                        // 忽略未使用的 it 参数
+                        continue;
+                    }
+                    name = `it`;
+                    break;
+                case DiagnosticCode.LocalFunction: {
+                    kind = languages.SymbolKind.Function;
+                    const funcScope = scope.children.find((s) => Range.compareRangesUsingStarts(s.range, range) > 0);
+                    if (funcScope) {
+                        allRange = Range.plusRange(range, funcScope.range);
+                        children = this.handleScope(model, funcScope);
+                        unhandledChildren.delete(funcScope);
+                    }
+                    break;
+                }
+            }
+            symbols.push({
+                name: name ?? model.getValueInRange(definition.range),
+                detail: '',
+                kind,
+                range: allRange,
+                tags: [],
+                selectionRange: range,
+                children: children,
+            } satisfies languages.DocumentSymbol);
+        }
+        // 处理未处理的子作用域
+        for (const child of unhandledChildren) {
+            symbols.push(...this.handleScope(model, child));
+        }
+        return symbols;
+    }
+    /** @inheritdoc */
+    async provideDocumentSymbols(
+        model: editor.ITextModel,
+        token: CancellationToken,
+    ): Promise<languages.DocumentSymbol[] | undefined> {
+        const compiled = await this.getCompileResult(model);
+        if (!compiled) return undefined;
+        const root = compiled.scopes(model)[0];
+        if (!root) return undefined;
+        return this.handleScope(model, root);
+    }
+}

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

@@ -0,0 +1,81 @@
+import {
+    type languages,
+    type editor,
+    type IRange,
+    Range,
+    type CancellationToken,
+    type Position,
+} from '../../monaco-api.js';
+import { Provider } from './base.js';
+
+/** 格式化 */
+export class FormatterProvider
+    extends Provider
+    implements
+        languages.DocumentFormattingEditProvider,
+        languages.DocumentRangeFormattingEditProvider,
+        languages.OnTypeFormattingEditProvider
+{
+    /** @inheritdoc */
+    private async format(
+        model: editor.ITextModel,
+        ranges: readonly IRange[],
+        options: languages.FormattingOptions,
+        hint: 'full' | 'range' | 'expression' | 'statement',
+        token: CancellationToken,
+    ): Promise<languages.TextEdit[]> {
+        if (hint !== 'full') return [];
+        const compiled = await this.getCompileResult(model);
+        if (compiled?.result.formatted == null) return [];
+        return [
+            {
+                range: model.getFullModelRange(),
+                text: compiled.result.formatted,
+            },
+        ];
+    }
+    /** @inheritdoc */
+    provideDocumentFormattingEdits(
+        model: editor.ITextModel,
+        options: languages.FormattingOptions,
+        token: CancellationToken,
+    ): languages.ProviderResult<languages.TextEdit[]> {
+        return this.format(model, [], options, 'full', token);
+    }
+    /** @inheritdoc */
+    provideDocumentRangeFormattingEdits(
+        model: editor.ITextModel,
+        range: Range,
+        options: languages.FormattingOptions,
+        token: CancellationToken,
+    ): languages.ProviderResult<languages.TextEdit[]> {
+        return this.format(model, [range], options, 'range', token);
+    }
+    /** @inheritdoc */
+    provideDocumentRangesFormattingEdits(
+        model: editor.ITextModel,
+        ranges: Range[],
+        options: languages.FormattingOptions,
+        token: CancellationToken,
+    ): languages.ProviderResult<languages.TextEdit[]> {
+        return this.format(model, ranges, options, 'range', token);
+    }
+    /** @inheritdoc */
+    readonly autoFormatTriggerCharacters = [';', '}', ']', ')'];
+    /** @inheritdoc */
+    provideOnTypeFormattingEdits(
+        model: editor.ITextModel,
+        position: Position,
+        ch: string,
+        options: languages.FormattingOptions,
+        token: CancellationToken,
+    ): languages.ProviderResult<languages.TextEdit[]> {
+        return this.format(
+            model,
+            [Range.fromPositions(position, position)],
+            options,
+            ch === ';' ? 'statement' : 'expression',
+            token,
+        );
+    }
+}

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

@@ -0,0 +1,150 @@
+import type { CancellationToken, editor, IMarkdownString, IRange, languages, Position } from '../../monaco-api.js';
+import { Provider } from './base.js';
+import { DiagnosticCode } from '@mirascript/wasm';
+import { codeblock, getDeep, valueDoc, paramsList, wordAt } from '../utils.js';
+import type { FieldsAccessAt, VariableAccessAt } from '../compile-result.js';
+
+/** @inheritdoc */
+export class HoverProvider extends Provider implements languages.HoverProvider {
+    /** 变量提示 */
+    private async provideVariableHover(
+        model: editor.ITextModel,
+        { def, ref }: VariableAccessAt,
+    ): Promise<languages.Hover | undefined> {
+        const contents: IMarkdownString[] = [];
+        let range: IRange | undefined;
+        if ('name' in def) {
+            const globals = await this.getContext(model);
+            const value = globals.has(def.name) ? globals.get(def.name) : undefined;
+            const { script, doc } = valueDoc(def.name, value, 'hint');
+            contents.push({ value: codeblock(`\0(global) ${script}`) });
+            for (const d of doc) {
+                contents.push({ value: d });
+            }
+            range = def.references[ref!]?.range;
+        } else {
+            let content: IMarkdownString | undefined;
+            const tag = def.definition;
+            switch (tag.code) {
+                case DiagnosticCode.ParameterSubPatternImmutable:
+                    content = {
+                        value: codeblock(`\0(parameter pattern) ${model.getValueInRange(tag.range)}`),
+                    };
+                    break;
+                case DiagnosticCode.ParameterSubPatternMutable:
+                    content = {
+                        value: codeblock(`\0(parameter pattern) mut ${model.getValueInRange(tag.range)}`),
+                    };
+                    break;
+                case DiagnosticCode.ParameterImmutable:
+                    content = {
+                        value: codeblock(`\0(parameter) ${model.getValueInRange(tag.range)}`),
+                    };
+                    break;
+                case DiagnosticCode.ParameterMutable:
+                    content = {
+                        value: codeblock(`\0(parameter) mut ${model.getValueInRange(tag.range)}`),
+                    };
+                    break;
+                case DiagnosticCode.ParameterIt:
+                    content = {
+                        value: codeblock(`\0(parameter) it`),
+                    };
+                    break;
+                case DiagnosticCode.ParameterImmutableRest:
+                    content = {
+                        value: codeblock(`\0(parameter) ..${model.getValueInRange(tag.range)}`),
+                    };
+                    break;
+                case DiagnosticCode.ParameterMutableRest:
+                    content = {
+                        value: codeblock(`\0(parameter) ..mut ${model.getValueInRange(tag.range)}`),
+                    };
+                    break;
+                case DiagnosticCode.LocalFunction: {
+                    const params = paramsList(model, def.fn);
+                    content = {
+                        value: codeblock(`\0fn ${model.getValueInRange(tag.range)}${params}`),
+                    };
+                    break;
+                }
+                case DiagnosticCode.LocalImmutable:
+                    content = {
+                        value: codeblock(`\0let ${model.getValueInRange(tag.range)}`),
+                    };
+                    break;
+                case DiagnosticCode.LocalConst:
+                    content = {
+                        value: codeblock(`\0const ${model.getValueInRange(tag.range)}`),
+                    };
+                    break;
+                case DiagnosticCode.LocalMutable:
+                    content = {
+                        value: codeblock(`\0let mut ${model.getValueInRange(tag.range)}`),
+                    };
+                    break;
+            }
+            if (ref == null) {
+                range = tag.range;
+            } else {
+                range = def.references[ref]?.range;
+            }
+            if (content) {
+                contents.push(content);
+            }
+        }
+        if (!contents.length) return undefined;
+        return {
+            contents,
+            range: range,
+        };
+    }
+
+    /** 字段提示 */
+    private async provideFieldHover(
+        model: editor.ITextModel,
+        range: IRange,
+        { def: { def, ref }, fields }: FieldsAccessAt,
+    ): Promise<languages.Hover | undefined> {
+        if ('definition' in def) {
+            // TODO: provide local item fields
+            return undefined;
+        }
+        const vmGlobal = await this.getContext(model);
+        const value = getDeep(vmGlobal.get(def.name), fields);
+        if (value == null) return undefined;
+        const lastField = fields.pop()!;
+        const { script, doc } = valueDoc(lastField, value, 'field');
+        return {
+            contents: [{ value: codeblock(`\0(field) ${script}`) }, ...doc.map((d) => ({ value: d }))],
+            range,
+        };
+    }
+    /** @inheritdoc */
+    async provideHover(
+        model: editor.ITextModel,
+        position: Position,
+        token: CancellationToken,
+        context?: languages.HoverContext<languages.Hover>,
+    ): Promise<languages.Hover | undefined> {
+        const compiled = await this.getCompileResult(model);
+        if (!compiled) {
+            return undefined;
+        }
+        const d = compiled.variableAccessAt(model, position);
+        if (d) {
+            return this.provideVariableHover(model, d);
+        }
+        const word = wordAt(model, position);
+        if (word) {
+            const a = compiled.fieldAccessAt(model, {
+                lineNumber: position.lineNumber,
+                column: word.range.endColumn,
+            });
+            if (a) {
+                return this.provideFieldHover(model, word.range, a);
+            }
+        }
+        return undefined;
+    }
+}

package/src/lsp/providers/inlay-hints-provider.ts

@@ -0,0 +1,121 @@
+import { languages, Range, type CancellationToken, type editor, type IEvent } from '../../monaco-api.js';
+import { Provider } from './base.js';
+import { DiagnosticCode } from '@mirascript/wasm';
+
+/** @inheritdoc */
+export class InlayHintsProvider extends Provider implements languages.InlayHintsProvider {
+    /** @inheritdoc */
+    get onDidChangeInlayHints(): IEvent<void> | undefined {
+        return this.onDidChange;
+    }
+    /** @inheritdoc */
+    async provideInlayHints(
+        model: editor.ITextModel,
+        range: Range,
+        token: CancellationToken,
+    ): Promise<languages.InlayHintList | null | undefined> {
+        const compiled = await this.getCompileResult(model);
+        if (!compiled) {
+            return undefined;
+        }
+        const hints: languages.InlayHint[] = [];
+        for (const tag of compiled.tags) {
+            if (!range.containsRange(tag.range)) {
+                continue;
+            }
+            let lineNumber = 0;
+            let column = 0;
+            let label = '';
+            const kind = languages.InlayHintKind.Parameter;
+            let paddingLeft = true;
+            let paddingRight = false;
+            const edits: languages.TextEdit[] = [];
+            // eslint-disable-next-line @typescript-eslint/switch-exhaustiveness-check
+            switch (tag.code) {
+                case DiagnosticCode.ParameterIt: {
+                    if (!tag.references.length) {
+                        // 没有引用，隐藏该隐式参数
+                        continue;
+                    }
+                    lineNumber = tag.range.endLineNumber;
+                    column = tag.range.endColumn;
+                    label = '(it)';
+                    paddingLeft = /\bfn$/u.test(
+                        model.getValueInRange(new Range(lineNumber, column - 3, lineNumber, column)),
+                    );
+                    paddingRight = model.getValueInRange(new Range(lineNumber, column, lineNumber, column + 1)) === '{';
+                    edits.push({
+                        range: new Range(lineNumber, column, lineNumber, column),
+                        text: `${paddingLeft ? ' ' : ''}${label}${paddingRight ? ' ' : ''}`,
+                    });
+                    break;
+                }
+                case DiagnosticCode.UnnamedRecordField0:
+                case DiagnosticCode.UnnamedRecordField1:
+                case DiagnosticCode.UnnamedRecordField2:
+                case DiagnosticCode.UnnamedRecordField3:
+                case DiagnosticCode.UnnamedRecordField4:
+                case DiagnosticCode.UnnamedRecordField5:
+                case DiagnosticCode.UnnamedRecordField6:
+                case DiagnosticCode.UnnamedRecordField7:
+                case DiagnosticCode.UnnamedRecordField8:
+                case DiagnosticCode.UnnamedRecordField9:
+                case DiagnosticCode.UnnamedRecordFieldN: {
+                    const index = tag.code - DiagnosticCode.UnnamedRecordField0;
+                    if (index > 9) break;
+                    lineNumber = tag.range.startLineNumber;
+                    column = tag.range.startColumn;
+                    label = `${index}:`;
+                    paddingLeft = /[^\s(]/u.test(
+                        model.getValueInRange(new Range(lineNumber, column - 1, lineNumber, column)),
+                    );
+                    paddingRight = true;
+                    break;
+                }
+                case DiagnosticCode.OmitNamedRecordField: {
+                    const ref = tag.references[0];
+                    if (ref?.code !== DiagnosticCode.OmitNamedRecordFieldName) continue;
+                    lineNumber = tag.range.startLineNumber;
+                    column = tag.range.startColumn;
+                    label = model.getValueInRange(ref.range);
+                    paddingLeft = /[^\s(]/u.test(
+                        model.getValueInRange(new Range(lineNumber, column - 1, lineNumber, column)),
+                    );
+                    paddingRight = false;
+
+                    const insertRight = !/\s/u.test(
+                        model.getValueInRange(
+                            new Range(
+                                tag.range.endLineNumber,
+                                tag.range.endColumn,
+                                tag.range.endLineNumber,
+                                tag.range.endColumn + 1,
+                            ),
+                        ),
+                    );
+                    edits.push({
+                        range: tag.range,
+                        text: `${paddingLeft ? ' ' : ''}${label}${model.getValueInRange(tag.range)}${insertRight ? ' ' : ''}`,
+                    });
+                    break;
+                }
+            }
+            if (!label) continue;
+            const hint: languages.InlayHint = {
+                position: { lineNumber, column },
+                label,
+                kind,
+                paddingLeft,
+                paddingRight,
+                textEdits: edits,
+            };
+            hints.push(hint);
+        }
+        return {
+            hints,
+            dispose: () => {
+                // Cleanup if necessary
+            },
+        };
+    }
+}

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

@@ -0,0 +1,37 @@
+import { Range, type CancellationToken, type editor, type languages, type Position } from '../../monaco-api.js';
+import { Provider } from './base.js';
+
+/** @inheritdoc */
+export class RangeProvider
+    extends Provider
+    implements languages.FoldingRangeProvider, languages.SelectionRangeProvider
+{
+    /** @inheritdoc */
+    async provideFoldingRanges(
+        model: editor.ITextModel,
+        context: languages.FoldingContext,
+        token: CancellationToken,
+    ): Promise<languages.FoldingRange[] | undefined> {
+        const compiled = await this.getCompileResult(model);
+        if (!compiled) return undefined;
+        // 暂时没必要
+        return undefined;
+    }
+    /** @inheritdoc */
+    async provideSelectionRanges(
+        model: editor.ITextModel,
+        positions: Position[],
+        token: CancellationToken,
+    ): Promise<languages.SelectionRange[][] | undefined> {
+        const compiled = await this.getCompileResult(model);
+        if (!compiled) return undefined;
+        const { ranges } = compiled.groupedTags(model);
+        return positions.map((pos) => {
+            return ranges
+                .filter((r) => Range.containsPosition(r.range, pos))
+                .map((t) => ({
+                    range: t.range,
+                }));
+        });
+    }
+}