redscript-mc 2.5.0 → 2.6.0

package/src/lsp/server.ts

@@ -26,15 +26,28 @@ import {
   Location,
   Position,
   TextDocumentPositionParams,
+  SignatureHelp,
+  SignatureInformation,
+  ParameterInformation,
+  SignatureHelpParams,
+  ReferenceParams,
+  RenameParams,
+  WorkspaceEdit,
+  InlayHint,
+  InlayHintKind,
 } from 'vscode-languageserver/node'
 import { TextDocument } from 'vscode-languageserver-textdocument'
+import * as path from 'path'
+import * as fs from 'fs'
+import { fileURLToPath, pathToFileURL } from 'url'
 
 import { Lexer } from '../lexer'
 import { Parser } from '../parser'
 import { TypeChecker } from '../typechecker'
 import { DiagnosticError } from '../diagnostics'
-import type { Program, FnDecl, Span, TypeNode } from '../ast/types'
+import type { Program, FnDecl, Span, TypeNode, Stmt, Block } from '../ast/types'
 import { BUILTIN_METADATA } from '../builtins/metadata'
+import type { BuiltinDef } from '../builtins/metadata'
 
 // ---------------------------------------------------------------------------
 // Connection and document manager
@@ -43,6 +56,92 @@ import { BUILTIN_METADATA } from '../builtins/metadata'
 const connection = createConnection(ProposedFeatures.all)
 const documents = new TextDocuments(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(): Record<string, BuiltinDef> {
+  const extra: Record<string, BuiltinDef> = {}
+  // 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: string[] = []
+  let paramDocs: Record<string, string> = {}
+
+  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: Record<string, BuiltinDef> = { ...EXTRA_BUILTINS, ...BUILTIN_METADATA }
+
 // ---------------------------------------------------------------------------
 // Per-document parse cache
 // ---------------------------------------------------------------------------
@@ -227,7 +326,7 @@ const KEYWORD_COMPLETIONS: CompletionItem[] = [
 }))
 
 const TYPE_COMPLETIONS: CompletionItem[] = [
-  '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 => ({
@@ -236,11 +335,30 @@ const TYPE_COMPLETIONS: CompletionItem[] = [
 }))
 
 const DECORATOR_COMPLETIONS: CompletionItem[] = [
-  '@tick', '@load', '@on', '@coroutine', '@keep',
-].map(d => ({
-  label: d,
-  kind: 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: CompletionItemKind.Event }))
+
+/** Entity selector completions triggered by @ inside expressions */
+const SELECTOR_COMPLETIONS: CompletionItem[] = [
+  { label: '@a',  kind: CompletionItemKind.Value, detail: 'All players',              documentation: 'Targets all online players.' },
+  { label: '@p',  kind: CompletionItemKind.Value, detail: 'Nearest player',           documentation: 'Targets the nearest player to the command source.' },
+  { label: '@s',  kind: CompletionItemKind.Value, detail: 'Executing entity',         documentation: 'Targets the entity currently executing the command.' },
+  { label: '@e',  kind: CompletionItemKind.Value, detail: 'All entities',             documentation: 'Targets all entities (use [type=...] to filter).' },
+  { label: '@r',  kind: CompletionItemKind.Value, detail: 'Random player',            documentation: 'Targets a random online player.' },
+  { label: '@n',  kind: CompletionItemKind.Value, detail: 'Nearest entity',           documentation: 'Targets the nearest entity (any type).' },
+]
 
 const BUILTIN_FN_COMPLETIONS: CompletionItem[] = [
   'say', 'tell', 'give', 'kill', 'teleport', 'summon', 'setblock',
@@ -267,6 +385,12 @@ connection.onInitialize((_params: InitializeParams): InitializeResult => {
         triggerCharacters: ['.', '@'],
         resolveProvider: false,
       },
+      signatureHelpProvider: {
+        triggerCharacters: ['(', ','],
+      },
+      referencesProvider: true,
+      renameProvider: true,
+      inlayHintProvider: true,
     },
     serverInfo: {
       name: 'redscript-lsp',
@@ -306,36 +430,40 @@ connection.onHover((params: TextDocumentPositionParams): Hover | null => {
   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: RegExpExecArray | null
+  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: MarkupContent = {
-          kind: MarkupKind.Markdown,
-          value: `**@${decoratorName}** — ${decoratorDoc}`,
+        return {
+          contents: {
+            kind: MarkupKind.Markdown,
+            value: `**@${decoratorName}** — ${decoratorDoc}`,
+          } as MarkupContent,
         }
-        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 = BUILTIN_METADATA[word]
+  const builtin = ALL_BUILTINS[word]
   if (builtin) {
     const paramStr = builtin.params
       .map(p => `${p.name}: ${p.type}${p.required ? '' : '?'}`)
@@ -391,6 +519,31 @@ connection.onHover((params: TextDocumentPositionParams): Hover | null => {
     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: MarkupContent = {
+          kind: 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: MarkupContent = {
+          kind: MarkupKind.Markdown,
+          value: `\`\`\`redscript\nstruct ${importedStruct.name} {\n${fields}\n}\n\`\`\`\n*from ${path.basename(filePath)}*`,
+        }
+        return { contents: content }
+      }
+    }
+  } catch { /* ignore */ }
+
   return null
 })
 
@@ -398,11 +551,101 @@ connection.onHover((params: TextDocumentPositionParams): Hover | 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: string, fromUri: string): Array<{ prog: import('../ast/types').Program; filePath: string }> {
+  const result: Array<{ prog: import('../ast/types').Program; filePath: string }> = []
+  // 1. Path-based: import "stdlib/math.mcrs"
+  const FILE_IMPORT_RE = /^import\s+"([^"]+)"/gm
+  let m: RegExpExecArray | null
+  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(src).tokenize()
+      const prog = new 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(src).tokenize()
+      const prog = new 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: string, fromUri: string): string | null {
+  try {
+    const fromFile = 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: TextDocumentPositionParams): Location | null => {
   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: 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) return null
@@ -410,6 +653,22 @@ connection.onDefinition((params: TextDocumentPositionParams): Location | null =>
   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: 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) return null
@@ -425,12 +684,155 @@ connection.onDefinition((params: TextDocumentPositionParams): Location | null =>
   }
 })
 
+// ---------------------------------------------------------------------------
+// Completion helpers
+// ---------------------------------------------------------------------------
+
+/** int[] built-in methods */
+const ARRAY_METHOD_COMPLETIONS: CompletionItem[] = [
+  { label: 'push',   kind: CompletionItemKind.Method, detail: '(value: int): void',  documentation: 'Append an element to the array.' },
+  { label: 'pop',    kind: CompletionItemKind.Method, detail: '(): int',              documentation: 'Remove and return the last element.' },
+  { label: 'length', kind: 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: Block): Map<string, TypeNode> {
+  const map = new Map<string, TypeNode>()
+  function walk(stmts: Block): void {
+    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 as Record<string, unknown>)
+      if (Array.isArray(sub['body'])) walk(sub['body'] as Block)
+      if (Array.isArray(sub['then'])) walk(sub['then'] as Block)
+      if (Array.isArray(sub['else_'])) walk(sub['else_'] as Block)
+    }
+  }
+  walk(body)
+  return map
+}
+
+/** Determine if line at cursor is a dot-access context: `<expr>.` */
+function getDotReceiver(lineText: string, charPos: number): string | null {
+  // 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: TextDocumentPositionParams): CompletionItem[] => {
   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: CompletionItem[] = []
+
+    if (program) {
+      // Find which function body contains this line (by span)
+      const curLine = params.position.line + 1 // spans are 1-based
+      let locals: Map<string, TypeNode> | null = 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 as Block)
+            break
+          }
+        }
+      }
+
+      // Determine type of receiver
+      const receiverType: TypeNode | undefined = 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 as { name: string }).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: 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: 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: CompletionItemKind.Method })
+          }
+        }
+        items.push(...ARRAY_METHOD_COMPLETIONS)
+      }
+    }
+
+    return items
+  }
+
+  // ── Global / normal completion ─────────────────────────────────────────────
   const items: CompletionItem[] = [
     ...KEYWORD_COMPLETIONS,
     ...TYPE_COMPLETIONS,
@@ -438,12 +840,8 @@ connection.onCompletion((params: TextDocumentPositionParams): CompletionItem[] =
     ...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: CompletionItemKind.Function })
     }
@@ -456,11 +854,252 @@ connection.onCompletion((params: TextDocumentPositionParams): CompletionItem[] =
     for (const c of program.consts ?? []) {
       items.push({ label: c.name, kind: CompletionItemKind.Constant })
     }
+    for (const g of program.globals ?? []) {
+      items.push({ label: g.name, kind: 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 as Block)) {
+            items.push({
+              label: name,
+              kind: 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: 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: 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: import('vscode-languageserver-textdocument').TextDocument,
+  position: Position,
+): { start: Position; end: Position } | null {
+  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: SignatureHelpParams): SignatureHelp | null => {
+  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: string
+  let paramsList: string[]
+
+  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: ParameterInformation[] = paramsList.map(p => ({ label: p }))
+
+  return {
+    signatures: [
+      {
+        label,
+        parameters: paramInfos,
+        activeParameter: Math.min(activeParam, Math.max(0, paramInfos.length - 1)),
+      } as SignatureInformation,
+    ],
+    activeSignature: 0,
+    activeParameter: Math.min(activeParam, Math.max(0, paramInfos.length - 1)),
+  }
+})
+
+// ---------------------------------------------------------------------------
+// Inlay Hints
+// ---------------------------------------------------------------------------
+
+connection.onRequest(
+  'textDocument/inlayHint',
+  (params: { textDocument: { uri: string }; range: unknown }): InlayHint[] => {
+    const parsed = parsedDocs.get(params.textDocument.uri)
+    if (!parsed?.program) return []
+    const doc = documents.get(params.textDocument.uri)
+    if (!doc) return []
+
+    const hints: InlayHint[] = []
+
+    // Walk all let declarations with no explicit type annotation
+    // (where the type was inferred by the type checker)
+    function walkStmt(stmt: Record<string, unknown>): void {
+      if (
+        stmt['kind'] === 'let_decl' &&
+        !stmt['typeAnnotation'] &&
+        stmt['inferredType']
+      ) {
+        const spanVal = stmt['span'] as { end?: number } | undefined
+        const pos = doc!.positionAt(spanVal?.end ?? 0)
+        hints.push({
+          position: { line: pos.line, character: pos.character },
+          label: `: ${typeToString(stmt['inferredType'] as import('../ast/types').TypeNode)}`,
+          kind: InlayHintKind.Type,
+          paddingLeft: true,
+        })
+      }
+      // Recurse into blocks, if/else bodies, etc.
+      const body = stmt['body'] as Record<string, unknown>[] | undefined
+      if (Array.isArray(body)) body.forEach(walkStmt)
+      const then_ = stmt['then'] as Record<string, unknown>[] | undefined
+      if (Array.isArray(then_)) then_.forEach(walkStmt)
+      const else_ = stmt['else_'] as Record<string, unknown>[] | undefined
+      if (Array.isArray(else_)) else_.forEach(walkStmt)
+    }
+
+    parsed.program.declarations.forEach(top => {
+      if (top.body) {
+        (top.body as Record<string, unknown>[]).forEach(walkStmt)
+      }
+    })
+
+    return hints
+  },
+)
+
+// ---------------------------------------------------------------------------
+// Find References
+// ---------------------------------------------------------------------------
+
+connection.onReferences((params: ReferenceParams): Location[] => {
+  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: Location[] = []
+  const regex = new RegExp(`\\b${word}\\b`, 'g')
+  let match: RegExpExecArray | null
+
+  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: RenameParams): WorkspaceEdit | null => {
+  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: import('vscode-languageserver/node').TextEdit[] = []
+  const regex = new RegExp(`\\b${word}\\b`, 'g')
+  let match: RegExpExecArray | null
+
+  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
 // ---------------------------------------------------------------------------