redscript-mc 2.4.1 → 2.6.0

package/dist/src/lsp/server.js

@@ -9,9 +9,45 @@
  *   - Go-to-definition (functions, variables)
  *   - Completion (keywords, functions, builtins)
  */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
 Object.defineProperty(exports, "__esModule", { value: true });
 const node_1 = require("vscode-languageserver/node");
 const vscode_languageserver_textdocument_1 = require("vscode-languageserver-textdocument");
+const path = __importStar(require("path"));
+const fs = __importStar(require("fs"));
+const url_1 = require("url");
 const lexer_1 = require("../lexer");
 const parser_1 = require("../parser");
 const typechecker_1 = require("../typechecker");
@@ -22,6 +58,90 @@ const metadata_1 = require("../builtins/metadata");
 // ---------------------------------------------------------------------------
 const connection = (0, node_1.createConnection)(node_1.ProposedFeatures.all);
 const documents = new node_1.TextDocuments(vscode_languageserver_textdocument_1.TextDocument);
+// ---------------------------------------------------------------------------
+// Builtin metadata: augment BUILTIN_METADATA from builtins.d.mcrs if present
+// ---------------------------------------------------------------------------
+/**
+ * Parse builtins.d.mcrs for `declare fn` entries and extract doc/param info.
+ * This ensures LSP hover covers every declared builtin even if metadata.ts
+ * is not yet updated.
+ */
+function loadBuiltinsFromDeclFile() {
+    const extra = {};
+    // Candidate paths: next to server.ts (dev), or next to the package root
+    const candidates = [
+        path.resolve(__dirname, '../../builtins.d.mcrs'),
+        path.resolve(__dirname, '../../../builtins.d.mcrs'),
+        path.resolve(__dirname, '../../../../builtins.d.mcrs'),
+    ];
+    let src = '';
+    for (const p of candidates) {
+        if (fs.existsSync(p)) {
+            src = fs.readFileSync(p, 'utf-8');
+            break;
+        }
+    }
+    if (!src)
+        return extra;
+    const lines = src.split('\n');
+    let docLines = [];
+    let paramDocs = {};
+    for (const line of lines) {
+        const tripleDoc = line.match(/^\/\/\/\s?(.*)$/);
+        if (tripleDoc) {
+            const content = tripleDoc[1];
+            const paramMatch = content.match(/^@param\s+(\w+)\s+(.+)$/);
+            if (paramMatch) {
+                paramDocs[paramMatch[1]] = paramMatch[2];
+            }
+            else if (!content.startsWith('@example')) {
+                docLines.push(content);
+            }
+            continue;
+        }
+        const declMatch = line.match(/^declare fn (\w+)\(([^)]*)\):\s*(\w+);?$/);
+        if (declMatch) {
+            const [, fnName, paramsStr, retType] = declMatch;
+            // Only add if not already in BUILTIN_METADATA
+            if (!ALL_BUILTINS[fnName]) {
+                const params = paramsStr.trim()
+                    ? paramsStr.split(',').map(p => {
+                        const [pname, ptype] = p.trim().split(':').map(s => s.trim());
+                        return {
+                            name: pname ?? '',
+                            type: ptype ?? 'string',
+                            required: true,
+                            doc: paramDocs[pname ?? ''] ?? '',
+                            docZh: '',
+                        };
+                    })
+                    : [];
+                extra[fnName] = {
+                    name: fnName,
+                    params,
+                    returns: (retType === 'void' || retType === 'int' || retType === 'bool' || retType === 'string')
+                        ? retType : 'void',
+                    doc: docLines.join(' ').trim(),
+                    docZh: '',
+                    examples: [],
+                    category: 'builtin',
+                };
+            }
+            docLines = [];
+            paramDocs = {};
+            continue;
+        }
+        // Non-comment, non-declare line resets doc accumulator
+        if (line.trim() && !line.startsWith('//')) {
+            docLines = [];
+            paramDocs = {};
+        }
+    }
+    return extra;
+}
+const EXTRA_BUILTINS = loadBuiltinsFromDeclFile();
+/** Combined lookup: metadata.ts entries + anything declared in builtins.d.mcrs */
+const ALL_BUILTINS = { ...EXTRA_BUILTINS, ...metadata_1.BUILTIN_METADATA };
 const parsedDocs = new Map();
 // ---------------------------------------------------------------------------
 // Helpers
@@ -184,7 +304,7 @@ const KEYWORD_COMPLETIONS = [
     kind: node_1.CompletionItemKind.Keyword,
 }));
 const TYPE_COMPLETIONS = [
-    'int', 'bool', 'float', 'string', 'void', 'BlockPos', 'byte', 'short', 'long', 'double',
+    'int', 'bool', 'fixed', 'float', 'string', 'void', 'BlockPos', 'byte', 'short', 'long', 'double',
     'entity', 'Player', 'Mob', 'HostileMob', 'PassiveMob',
     'Zombie', 'Skeleton', 'Creeper', 'Spider', 'Enderman',
 ].map(t => ({
@@ -192,11 +312,29 @@ const TYPE_COMPLETIONS = [
     kind: node_1.CompletionItemKind.TypeParameter,
 }));
 const DECORATOR_COMPLETIONS = [
-    '@tick', '@load', '@on', '@coroutine', '@keep',
-].map(d => ({
-    label: d,
-    kind: node_1.CompletionItemKind.Event,
-}));
+    { label: '@tick', detail: 'Run every game tick (~20 Hz)' },
+    { label: '@load', detail: 'Run on /reload (initialization)' },
+    { label: '@on_trigger', detail: 'Run when a player uses /trigger' },
+    { label: '@schedule', detail: 'Schedule function after N ticks' },
+    { label: '@coroutine', detail: 'Spread loop across ticks (batch=N)' },
+    { label: '@keep', detail: 'Prevent dead-code elimination' },
+    { label: '@on', detail: 'Generic event handler' },
+    { label: '@on_advancement', detail: 'Run on advancement earned' },
+    { label: '@on_craft', detail: 'Run on item craft' },
+    { label: '@on_death', detail: 'Run on player death' },
+    { label: '@on_join_team', detail: 'Run on team join' },
+    { label: '@on_login', detail: 'Run on player login' },
+    { label: '@require_on_load', detail: 'Ensure a fn runs on load (stdlib)' },
+].map(d => ({ ...d, kind: node_1.CompletionItemKind.Event }));
+/** Entity selector completions triggered by @ inside expressions */
+const SELECTOR_COMPLETIONS = [
+    { label: '@a', kind: node_1.CompletionItemKind.Value, detail: 'All players', documentation: 'Targets all online players.' },
+    { label: '@p', kind: node_1.CompletionItemKind.Value, detail: 'Nearest player', documentation: 'Targets the nearest player to the command source.' },
+    { label: '@s', kind: node_1.CompletionItemKind.Value, detail: 'Executing entity', documentation: 'Targets the entity currently executing the command.' },
+    { label: '@e', kind: node_1.CompletionItemKind.Value, detail: 'All entities', documentation: 'Targets all entities (use [type=...] to filter).' },
+    { label: '@r', kind: node_1.CompletionItemKind.Value, detail: 'Random player', documentation: 'Targets a random online player.' },
+    { label: '@n', kind: node_1.CompletionItemKind.Value, detail: 'Nearest entity', documentation: 'Targets the nearest entity (any type).' },
+];
 const BUILTIN_FN_COMPLETIONS = [
     'say', 'tell', 'give', 'kill', 'teleport', 'summon', 'setblock',
     'fill', 'clone', 'effect', 'enchant', 'experience', 'gamemode',
@@ -220,6 +358,12 @@ connection.onInitialize((_params) => {
                 triggerCharacters: ['.', '@'],
                 resolveProvider: false,
             },
+            signatureHelpProvider: {
+                triggerCharacters: ['(', ','],
+            },
+            referencesProvider: true,
+            renameProvider: true,
+            inlayHintProvider: true,
         },
         serverInfo: {
             name: 'redscript-lsp',
@@ -253,35 +397,38 @@ connection.onHover((params) => {
     if (!doc)
         return null;
     const source = doc.getText();
-    const cached = parsedDocs.get(params.textDocument.uri);
-    const program = cached?.program ?? null;
-    if (!program)
-        return null;
-    // Check if cursor is on a decorator (@tick, @load, etc.)
+    // ── Decorator hover: works even if program is null (parse errors elsewhere) ──
     const lines = source.split('\n');
     const lineText = lines[params.position.line] ?? '';
-    const decoratorMatch = lineText.match(/@([a-zA-Z_][a-zA-Z0-9_]*)/);
-    if (decoratorMatch) {
-        const ch = params.position.character;
-        const atIdx = lineText.indexOf('@');
-        const decoratorEnd = atIdx + 1 + decoratorMatch[1].length;
-        if (ch >= atIdx && ch <= decoratorEnd) {
-            const decoratorName = decoratorMatch[1];
+    const ch = params.position.character;
+    // Find all @xxx on this line and check if cursor is inside one
+    const decorRe = /@([a-zA-Z_][a-zA-Z0-9_]*)/g;
+    let dm;
+    while ((dm = decorRe.exec(lineText)) !== null) {
+        const atIdx = dm.index;
+        const decorEnd = atIdx + dm[0].length;
+        if (ch >= atIdx && ch <= decorEnd) {
+            const decoratorName = dm[1];
             const decoratorDoc = DECORATOR_DOCS[decoratorName];
             if (decoratorDoc) {
-                const content = {
-                    kind: node_1.MarkupKind.Markdown,
-                    value: `**@${decoratorName}** — ${decoratorDoc}`,
+                return {
+                    contents: {
+                        kind: node_1.MarkupKind.Markdown,
+                        value: `**@${decoratorName}** — ${decoratorDoc}`,
+                    },
                 };
-                return { contents: content };
             }
         }
     }
+    const cached = parsedDocs.get(params.textDocument.uri);
+    const program = cached?.program ?? null;
+    if (!program)
+        return null;
     const word = wordAt(source, params.position);
     if (!word)
         return null;
     // Check builtins
-    const builtin = metadata_1.BUILTIN_METADATA[word];
+    const builtin = ALL_BUILTINS[word];
     if (builtin) {
         const paramStr = builtin.params
             .map(p => `${p.name}: ${p.type}${p.required ? '' : '?'}`)
@@ -332,16 +479,139 @@ connection.onHover((params) => {
         };
         return { contents: content };
     }
+    // ── Check imported files (import "stdlib/xxx.mcrs" and import xxx::*) ──────
+    try {
+        const importedPrograms = getImportedPrograms(source, params.textDocument.uri);
+        for (const { prog, filePath } of importedPrograms) {
+            const importedFn = findFunction(prog, word);
+            if (importedFn) {
+                const sig = formatFnSignature(importedFn);
+                const content = {
+                    kind: node_1.MarkupKind.Markdown,
+                    value: `\`\`\`redscript\n${sig}\n\`\`\`\n*from ${path.basename(filePath)}*`,
+                };
+                return { contents: content };
+            }
+            const importedStruct = prog.structs?.find(s => s.name === word);
+            if (importedStruct) {
+                const fields = importedStruct.fields.map(f => `  ${f.name}: ${typeToString(f.type)}`).join('\n');
+                const content = {
+                    kind: node_1.MarkupKind.Markdown,
+                    value: `\`\`\`redscript\nstruct ${importedStruct.name} {\n${fields}\n}\n\`\`\`\n*from ${path.basename(filePath)}*`,
+                };
+                return { contents: content };
+            }
+        }
+    }
+    catch { /* ignore */ }
     return null;
 });
 // ---------------------------------------------------------------------------
 // Go-to-definition
 // ---------------------------------------------------------------------------
+/**
+ * Parse all import declarations in `source` (both path-based and module::*
+ * forms) and return parsed Program objects for each resolved file.
+ */
+function getImportedPrograms(source, fromUri) {
+    const result = [];
+    // 1. Path-based: import "stdlib/math.mcrs"
+    const FILE_IMPORT_RE = /^import\s+"([^"]+)"/gm;
+    let m;
+    while ((m = FILE_IMPORT_RE.exec(source)) !== null) {
+        const resolved = resolveImportPath(m[1], fromUri);
+        if (!resolved || !fs.existsSync(resolved))
+            continue;
+        try {
+            const src = fs.readFileSync(resolved, 'utf-8');
+            const tokens = new lexer_1.Lexer(src).tokenize();
+            const prog = new parser_1.Parser(tokens).parse(path.basename(resolved, '.mcrs'));
+            result.push({ prog, filePath: resolved });
+        }
+        catch { /* skip */ }
+    }
+    // 2. Module-star: import random::* or import random::fn_name
+    const MOD_IMPORT_RE = /^import\s+([a-zA-Z_][a-zA-Z0-9_]*)\s*::/gm;
+    while ((m = MOD_IMPORT_RE.exec(source)) !== null) {
+        const modName = m[1];
+        // Try to resolve as stdlib/modName.mcrs
+        const resolved = resolveImportPath(`stdlib/${modName}.mcrs`, fromUri);
+        if (!resolved || !fs.existsSync(resolved))
+            continue;
+        // Avoid duplicates if already resolved above
+        if (result.some(r => r.filePath === resolved))
+            continue;
+        try {
+            const src = fs.readFileSync(resolved, 'utf-8');
+            const tokens = new lexer_1.Lexer(src).tokenize();
+            const prog = new parser_1.Parser(tokens).parse(modName);
+            result.push({ prog, filePath: resolved });
+        }
+        catch { /* skip */ }
+    }
+    return result;
+}
+/** Resolve a relative or stdlib import path to an absolute file path. */
+function resolveImportPath(importStr, fromUri) {
+    try {
+        const fromFile = (0, url_1.fileURLToPath)(fromUri);
+        const fromDir = path.dirname(fromFile);
+        if (importStr.startsWith('.')) {
+            // Relative path: import "../stdlib/math.mcrs"
+            const resolved = path.resolve(fromDir, importStr);
+            if (fs.existsSync(resolved))
+                return resolved;
+            // Try adding .mcrs extension
+            if (!resolved.endsWith('.mcrs') && fs.existsSync(resolved + '.mcrs'))
+                return resolved + '.mcrs';
+        }
+        else {
+            // stdlib path: import "stdlib/math" or "stdlib/math.mcrs"
+            // Walk up to find package root (contains package.json)
+            let dir = fromDir;
+            for (let i = 0; i < 10; i++) {
+                if (fs.existsSync(path.join(dir, 'package.json'))) {
+                    const candidate = path.join(dir, 'src', importStr);
+                    if (fs.existsSync(candidate))
+                        return candidate;
+                    if (fs.existsSync(candidate + '.mcrs'))
+                        return candidate + '.mcrs';
+                    // also try without 'src/'
+                    const candidate2 = path.join(dir, importStr);
+                    if (fs.existsSync(candidate2))
+                        return candidate2;
+                    if (fs.existsSync(candidate2 + '.mcrs'))
+                        return candidate2 + '.mcrs';
+                    break;
+                }
+                dir = path.dirname(dir);
+            }
+        }
+    }
+    catch { /* ignore */ }
+    return null;
+}
 connection.onDefinition((params) => {
     const doc = documents.get(params.textDocument.uri);
     if (!doc)
         return null;
     const source = doc.getText();
+    const lines = source.split('\n');
+    const lineText = lines[params.position.line] ?? '';
+    const ch = params.position.character;
+    // ── import "path/to/file.mcrs" ─────────────────────────────────────────────
+    // Cursor is anywhere on the line that starts with `import "..."`
+    const fileImportMatch = lineText.match(/^import\s+"([^"]+)"/);
+    if (fileImportMatch) {
+        const importStr = fileImportMatch[1];
+        const resolved = resolveImportPath(importStr, params.textDocument.uri);
+        if (resolved) {
+            return {
+                uri: (0, url_1.pathToFileURL)(resolved).toString(),
+                range: { start: { line: 0, character: 0 }, end: { line: 0, character: 0 } },
+            };
+        }
+    }
     const cached = parsedDocs.get(params.textDocument.uri);
     const program = cached?.program ?? null;
     if (!program)
@@ -349,6 +619,21 @@ connection.onDefinition((params) => {
     const word = wordAt(source, params.position);
     if (!word)
         return null;
+    // ── import module::symbol — jump to the symbol in the imported module ───────
+    // Check if word is a known import symbol; try to resolve its module file
+    const importDecl = program.imports?.find(im => im.symbol === word || im.symbol === '*');
+    if (importDecl) {
+        const resolved = resolveImportPath(importDecl.moduleName, params.textDocument.uri)
+            ?? resolveImportPath(importDecl.moduleName + '.mcrs', params.textDocument.uri);
+        if (resolved) {
+            // Open file at start; could later search for the symbol definition
+            return {
+                uri: (0, url_1.pathToFileURL)(resolved).toString(),
+                range: { start: { line: 0, character: 0 }, end: { line: 0, character: 0 } },
+            };
+        }
+    }
+    // ── Normal in-file definition ──────────────────────────────────────────────
     const defMap = buildDefinitionMap(program, source);
     const span = defMap.get(word);
     if (!span)
@@ -364,22 +649,158 @@ connection.onDefinition((params) => {
     };
 });
 // ---------------------------------------------------------------------------
+// Completion helpers
+// ---------------------------------------------------------------------------
+/** int[] built-in methods */
+const ARRAY_METHOD_COMPLETIONS = [
+    { label: 'push', kind: node_1.CompletionItemKind.Method, detail: '(value: int): void', documentation: 'Append an element to the array.' },
+    { label: 'pop', kind: node_1.CompletionItemKind.Method, detail: '(): int', documentation: 'Remove and return the last element.' },
+    { label: 'length', kind: node_1.CompletionItemKind.Property, detail: 'int', documentation: 'Number of elements in the array.' },
+];
+/** Collect (name → TypeNode) for all let bindings visible in the function body at offset. */
+function collectLocals(body) {
+    const map = new Map();
+    function walk(stmts) {
+        for (const s of stmts) {
+            if (s.kind === 'let' && s.type) {
+                map.set(s.name, s.type);
+            }
+            else if (s.kind === 'let_destruct') {
+                // no type info per-binding easily; skip
+            }
+            // Recurse into sub-blocks
+            const sub = s;
+            if (Array.isArray(sub['body']))
+                walk(sub['body']);
+            if (Array.isArray(sub['then']))
+                walk(sub['then']);
+            if (Array.isArray(sub['else_']))
+                walk(sub['else_']);
+        }
+    }
+    walk(body);
+    return map;
+}
+/** Determine if line at cursor is a dot-access context: `<expr>.` */
+function getDotReceiver(lineText, charPos) {
+    // Check that the character just before cursor is '.'
+    if (lineText[charPos - 1] !== '.')
+        return null;
+    // Scan left to collect the identifier before '.'
+    let end = charPos - 2;
+    while (end >= 0 && /\s/.test(lineText[end]))
+        end--;
+    if (end < 0)
+        return null;
+    let start = end;
+    while (start > 0 && /[a-zA-Z0-9_]/.test(lineText[start - 1]))
+        start--;
+    return lineText.slice(start, end + 1) || null;
+}
+// ---------------------------------------------------------------------------
 // Completion
 // ---------------------------------------------------------------------------
 connection.onCompletion((params) => {
     const doc = documents.get(params.textDocument.uri);
+    if (!doc) {
+        return [...KEYWORD_COMPLETIONS, ...TYPE_COMPLETIONS, ...BUILTIN_FN_COMPLETIONS, ...DECORATOR_COMPLETIONS];
+    }
+    const source = doc.getText();
+    const lines = source.split('\n');
+    const lineText = lines[params.position.line] ?? '';
+    const charPos = params.position.character;
+    const cached = parsedDocs.get(params.textDocument.uri);
+    const program = cached?.program ?? null;
+    // ── @ trigger: selector (@a/@p/@s/@e/@r/@n) vs decorator (@tick etc) ────────
+    // Check if current token starts with '@': prevChar='@' OR there's '@xxx' partial token
+    const prevChar = lineText[charPos - 1];
+    const atMatch = lineText.slice(0, charPos).match(/@([a-zA-Z_]*)$/);
+    if (prevChar === '@' || atMatch) {
+        // Heuristic: if there's a non-whitespace non-keyword char before '@'
+        // on the same line it's likely an expression context (selector).
+        // If line is only whitespace before '@', it's a decorator.
+        const atStart = atMatch ? charPos - atMatch[0].length : charPos - 1;
+        const before = lineText.slice(0, atStart).trim();
+        const isExprContext = before.length > 0 && !/^(fn|let|if|while|for|return|@)/.test(before.split(/\s+/).pop() ?? '');
+        if (isExprContext) {
+            return SELECTOR_COMPLETIONS;
+        }
+        // Decorator context — return decorator completions only
+        return DECORATOR_COMPLETIONS;
+    }
+    // ── Dot-access completion ──────────────────────────────────────────────────
+    const dotReceiver = getDotReceiver(lineText, charPos);
+    if (dotReceiver !== null) {
+        const items = [];
+        if (program) {
+            // Find which function body contains this line (by span)
+            const curLine = params.position.line + 1; // spans are 1-based
+            let locals = null;
+            for (const fn of program.declarations) {
+                if (fn.body && fn.span) {
+                    if (curLine >= fn.span.line && curLine <= (fn.span.endLine ?? Infinity)) {
+                        locals = collectLocals(fn.body);
+                        break;
+                    }
+                }
+            }
+            // Determine type of receiver
+            const receiverType = locals?.get(dotReceiver)
+                ?? program.consts?.find(c => c.name === dotReceiver)?.type
+                ?? program.globals?.find(g => g.name === dotReceiver)?.type;
+            if (receiverType) {
+                if (receiverType.kind === 'array') {
+                    // int[] → push / pop / length
+                    items.push(...ARRAY_METHOD_COMPLETIONS);
+                }
+                else if (receiverType.kind === 'named' || receiverType.kind === 'struct') {
+                    const typeName = receiverType.name;
+                    // Struct fields
+                    const structDecl = program.structs?.find(s => s.name === typeName);
+                    if (structDecl) {
+                        for (const f of structDecl.fields) {
+                            items.push({
+                                label: f.name,
+                                kind: node_1.CompletionItemKind.Field,
+                                detail: typeToString(f.type),
+                            });
+                        }
+                    }
+                    // Impl methods
+                    const implBlock = program.implBlocks?.find(ib => ib.typeName === typeName);
+                    if (implBlock) {
+                        for (const m of implBlock.methods) {
+                            const params_ = m.params.map(p => `${p.name}: ${typeToString(p.type)}`).join(', ');
+                            items.push({
+                                label: m.name,
+                                kind: node_1.CompletionItemKind.Method,
+                                detail: `(${params_}): ${typeToString(m.returnType)}`,
+                            });
+                        }
+                    }
+                }
+            }
+            else {
+                // Unknown type — offer all struct fields + impl methods as fallback
+                for (const ib of program.implBlocks ?? []) {
+                    for (const m of ib.methods) {
+                        items.push({ label: m.name, kind: node_1.CompletionItemKind.Method });
+                    }
+                }
+                items.push(...ARRAY_METHOD_COMPLETIONS);
+            }
+        }
+        return items;
+    }
+    // ── Global / normal completion ─────────────────────────────────────────────
     const items = [
         ...KEYWORD_COMPLETIONS,
         ...TYPE_COMPLETIONS,
         ...BUILTIN_FN_COMPLETIONS,
         ...DECORATOR_COMPLETIONS,
     ];
-    if (!doc)
-        return items;
-    // Add user-defined functions from the parsed doc
-    const cached = parsedDocs.get(params.textDocument.uri);
-    const program = cached?.program ?? null;
     if (program) {
+        // User-defined top-level symbols
         for (const fn of program.declarations) {
             items.push({ label: fn.name, kind: node_1.CompletionItemKind.Function });
         }
@@ -392,10 +813,232 @@ connection.onCompletion((params) => {
         for (const c of program.consts ?? []) {
             items.push({ label: c.name, kind: node_1.CompletionItemKind.Constant });
         }
+        for (const g of program.globals ?? []) {
+            items.push({ label: g.name, kind: node_1.CompletionItemKind.Variable });
+        }
+        // Locals from the enclosing function
+        const curLine = params.position.line + 1;
+        for (const fn of program.declarations) {
+            if (fn.body && fn.span) {
+                if (curLine >= fn.span.line && curLine <= (fn.span.endLine ?? Infinity)) {
+                    for (const [name, typ] of collectLocals(fn.body)) {
+                        items.push({
+                            label: name,
+                            kind: node_1.CompletionItemKind.Variable,
+                            detail: typeToString(typ),
+                        });
+                    }
+                    break;
+                }
+            }
+        }
+    }
+    // ── Functions from imported files (both "path" and module::* forms) ────────
+    try {
+        const importedPrograms = getImportedPrograms(source, params.textDocument.uri);
+        for (const { prog, filePath } of importedPrograms) {
+            for (const fn of prog.declarations) {
+                const paramList = fn.params.map(p => `${p.name}: ${typeToString(p.type)}`).join(', ');
+                items.push({
+                    label: fn.name,
+                    kind: node_1.CompletionItemKind.Function,
+                    detail: `(${paramList}) → ${typeToString(fn.returnType ?? { kind: 'named', name: 'void' })}`,
+                    documentation: `from ${path.basename(filePath)}`,
+                });
+            }
+            for (const s of prog.structs ?? []) {
+                items.push({ label: s.name, kind: node_1.CompletionItemKind.Struct, documentation: `from ${path.basename(filePath)}` });
+            }
+        }
     }
+    catch { /* ignore import completion errors */ }
     return items;
 });
 // ---------------------------------------------------------------------------
+// Helpers for word-at-position (used by references and rename)
+// ---------------------------------------------------------------------------
+function getWordRangeAtPosition(doc, position) {
+    const text = doc.getText();
+    const offset = doc.offsetAt(position);
+    let start = offset;
+    let end = offset;
+    while (start > 0 && /[a-zA-Z0-9_]/.test(text[start - 1]))
+        start--;
+    while (end < text.length && /[a-zA-Z0-9_]/.test(text[end]))
+        end++;
+    if (start === end)
+        return null;
+    return { start: doc.positionAt(start), end: doc.positionAt(end) };
+}
+// ---------------------------------------------------------------------------
+// Signature Help
+// ---------------------------------------------------------------------------
+connection.onSignatureHelp((params) => {
+    const doc = documents.get(params.textDocument.uri);
+    if (!doc)
+        return null;
+    const parsed = parsedDocs.get(params.textDocument.uri);
+    if (!parsed?.program)
+        return null;
+    const text = doc.getText();
+    const offset = doc.offsetAt(params.position);
+    // Walk backwards to find the opening '(' and count active parameter
+    let depth = 0;
+    let i = offset - 1;
+    let activeParam = 0;
+    while (i >= 0) {
+        const ch = text[i];
+        if (ch === ')')
+            depth++;
+        else if (ch === '(') {
+            if (depth === 0)
+                break;
+            depth--;
+        }
+        else if (ch === ',' && depth === 0)
+            activeParam++;
+        i--;
+    }
+    if (i < 0)
+        return null;
+    // Extract function name before '('
+    let nameEnd = i - 1;
+    while (nameEnd >= 0 && /\s/.test(text[nameEnd]))
+        nameEnd--;
+    let nameStart = nameEnd;
+    while (nameStart > 0 && /[a-zA-Z0-9_]/.test(text[nameStart - 1]))
+        nameStart--;
+    const fnName = text.slice(nameStart, nameEnd + 1);
+    if (!fnName)
+        return null;
+    // Find function declaration in parsed program
+    const fn = parsed.program.declarations.find(s => s.name === fnName);
+    // Also check builtins (BUILTIN_METADATA is a Record<string, BuiltinDef>)
+    const builtin = ALL_BUILTINS[fnName];
+    if (!fn && !builtin)
+        return null;
+    let label;
+    let paramsList;
+    if (fn) {
+        paramsList = fn.params.map(p => `${p.name}: ${typeToString(p.type)}`);
+        label = `fn ${fn.name}(${paramsList.join(', ')}): ${typeToString(fn.returnType)}`;
+    }
+    else {
+        paramsList = builtin.params?.map(p => `${p.name}: ${p.type}`) ?? [];
+        label = `${builtin.name}(${paramsList.join(', ')}): ${builtin.returns ?? 'void'}`;
+    }
+    const paramInfos = paramsList.map(p => ({ label: p }));
+    return {
+        signatures: [
+            {
+                label,
+                parameters: paramInfos,
+                activeParameter: Math.min(activeParam, Math.max(0, paramInfos.length - 1)),
+            },
+        ],
+        activeSignature: 0,
+        activeParameter: Math.min(activeParam, Math.max(0, paramInfos.length - 1)),
+    };
+});
+// ---------------------------------------------------------------------------
+// Inlay Hints
+// ---------------------------------------------------------------------------
+connection.onRequest('textDocument/inlayHint', (params) => {
+    const parsed = parsedDocs.get(params.textDocument.uri);
+    if (!parsed?.program)
+        return [];
+    const doc = documents.get(params.textDocument.uri);
+    if (!doc)
+        return [];
+    const hints = [];
+    // Walk all let declarations with no explicit type annotation
+    // (where the type was inferred by the type checker)
+    function walkStmt(stmt) {
+        if (stmt['kind'] === 'let_decl' &&
+            !stmt['typeAnnotation'] &&
+            stmt['inferredType']) {
+            const spanVal = stmt['span'];
+            const pos = doc.positionAt(spanVal?.end ?? 0);
+            hints.push({
+                position: { line: pos.line, character: pos.character },
+                label: `: ${typeToString(stmt['inferredType'])}`,
+                kind: node_1.InlayHintKind.Type,
+                paddingLeft: true,
+            });
+        }
+        // Recurse into blocks, if/else bodies, etc.
+        const body = stmt['body'];
+        if (Array.isArray(body))
+            body.forEach(walkStmt);
+        const then_ = stmt['then'];
+        if (Array.isArray(then_))
+            then_.forEach(walkStmt);
+        const else_ = stmt['else_'];
+        if (Array.isArray(else_))
+            else_.forEach(walkStmt);
+    }
+    parsed.program.declarations.forEach(top => {
+        if (top.body) {
+            top.body.forEach(walkStmt);
+        }
+    });
+    return hints;
+});
+// ---------------------------------------------------------------------------
+// Find References
+// ---------------------------------------------------------------------------
+connection.onReferences((params) => {
+    const doc = documents.get(params.textDocument.uri);
+    if (!doc)
+        return [];
+    const parsed = parsedDocs.get(params.textDocument.uri);
+    if (!parsed?.program)
+        return [];
+    const wordRange = getWordRangeAtPosition(doc, params.position);
+    if (!wordRange)
+        return [];
+    const word = doc.getText(wordRange);
+    if (!word)
+        return [];
+    const text = doc.getText();
+    const locations = [];
+    const regex = new RegExp(`\\b${word}\\b`, 'g');
+    let match;
+    while ((match = regex.exec(text)) !== null) {
+        const start = doc.positionAt(match.index);
+        const end = doc.positionAt(match.index + word.length);
+        locations.push({
+            uri: params.textDocument.uri,
+            range: { start, end },
+        });
+    }
+    return locations;
+});
+// ---------------------------------------------------------------------------
+// Rename Symbol
+// ---------------------------------------------------------------------------
+connection.onRenameRequest((params) => {
+    const doc = documents.get(params.textDocument.uri);
+    if (!doc)
+        return null;
+    const wordRange = getWordRangeAtPosition(doc, params.position);
+    if (!wordRange)
+        return null;
+    const word = doc.getText(wordRange);
+    if (!word)
+        return null;
+    const text = doc.getText();
+    const edits = [];
+    const regex = new RegExp(`\\b${word}\\b`, 'g');
+    let match;
+    while ((match = regex.exec(text)) !== null) {
+        const start = doc.positionAt(match.index);
+        const end = doc.positionAt(match.index + word.length);
+        edits.push({ range: { start, end }, newText: params.newName });
+    }
+    return { changes: { [params.textDocument.uri]: edits } };
+});
+// ---------------------------------------------------------------------------
 // Start
 // ---------------------------------------------------------------------------
 documents.listen(connection);