@mirascript/monaco 0.1.0

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

@@ -0,0 +1,144 @@
+import {
+    Range,
+    type CancellationToken,
+    type editor,
+    type IRange,
+    type languages,
+    type Position,
+} from '../../monaco-api.js';
+import { DiagnosticCode } from '@mirascript/wasm';
+import { Provider } from './base.js';
+import type { CompileResult } from '../compile-result.js';
+
+/** @inheritdoc */
+export class RenameProvider extends Provider implements languages.RenameProvider {
+    /** 重命名推断字段 */
+    private provideRenameEditsOmitNameFields(
+        model: editor.ITextModel,
+        compiled: CompileResult,
+        edits: languages.IWorkspaceTextEdit[],
+        ref: { range: IRange },
+        oldName: string,
+    ): void {
+        const { omitNameFields } = compiled.groupedTags(model);
+        for (const tag of omitNameFields) {
+            if (Range.equalsRange(tag.references[0]?.range, ref.range)) {
+                const current = model.getValueInRange(tag.range);
+                const paddingLeft = /[^\s(]/u.test(
+                    model.getValueInRange({
+                        startLineNumber: tag.range.startLineNumber,
+                        startColumn: tag.range.startColumn - 1,
+                        endLineNumber: tag.range.startLineNumber,
+                        endColumn: tag.range.startColumn,
+                    }),
+                );
+                const paddingRight = !/\s/u.test(
+                    model.getValueInRange({
+                        startLineNumber: tag.range.endLineNumber,
+                        startColumn: tag.range.endColumn,
+                        endLineNumber: tag.range.endLineNumber,
+                        endColumn: tag.range.endColumn + 1,
+                    }),
+                );
+                edits.push({
+                    resource: model.uri,
+                    versionId: compiled.version,
+                    textEdit: {
+                        range: tag.range,
+                        text: `${paddingLeft ? ' ' : ''}${oldName}${current}${paddingRight ? ' ' : ''}`,
+                    },
+                });
+            }
+        }
+    }
+    /** @inheritdoc */
+    async provideRenameEdits(
+        model: editor.ITextModel,
+        position: Position,
+        newName: string,
+        token: CancellationToken,
+    ): Promise<undefined | (languages.WorkspaceEdit & languages.Rejection)> {
+        newName = newName.trim();
+        const compiled = await this.getCompileResult(model);
+        if (!compiled) return undefined;
+        const d = compiled.variableAccessAt(model, position);
+        if (!d) return undefined;
+        const edits: languages.IWorkspaceTextEdit[] = [];
+        const { references } = d.def;
+        let oldName;
+        if ('definition' in d.def) {
+            edits.push({
+                resource: model.uri,
+                versionId: compiled.version,
+                textEdit: {
+                    range: d.def.definition.range,
+                    text: d.def.definition.code === DiagnosticCode.ParameterIt ? `(${newName})` : newName,
+                },
+            });
+            oldName = model.getValueInRange(d.def.definition.range);
+            this.provideRenameEditsOmitNameFields(model, compiled, edits, d.def.definition, oldName);
+        } else {
+            oldName = d.def.name;
+        }
+        for (const ref of references) {
+            edits.push({
+                resource: model.uri,
+                versionId: compiled.version,
+                textEdit: {
+                    range: ref.range,
+                    text: newName,
+                },
+            });
+            this.provideRenameEditsOmitNameFields(model, compiled, edits, ref, oldName);
+        }
+
+        const { globals } = compiled.groupedTags(model);
+        const globalWithSameName = globals.find((g) => g.name === newName);
+        if (globalWithSameName) {
+            for (const ref of globalWithSameName.references) {
+                edits.push({
+                    resource: model.uri,
+                    versionId: compiled.version,
+                    textEdit: {
+                        range: ref.range,
+                        text: `global.${newName}`,
+                    },
+                });
+                this.provideRenameEditsOmitNameFields(model, compiled, edits, ref, oldName);
+            }
+        }
+
+        return { edits };
+    }
+
+    /** @inheritdoc */
+    async resolveRenameLocation(
+        model: editor.ITextModel,
+        position: Position,
+        token: CancellationToken,
+    ): Promise<undefined | (languages.RenameLocation & languages.Rejection)> {
+        const compiled = await this.getCompileResult(model);
+        if (!compiled) return undefined;
+        const d = compiled.variableAccessAt(model, position);
+        if (!d) {
+            return {
+                range: Range.fromPositions(position),
+                text: '',
+                rejectReason: 'Cannot rename this element',
+            };
+        }
+        const { def, ref } = d;
+        if ('name' in def) {
+            return {
+                range: def.references[ref!]?.range ?? Range.fromPositions(position),
+                text: def.name,
+                rejectReason: 'Cannot rename global variables',
+            };
+        }
+        const tag = ref == null ? def.definition : def.references[ref]!;
+        return {
+            range: tag.range,
+            text: model.getValueInRange(tag.range) ?? '',
+        };
+    }
+}

package/src/lsp/providers/semantic-tokens-provider.ts

@@ -0,0 +1,166 @@
+import { isVmFunction, isVmModule } from '@mirascript/mirascript';
+import { DiagnosticCode } from '@mirascript/wasm';
+import { Range, type CancellationToken, type editor, type languages } from '../../monaco-api.js';
+import { Provider } from './base.js';
+
+enum TokenType {
+    VARIABLE,
+    VARIABLE_MUTABLE,
+    CONSTANT,
+    GLOBAL,
+    FUNCTION,
+    MODULE,
+    PROPERTY,
+    KEYWORD_CONTROL,
+    PARAM,
+    PARAM_MUTABLE,
+}
+
+const TOKEN_TYPES: Record<TokenType, string> = {
+    [TokenType.VARIABLE]: 'variable.other.constant',
+    [TokenType.VARIABLE_MUTABLE]: 'variable',
+    [TokenType.CONSTANT]: 'variable.other.constant',
+    [TokenType.GLOBAL]: 'variable',
+    [TokenType.FUNCTION]: 'entity.name.function',
+    [TokenType.MODULE]: 'entity.name.namespace',
+    [TokenType.PROPERTY]: 'support.type.property-name',
+    [TokenType.KEYWORD_CONTROL]: 'keyword.control',
+    [TokenType.PARAM]: 'variable.other.constant.emphasis',
+    [TokenType.PARAM_MUTABLE]: 'variable.emphasis',
+};
+
+/** @inheritdoc */
+export class DocumentSemanticTokensProvider extends Provider implements languages.DocumentSemanticTokensProvider {
+    /** @inheritdoc */
+    getLegend(): languages.SemanticTokensLegend {
+        const tokenTypes = Object.values(TOKEN_TYPES);
+        return {
+            tokenTypes,
+            tokenModifiers: tokenTypes.map((_) => ''),
+        };
+    }
+    /** @inheritdoc */
+    async provideDocumentSemanticTokens(
+        model: editor.ITextModel,
+        lastResultId: string | null,
+        token: CancellationToken,
+    ): Promise<languages.SemanticTokens | null | undefined> {
+        const resultId = `${model.uri.toString()}?${model.getVersionId()}`;
+        const compiled = await this.getCompileResult(model);
+        if (!compiled) {
+            return undefined;
+        }
+        const globals = await this.getContext(model);
+
+        // data 长度是 5 的倍数
+        // [diffRow, diffCol, length, tokenType(index), tokenModifiers(bit field)]
+        const data = [];
+        for (const { code, range, references } of compiled.tags) {
+            if (Range.isEmpty(range)) continue;
+
+            let tokenType: TokenType | -1 = -1;
+            let onlyReferences = false;
+            // eslint-disable-next-line @typescript-eslint/switch-exhaustiveness-check
+            switch (code) {
+                case DiagnosticCode.GlobalVariable: {
+                    const id = model.getValueInRange(range);
+                    if (id.startsWith('@')) {
+                        tokenType = TokenType.CONSTANT;
+                    } else if (isVmFunction(globals.get(id))) {
+                        tokenType = TokenType.FUNCTION;
+                    } else if (isVmModule(globals.get(id))) {
+                        tokenType = TokenType.MODULE;
+                    } else {
+                        tokenType = TokenType.GLOBAL;
+                    }
+                    break;
+                }
+                case DiagnosticCode.LocalFunction: {
+                    tokenType = TokenType.FUNCTION;
+                    break;
+                }
+                case DiagnosticCode.ParameterMutable:
+                case DiagnosticCode.ParameterSubPatternMutable:
+                case DiagnosticCode.ParameterMutableRest: {
+                    tokenType = TokenType.PARAM_MUTABLE;
+                    break;
+                }
+                case DiagnosticCode.LocalMutable: {
+                    tokenType = TokenType.VARIABLE_MUTABLE;
+                    break;
+                }
+                case DiagnosticCode.ParameterImmutable:
+                case DiagnosticCode.ParameterSubPatternImmutable:
+                case DiagnosticCode.ParameterImmutableRest: {
+                    tokenType = TokenType.PARAM;
+                    break;
+                }
+                case DiagnosticCode.LocalImmutable: {
+                    tokenType = TokenType.VARIABLE;
+                    break;
+                }
+                case DiagnosticCode.LocalConst: {
+                    tokenType = TokenType.CONSTANT;
+                    break;
+                }
+                case DiagnosticCode.RecordFieldIdName: {
+                    tokenType = TokenType.PROPERTY;
+                    break;
+                }
+                case DiagnosticCode.ForExpression: {
+                    tokenType = TokenType.KEYWORD_CONTROL; // 标记为控制流关键字
+                    onlyReferences = true; // for 表达式本身不需要标记
+                    break;
+                }
+            }
+            if (tokenType < 0) continue;
+            const { startLineNumber, startColumn, endColumn } = range;
+            const length = endColumn - startColumn;
+            if (!onlyReferences) {
+                data.push({
+                    row: startLineNumber - 1, // 从 0 开始
+                    col: startColumn - 1,
+                    length,
+                    tokenType,
+                    tokenModifiers: 1 << tokenType,
+                });
+            }
+            for (const ref of references) {
+                data.push({
+                    row: ref.range.startLineNumber - 1,
+                    col: ref.range.startColumn - 1,
+                    length: ref.range.endColumn - ref.range.startColumn,
+                    tokenType,
+                    tokenModifiers: 1 << tokenType,
+                });
+            }
+        }
+        data.sort((a, b) => {
+            if (a.row !== b.row) {
+                return a.row - b.row;
+            }
+            return a.col - b.col;
+        });
+        const bin = new Uint32Array(data.length * 5);
+        for (let i = 0; i < data.length; i++) {
+            const current = data[i]!;
+            let { row, col } = current;
+            if (i > 0) {
+                const prev = data[i - 1]!;
+                row -= prev.row;
+                if (row === 0) {
+                    col -= prev.col;
+                }
+            }
+            bin.set([row, col, current.length, current.tokenType, current.tokenModifiers], i * 5);
+        }
+        return {
+            resultId,
+            data: bin,
+        };
+    }
+    /** @inheritdoc */
+    releaseDocumentSemanticTokens(resultId: string | undefined): void {
+        //
+    }
+}

package/src/lsp/providers/signature-help-provider.ts

@@ -0,0 +1,119 @@
+import { DiagnosticCode } from '@mirascript/wasm';
+import { type editor, type languages, type CancellationToken, Position, Range } from '../../monaco-api.js';
+import { Provider } from './base.js';
+import { fnSignature, getDeep, localParamSignature, strictContainsPosition } from '../utils.js';
+import { getVmFunctionInfo } from '@mirascript/mirascript';
+
+/** @inheritdoc */
+export class SignatureHelpProvider extends Provider implements languages.SignatureHelpProvider {
+    /** @inheritdoc */
+    readonly signatureHelpTriggerCharacters = ['(', ','];
+    /** @inheritdoc */
+    readonly signatureHelpRetriggerCharacters = [')'];
+    /** @inheritdoc */
+    async provideSignatureHelp(
+        model: editor.ITextModel,
+        position: Position,
+        token: CancellationToken,
+        context: languages.SignatureHelpContext,
+    ): Promise<languages.SignatureHelpResult | undefined> {
+        const compiled = await this.getCompileResult(model);
+        if (!compiled) return undefined;
+
+        const invokes = compiled.groupedTags(model).ranges.filter((r) => {
+            if (r.code !== DiagnosticCode.FunctionCall && r.code !== DiagnosticCode.ExtensionCall) {
+                return false;
+            }
+            if (!strictContainsPosition(r.range, position)) {
+                return false;
+            }
+            const argStart = r.references.find((ref) => ref.code === DiagnosticCode.ArgumentStart);
+            const argEnd = r.references.find((ref) => ref.code === DiagnosticCode.ArgumentEnd);
+            if (!argStart || !argEnd) {
+                return false;
+            }
+            return Range.containsPosition(
+                Range.fromPositions(Range.getEndPosition(argStart.range), Range.getStartPosition(argEnd.range)),
+                position,
+            );
+        });
+        if (!invokes.length) return undefined;
+        // 获取最内层的调用
+        invokes.sort((a, b) => (Range.strictContainsRange(a.range, b.range) ? 1 : -1));
+        const invoke = invokes[0]!;
+
+        const callableRef = invoke.references.find((ref) => ref.code === DiagnosticCode.Callable);
+        if (!callableRef) return undefined;
+        const callableInfo = compiled.accessAt(model, Range.getEndPosition(callableRef.range));
+        if (!callableInfo) return undefined;
+
+        let sig;
+        if ('name' in callableInfo.def.def) {
+            const { name } = callableInfo.def.def;
+            const globals = await this.getContext(model);
+            const callable = getDeep(globals.get(name), callableInfo.fields);
+            const info = getVmFunctionInfo(callable);
+            if (!info) return undefined;
+            sig = { ...fnSignature(name, info), name, summary: info.summary };
+        } else if (callableInfo.def.def.fn) {
+            const { fn, definition } = callableInfo.def.def;
+            const params = localParamSignature(model, fn);
+            const name = model.getValueInRange(definition.range);
+            sig = { params, returns: '', name, summary: '' };
+        }
+
+        if (!sig) return undefined;
+        const signature: languages.SignatureInformation = {
+            label: '',
+            parameters: [],
+        };
+        if (invoke.code === DiagnosticCode.ExtensionCall) {
+            const thisArg = sig.params[0];
+            if (thisArg && !thisArg[0].startsWith('..')) {
+                sig.params.shift();
+                const s = thisArg[1].includes(' ') ? `(${thisArg[1]})` : thisArg[1];
+                signature.label = `fn ${s}::${sig.name}(`;
+            } else {
+                signature.label = `fn ()::${sig.name}(`;
+            }
+        } else {
+            signature.label = `fn ${sig.name}(`;
+        }
+        signature.documentation = { value: sig.summary ?? '' };
+        for (let i = 0; i < sig.params.length; i++) {
+            const [_, p, doc] = sig.params[i]!;
+            const start = signature.label.length;
+            signature.parameters.push({
+                label: [start, start + p.length],
+                documentation: { value: doc },
+            });
+            if (i === sig.params.length - 1) {
+                signature.label += p;
+            } else {
+                signature.label += p + ', ';
+            }
+        }
+        signature.label += ')' + sig.returns;
+
+        let pos = 0;
+        for (const ref of invoke.references) {
+            if (ref.code === DiagnosticCode.ArgumentSpread) pos = Number.NaN;
+            if (ref.code !== DiagnosticCode.ArgumentComma || Range.isEmpty(ref.range)) continue;
+            if (
+                Position.isBeforeOrEqual(Range.getEndPosition(ref.range), position) &&
+                !sig.params[pos]?.[0].startsWith('..')
+            ) {
+                pos++;
+            }
+        }
+
+        return {
+            dispose: () => void 0,
+            value: {
+                signatures: [signature],
+                activeSignature: 0,
+                activeParameter: pos,
+            },
+        };
+    }
+}