luaut-language-server 1.0.1 → 1.1.0

package/dist/index.cjs

@@ -30,20 +30,28 @@ __export(index_exports, {
   diagnostics: () => diagnostics,
   documentSymbols: () => documentSymbols,
   enclosing: () => enclosing,
+  exportDeclaration: () => exportDeclaration,
   highlights: () => highlights,
   hover: () => hover,
+  importCompletion: () => importCompletion,
+  importDefinition: () => importDefinition,
   membersOf: () => membersOf,
   nodeAt: () => nodeAt,
   pathAt: () => pathAt,
+  pathOfUri: () => pathOfUri,
   prepareRename: () => prepareRename,
   references: () => references,
   rename: () => rename,
+  samePath: () => samePath,
+  semanticTokens: () => semanticTokens,
+  semanticTokensLegend: () => semanticTokensLegend,
   signatureHelp: () => signatureHelp,
   signatureLabel: () => signatureLabel,
   signaturesOf: () => signaturesOf,
   startServer: () => startServer,
   toPosition: () => toPosition,
   toRange: () => toRange,
+  uriOfPath: () => uriOfPath,
   walk: () => walk
 });
 module.exports = __toCommonJS(index_exports);
@@ -53,6 +61,9 @@ var import_node = require("vscode-languageserver/node");
 var import_vscode_languageserver_textdocument = require("vscode-languageserver-textdocument");
 
 // src/analysis.ts
+var import_node_fs = require("fs");
+var import_node_path = require("path");
+var import_node_url = require("url");
 var import_luaut_parser = require("luaut-parser");
 function globalsOf(libs) {
   const names = /* @__PURE__ */ new Set();
@@ -81,20 +92,45 @@ function declarationIndex(analysis) {
   }
   return index;
 }
+function pathOfUri(uri) {
+  if (!uri.startsWith("file:")) return void 0;
+  try {
+    return (0, import_node_url.fileURLToPath)(uri);
+  } catch {
+    return void 0;
+  }
+}
+function uriOfPath(path) {
+  return (0, import_node_url.pathToFileURL)(path).href;
+}
+function samePath(a, b) {
+  return pathKey(a) === pathKey(b);
+}
+function pathKey(path) {
+  const normalized = (0, import_node_path.resolve)(path);
+  return process.platform === "win32" ? normalized.toLowerCase() : normalized;
+}
+var CYCLE = { values: /* @__PURE__ */ new Map(), types: /* @__PURE__ */ new Map(), partial: true };
 var Analyzer = class {
   libs;
   builtinGlobals;
+  openDocument;
   cache = /* @__PURE__ */ new Map();
+  /** Imported modules, by path key. */
+  modules = /* @__PURE__ */ new Map();
   constructor(options = {}) {
     this.libs = options.libs ?? import_luaut_parser.defaultLibs;
     this.builtinGlobals = globalsOf(this.libs);
+    this.openDocument = options.openDocument;
   }
-  /** Analyze `document`, reusing the previous result if its version is
-   *  unchanged. */
+  /** Analyze `document`, reusing the previous result while neither it nor
+   *  anything it imports has changed. */
   get(document) {
     const cached = this.cache.get(document.uri);
     const source = document.getText();
-    if (cached && cached.version === document.version && cached.source === source) return cached;
+    if (cached && cached.version === document.version && cached.source === source && this.isFresh(cached)) {
+      return cached;
+    }
     const analysis = this.analyze(document.uri, document.version, source);
     this.cache.set(document.uri, analysis);
     return analysis;
@@ -102,18 +138,103 @@ var Analyzer = class {
   /** Analyze source text that is not a tracked document — used by
    *  completion, which analyzes a speculatively edited copy of the file. */
   analyze(uri, version, source) {
-    const { program, errors } = (0, import_luaut_parser.parseWithRecovery)(source);
-    const scopes = (0, import_luaut_parser.analyzeScopes)(program, { builtinGlobals: this.builtinGlobals });
-    const types = (0, import_luaut_parser.analyzeTypes)(program, scopes, { libs: this.libs });
-    return { uri, version, source, program, parseErrors: errors, scopes, types };
+    const path = pathOfUri(uri);
+    return this.analyzeModule(uri, version, source, new Set(path ? [pathKey(path)] : []));
   }
   forget(uri) {
     this.cache.delete(uri);
   }
+  /** The file an import in `fromUri` names. Relative paths only (`./x`,
+   *  `../x`); the extension may be left off, and a folder means its
+   *  `index.luaut`. */
+  resolveModulePath(fromUri, specifier) {
+    return this.moduleCandidates(fromUri, specifier).find((candidate) => this.sourceOf(candidate) !== void 0);
+  }
+  /** Every file an import could mean, in the order they are tried. */
+  moduleCandidates(fromUri, specifier) {
+    const from = pathOfUri(fromUri);
+    if (!from || !(specifier.startsWith("./") || specifier.startsWith("../"))) return [];
+    const base = (0, import_node_path.resolve)((0, import_node_path.dirname)(from), specifier);
+    return specifier.endsWith(".luaut") ? [base] : [`${base}.luaut`, `${base}.d.luaut`, (0, import_node_path.join)(base, "index.luaut")];
+  }
+  /** What the module at `path` exports, analyzing it if need be. */
+  exportsAt(path) {
+    return this.exportsOf(path, /* @__PURE__ */ new Set());
+  }
+  /** The analysis of the module at `path`, analyzing it if need be. */
+  moduleAt(path) {
+    this.exportsOf(path, /* @__PURE__ */ new Set());
+    return this.modules.get(pathKey(path))?.analysis;
+  }
+  sourceOf(path) {
+    const open = this.openDocument?.(path);
+    if (open) return open.getText();
+    try {
+      return (0, import_node_fs.statSync)(path).isFile() ? (0, import_node_fs.readFileSync)(path, "utf8") : void 0;
+    } catch {
+      return void 0;
+    }
+  }
+  /** `importing` holds every module on the current import chain, so an
+   *  import back into one of them is recognized as a cycle. */
+  analyzeModule(uri, version, source, importing) {
+    const { program, errors } = (0, import_luaut_parser.parseWithRecovery)(source);
+    const scopes = (0, import_luaut_parser.analyzeScopes)(program, { builtinGlobals: this.builtinGlobals });
+    const dependencies = /* @__PURE__ */ new Map();
+    const types = (0, import_luaut_parser.analyzeTypes)(program, scopes, {
+      libs: this.libs,
+      resolveModule: (specifier) => {
+        const target = this.resolveModulePath(uri, specifier);
+        if (!target) {
+          for (const candidate of this.moduleCandidates(uri, specifier)) dependencies.set(candidate, void 0);
+          return void 0;
+        }
+        const exports2 = this.exportsOf(target, importing);
+        dependencies.set(target, this.sourceOf(target));
+        return exports2;
+      }
+    });
+    return { uri, version, source, program, parseErrors: errors, scopes, types, dependencies };
+  }
+  exportsOf(path, importing) {
+    const key = pathKey(path);
+    if (importing.has(key)) return CYCLE;
+    const source = this.sourceOf(path);
+    if (source === void 0) return void 0;
+    const cached = this.modules.get(key);
+    if (cached && cached.analysis.source === source && this.isFresh(cached.analysis)) return cached.exports;
+    importing.add(key);
+    try {
+      const analysis = this.analyzeModule(uriOfPath(path), -1, source, importing);
+      const exports2 = (0, import_luaut_parser.moduleExports)(analysis.program, analysis.scopes, analysis.types, (specifier) => {
+        const next = this.resolveModulePath(analysis.uri, specifier);
+        return next ? this.exportsOf(next, importing) : void 0;
+      });
+      this.modules.set(key, { analysis, exports: exports2 });
+      return exports2;
+    } finally {
+      importing.delete(key);
+    }
+  }
+  /** Does every module `analysis` imported — and everything those import —
+   *  still have the text it was analyzed against? */
+  isFresh(analysis, seen = /* @__PURE__ */ new Set()) {
+    if (seen.has(analysis)) return true;
+    seen.add(analysis);
+    for (const [path, source] of analysis.dependencies) {
+      if (this.sourceOf(path) !== source) return false;
+      const module2 = this.modules.get(pathKey(path));
+      if (module2 && !this.isFresh(module2.analysis, seen)) return false;
+    }
+    return true;
+  }
 };
 
-// src/features/diagnostics.ts
+// src/features/imports.ts
+var import_node_fs2 = require("fs");
+var import_node_path2 = require("path");
 var import_vscode_languageserver = require("vscode-languageserver");
+var import_luaut_parser3 = require("luaut-parser");
 
 // src/ast-utils.ts
 function isSpanned(v) {
@@ -143,16 +264,21 @@ function containsPosition(node, pos, inclusive = false) {
 }
 function children(node) {
   const out = [];
-  for (const key of Object.keys(node)) {
+  collect2(node, out);
+  return out;
+}
+function collect2(container, out) {
+  for (const key of Object.keys(container)) {
     if (key === "line" || key === "column") continue;
-    const value = node[key];
-    if (Array.isArray(value)) {
-      for (const item of value) if (isSpanned(item)) out.push(item);
-    } else if (isSpanned(value)) {
-      out.push(value);
+    const value = container[key];
+    for (const item of Array.isArray(value) ? value : [value]) {
+      if (isSpanned(item)) out.push(item);
+      else if (isSpanlessNode(item)) collect2(item, out);
     }
   }
-  return out;
+}
+function isSpanlessNode(v) {
+  return !!v && typeof v === "object" && typeof v.type === "string";
 }
 function pathAt(root, pos, inclusive = false) {
   let best;
@@ -188,14 +314,280 @@ function walk(root, visit, parent) {
   for (const child of children(root)) walk(child, visit, root);
 }
 
+// src/features/members.ts
+var import_luaut_parser2 = require("luaut-parser");
+function membersOf(type, aliases, seen = /* @__PURE__ */ new Set()) {
+  if (!type || seen.has(type)) return [];
+  seen.add(type);
+  switch (type.kind) {
+    case "object": {
+      const out = [];
+      for (const [name, property] of type.properties) {
+        out.push({ name, property, isMethod: takesSelf(property.type) });
+      }
+      return out;
+    }
+    case "intersection": {
+      const merged = /* @__PURE__ */ new Map();
+      for (const part of type.types) {
+        for (const member of membersOf(part, aliases, seen)) merged.set(member.name, member);
+      }
+      return [...merged.values()];
+    }
+    case "union": {
+      const perBranch = type.types.map((part) => membersOf(part, aliases, seen));
+      if (!perBranch.length) return [];
+      const [first, ...rest] = perBranch;
+      return first.filter((member) => rest.every((other) => other.some((m) => m.name === member.name)));
+    }
+    case "genericRef": {
+      const alias = aliases.get(type.name);
+      return alias ? membersOf(alias, aliases, seen) : [];
+    }
+    case "typeParam":
+      return membersOf(type.constraint, aliases, seen);
+    default:
+      return [];
+  }
+}
+function takesSelf(type) {
+  for (const signature of signaturesOf(type)) {
+    if (signature.params[0]?.name === "self") return true;
+  }
+  return false;
+}
+function signaturesOf(type, aliases) {
+  if (!type) return [];
+  if (type.kind === "function") return [type];
+  if (type.kind === "intersection") return type.types.flatMap((t) => signaturesOf(t, aliases));
+  if (type.kind === "genericRef" && aliases) {
+    const alias = aliases.get(type.name);
+    return alias ? signaturesOf(alias, aliases) : [];
+  }
+  return [];
+}
+function signatureLabel(signature) {
+  const parameters = signature.params.map((p, i) => {
+    const name = p.name ?? `arg${i + 1}`;
+    return `${name}${p.optional ? "?" : ""}: ${(0, import_luaut_parser2.formatType)(p.type)}`;
+  });
+  const generics = signature.typeParams?.length ? `<${signature.typeParams.join(", ")}>` : "";
+  const varargs = signature.varargs ? [`...: ${(0, import_luaut_parser2.formatType)(signature.varargs)}`] : [];
+  const label = `${generics}(${[...parameters, ...varargs].join(", ")}) -> ${(0, import_luaut_parser2.formatType)(signature.returns)}`;
+  return { label, parameters };
+}
+
+// src/features/imports.ts
+var SUGGEST_AGAIN = { title: "Suggest", command: "editor.action.triggerSuggest" };
+function importCompletion(analyzer, document, position) {
+  const text = document.getText();
+  const cursor = document.offsetAt(position);
+  const lineStart = document.offsetAt({ line: position.line, character: 0 });
+  const lineEnd = document.offsetAt({ line: position.line + 1, character: 0 });
+  const before = text.slice(lineStart, cursor);
+  const after = text.slice(cursor, lineEnd);
+  if (!/^\s*(?:import|export)\b/.test(before)) return void 0;
+  const path = /\bfrom\s*(["'])([^"']*)$/.exec(before);
+  if (path) return pathItems(document.uri, position, path[2]);
+  const braces = /^\s*(import|export)\s+(?:[A-Za-z_][A-Za-z0-9_]*\s*,\s*)?\{[^}]*$/.exec(before);
+  if (braces) {
+    const module2 = /\}\s*from\s*(["'])([^"']+)\1/.exec(after);
+    if (module2) return nameItems(analyzer, document.uri, module2[2], before);
+    return braces[1] === "import" ? [] : void 0;
+  }
+  return void 0;
+}
+function pathItems(fromUri, position, typed) {
+  const from = pathOfUri(fromUri);
+  if (!from) return [];
+  if (!typed.startsWith("./") && !typed.startsWith("../")) {
+    const range2 = rangeBack(position, typed.length);
+    return ["./", "../"].map((label) => ({
+      label,
+      kind: import_vscode_languageserver.CompletionItemKind.Folder,
+      textEdit: { range: range2, newText: label },
+      command: SUGGEST_AGAIN
+    }));
+  }
+  const slash = typed.lastIndexOf("/");
+  const directory = (0, import_node_path2.resolve)((0, import_node_path2.dirname)(from), typed.slice(0, slash + 1));
+  const range = rangeBack(position, typed.length - slash - 1);
+  let entries;
+  try {
+    entries = (0, import_node_fs2.readdirSync)(directory, { withFileTypes: true });
+  } catch {
+    return [];
+  }
+  const items = [];
+  for (const entry of entries) {
+    if (entry.name.startsWith(".") || entry.name === "node_modules") continue;
+    if (entry.isDirectory()) {
+      items.push({
+        label: `${entry.name}/`,
+        kind: import_vscode_languageserver.CompletionItemKind.Folder,
+        textEdit: { range, newText: `${entry.name}/` },
+        command: SUGGEST_AGAIN
+      });
+    } else if (entry.name.endsWith(".luaut")) {
+      if (samePath((0, import_node_path2.resolve)(directory, entry.name), from)) continue;
+      const name = entry.name.replace(/(\.d)?\.luaut$/, "");
+      items.push({
+        label: name,
+        kind: import_vscode_languageserver.CompletionItemKind.File,
+        detail: entry.name,
+        textEdit: { range, newText: name }
+      });
+    }
+  }
+  return items;
+}
+function nameItems(analyzer, fromUri, specifier, before) {
+  const target = analyzer.resolveModulePath(fromUri, specifier);
+  const exports2 = target ? analyzer.exportsAt(target) : void 0;
+  if (!exports2) return [];
+  const braces = before.slice(before.indexOf("{") + 1);
+  const listed = new Set(braces.split(",").map((part) => part.trim().split(/\s+/)[0]).filter(Boolean));
+  const items = [];
+  for (const [name, type] of exports2.values) {
+    if (listed.has(name)) continue;
+    items.push({
+      label: name,
+      kind: signaturesOf(type).length ? import_vscode_languageserver.CompletionItemKind.Function : import_vscode_languageserver.CompletionItemKind.Variable,
+      detail: (0, import_luaut_parser3.formatType)(type)
+    });
+  }
+  for (const [name, exported] of exports2.types) {
+    if (listed.has(name) || exports2.values.has(name)) continue;
+    items.push({
+      label: name,
+      kind: import_vscode_languageserver.CompletionItemKind.Interface,
+      detail: `type ${name} = ${(0, import_luaut_parser3.formatType)(exported.type)}`
+    });
+  }
+  return items;
+}
+function rangeBack(position, length) {
+  return { start: { line: position.line, character: position.character - length }, end: position };
+}
+function importDefinition(analyzer, analysis, position) {
+  const path = pathAt(analysis.program, position, true);
+  const statement = path.find(isModuleReference);
+  if (!statement?.source) return void 0;
+  const target = analyzer.resolveModulePath(analysis.uri, statement.source.value);
+  if (!target) return null;
+  const fileStart = {
+    uri: uriOfPath(target),
+    range: { start: { line: 0, character: 0 }, end: { line: 0, character: 0 } }
+  };
+  const name = referencedName(statement, path[path.length - 1]);
+  if (!name) return fileStart;
+  const module2 = analyzer.moduleAt(target);
+  const found = module2 && exportDeclaration(analyzer, module2, name);
+  return found ? { uri: found.uri, range: toRange(found.node) } : fileStart;
+}
+function isModuleReference(node) {
+  return node.type === "ImportStatement" || node.type === "ExportAllStatement" || node.type === "ExportNamedStatement" && !!node.source;
+}
+function referencedName(statement, node) {
+  switch (statement.type) {
+    case "ImportStatement":
+      if (node === statement.defaultImport) return "default";
+      return statement.specifiers.find((s) => node === s.imported || node === s.local)?.imported.name;
+    case "ExportNamedStatement":
+      return statement.specifiers.find((s) => node === s.local || node === s.exported)?.local.name;
+    case "ExportAllStatement":
+      return void 0;
+  }
+}
+function exportDeclaration(analyzer, module2, name, seen = /* @__PURE__ */ new Set()) {
+  const key = `${module2.uri}#${name}`;
+  if (seen.has(key)) return void 0;
+  seen.add(key);
+  const here = (node) => ({ uri: module2.uri, node });
+  const stars = [];
+  for (const statement of module2.program.body.statements) {
+    switch (statement.type) {
+      case "ExportDefaultStatement":
+        if (name === "default") return here(statement);
+        break;
+      case "ExportTypeAliasStatement":
+        if (statement.alias.name.name === name) return here(statement.alias.name);
+        break;
+      case "ExportStatement": {
+        const declaration = statement.declaration;
+        if (declaration.type === "FunctionDeclaration") {
+          if (declaration.name.name === name) return here(declaration.name);
+        } else {
+          for (const target of declaration.names) {
+            const found = patternNamed(target, name);
+            if (found) return here(found);
+          }
+        }
+        break;
+      }
+      case "ExportNamedStatement": {
+        const specifier = statement.specifiers.find((s) => s.exported.name === name);
+        if (!specifier) break;
+        if (statement.source) {
+          const next = moduleFrom(analyzer, module2, statement.source.value);
+          return next && exportDeclaration(analyzer, next, specifier.local.name, seen);
+        }
+        return here(localDeclaration(module2, specifier.local) ?? specifier.local);
+      }
+      case "ExportAllStatement":
+        stars.push(statement.source.value);
+        break;
+    }
+  }
+  if (name === "default") return void 0;
+  for (const specifier of stars) {
+    const next = moduleFrom(analyzer, module2, specifier);
+    const found = next && exportDeclaration(analyzer, next, name, seen);
+    if (found) return found;
+  }
+  return void 0;
+}
+function moduleFrom(analyzer, module2, specifier) {
+  const target = analyzer.resolveModulePath(module2.uri, specifier);
+  return target ? analyzer.moduleAt(target) : void 0;
+}
+function localDeclaration(module2, local) {
+  const binding = bindingOfNode(module2, local);
+  if (binding?.declarationNode) return binding.declarationNode;
+  for (const statement of module2.program.body.statements) {
+    const alias = statement.type === "TypeAliasStatement" ? statement : statement.type === "ExportTypeAliasStatement" ? statement.alias : void 0;
+    if (alias?.name.name === local.name) return alias.name;
+  }
+  return void 0;
+}
+function patternNamed(target, name) {
+  switch (target.type) {
+    case "IdentifierPattern":
+      return target.name === name ? target : void 0;
+    case "ObjectPattern":
+      for (const property of target.properties) {
+        const found = patternNamed(property.value, name);
+        if (found) return found;
+      }
+      return target.rest && patternNamed(target.rest, name);
+    case "ArrayPattern":
+      for (const element of target.elements) {
+        const found = element && patternNamed(element.value, name);
+        if (found) return found;
+      }
+      return target.rest && patternNamed(target.rest, name);
+  }
+}
+
 // src/features/diagnostics.ts
+var import_vscode_languageserver2 = require("vscode-languageserver");
 function diagnostics(analysis) {
   const out = [];
   for (const error of analysis.parseErrors) {
     const start = toPosition(error.line, error.column);
     out.push({
       range: { start, end: { line: start.line, character: start.character + 1 } },
-      severity: import_vscode_languageserver.DiagnosticSeverity.Error,
+      severity: import_vscode_languageserver2.DiagnosticSeverity.Error,
       source: "luaut",
       code: "syntax",
       // The parser appends `(line:column)`; the range already says that.
@@ -205,7 +597,7 @@ function diagnostics(analysis) {
   for (const d of analysis.scopes.diagnostics) {
     out.push({
       range: toRange(d.node),
-      severity: import_vscode_languageserver.DiagnosticSeverity.Error,
+      severity: import_vscode_languageserver2.DiagnosticSeverity.Error,
       source: "luaut",
       code: d.kind,
       message: d.message
@@ -214,7 +606,7 @@ function diagnostics(analysis) {
   for (const d of analysis.types.diagnostics) {
     out.push({
       range: toRange(d.node),
-      severity: import_vscode_languageserver.DiagnosticSeverity.Error,
+      severity: import_vscode_languageserver2.DiagnosticSeverity.Error,
       source: "luaut",
       code: "type",
       message: d.message
@@ -224,46 +616,201 @@ function diagnostics(analysis) {
 }
 
 // src/features/hover.ts
-var import_luaut_parser2 = require("luaut-parser");
+var import_luaut_parser4 = require("luaut-parser");
 function hover(analysis, position) {
   const path = pathAt(analysis.program, position, true);
   for (let i = path.length - 1; i >= 0; i--) {
-    const node = path[i];
-    const found = describe(analysis, node, path[i - 1]);
-    if (found) return { contents: { kind: "markdown", value: code(found) }, range: toRange(node) };
+    const text = describe(analysis, path, i);
+    if (text) return { contents: { kind: "markdown", value: code(text) }, range: toRange(path[i]) };
   }
   return null;
 }
-function describe(analysis, node, parent) {
+var PRIMITIVES = /* @__PURE__ */ new Set(["any", "unknown", "never", "nil", "boolean", "number", "string", "thread", "buffer"]);
+function describe(analysis, path, index) {
   const { types } = analysis;
-  if (node.type === "TypeAliasStatement" || node.type === "ExportTypeAliasStatement") {
-    const name = node.name;
-    const alias = types.aliases.get(name);
-    if (alias) return `type ${name} = ${(0, import_luaut_parser2.formatType)(alias)}`;
-  }
-  if (node.type === "Identifier") {
-    const identifier = node;
-    const narrowed = types.narrowedTypeOf.get(identifier);
-    if (narrowed) return `${identifier.name}: ${(0, import_luaut_parser2.formatType)(narrowed)}`;
-    const binding = bindingOfNode(analysis, identifier);
-    if (binding) {
-      const type2 = types.bindingType.get(binding.id);
-      if (type2) return `${keyword(binding)} ${binding.name}: ${(0, import_luaut_parser2.formatType)(type2)}`;
+  const node = path[index];
+  const parent = path[index - 1];
+  const typeOfNode = (n) => types.typeOfTypeNode.get(n);
+  switch (node.type) {
+    case "Identifier": {
+      const identifier2 = node;
+      const name = identifier2.name;
+      switch (parent?.type) {
+        // `{ name: "n" }` — read the property off the object's type, so
+        // it widens the way the object did (`string`, not `"n"`).
+        case "TableExpression": {
+          const field = fieldWithKey(parent, node);
+          if (!field) break;
+          const objectType = types.typeOf.get(parent);
+          const property = objectType?.kind === "object" ? objectType.properties.get(name) : void 0;
+          const type2 = property?.type ?? types.typeOf.get(field.value);
+          return type2 && `(property) ${name}: ${pretty(type2)}`;
+        }
+        case "ImportSpecifier": {
+          const alias = types.aliases.get(name);
+          const binding2 = bindingOfNode(analysis, identifier2);
+          const value = binding2 && types.bindingType.get(binding2.id);
+          if (alias && (!value || value.kind === "any")) return `type ${name} = ${pretty(alias)}`;
+          break;
+        }
+        case "ExportSpecifier": {
+          if (bindingOfNode(analysis, identifier2)) break;
+          const alias = types.aliases.get(name);
+          if (alias) return `type ${name} = ${pretty(alias)}`;
+          break;
+        }
+        case "TypeAliasStatement":
+        case "ExportTypeAliasStatement":
+          if (parent.name === node) return aliasText(analysis, parent);
+          break;
+        case "DeclareStatement":
+          if (parent.id === node) return declareText(analysis, parent);
+          break;
+        case "TableTypeProperty":
+          if (parent.key === node) {
+            const type2 = typeOfNode(parent.valueType);
+            const readonly = parent.readonly ? "readonly " : "";
+            return type2 && `(property) ${readonly}${name}${parent.optional ? "?" : ""}: ${pretty(type2)}`;
+          }
+          break;
+        case "FunctionTypeParameter":
+          if (parent.id === node) {
+            const type2 = typeOfNode(parent.typeAnnotation);
+            return type2 && `(parameter) ${name}${parent.optional ? "?" : ""}: ${pretty(type2)}`;
+          }
+          break;
+        case "GenericTypeParameter":
+          if (parent.id === node) return typeParameterText(analysis, parent);
+          break;
+        case "InferTypeNode":
+          if (parent.id === node) return `(type parameter) infer ${name}`;
+          break;
+        case "MappedTypeNode":
+          if (parent.parameterId === node) {
+            const keys = typeOfNode(parent.constraint);
+            return `(type parameter) ${name}${keys ? ` in ${(0, import_luaut_parser4.formatType)(keys)}` : ""}`;
+          }
+          break;
+      }
+      const narrowed = types.narrowedTypeOf.get(identifier2);
+      if (narrowed) return `${name}: ${pretty(narrowed)}`;
+      const binding = bindingOfNode(analysis, identifier2);
+      if (binding) {
+        const type2 = types.bindingType.get(binding.id);
+        if (type2) return `${keyword(binding)} ${binding.name}: ${pretty(type2)}`;
+      }
+      if (parent?.type === "MemberExpression" || parent?.type === "MethodCallExpression") {
+        const type2 = types.typeOf.get(parent);
+        if (type2) return `${name}: ${pretty(type2)}`;
+      }
+      return void 0;
     }
-    if (parent && (parent.type === "MemberExpression" || parent.type === "MethodCallExpression")) {
-      const type2 = types.typeOf.get(parent);
-      if (type2) return `${identifier.name}: ${(0, import_luaut_parser2.formatType)(type2)}`;
+    // Declarations: `const x`, a parameter, `const function f`.
+    case "IdentifierPattern":
+    case "FunctionParameter":
+    case "TypedIdentifier": {
+      const binding = bindingOfNode(analysis, node);
+      const type2 = binding && types.bindingType.get(binding.id);
+      return type2 ? `${keyword(binding)} ${binding.name}: ${pretty(type2)}` : void 0;
     }
-  }
-  if (node.type === "IdentifierPattern" || node.type === "FunctionParameter" || node.type === "TypedIdentifier") {
-    const binding = bindingOfNode(analysis, node);
-    if (binding) {
-      const type2 = types.bindingType.get(binding.id);
-      if (type2) return `${keyword(binding)} ${binding.name}: ${(0, import_luaut_parser2.formatType)(type2)}`;
+    // A type written by name: `number`, `Shape`, `Partial<User>`, or a type
+    // parameter in scope.
+    case "TypeReference": {
+      const base = node.base;
+      if (!node.namespace) {
+        const parameter = typeParameterInScope(path, index, base);
+        if (parameter) return typeParameterText(analysis, parameter);
+        if (PRIMITIVES.has(base)) return `type ${base}`;
+      }
+      if (!node.namespace && !node.typeArguments.length) {
+        const alias = types.aliases.get(base);
+        if (alias) return `type ${base} = ${pretty(alias)}`;
+      }
+      const type2 = typeOfNode(node);
+      return type2 && `type ${referenceText(analysis, node)} = ${pretty(type2)}`;
     }
   }
+  const annotated = typeOfNode(node);
+  if (annotated) return pretty(annotated);
   const type = types.typeOf.get(node);
-  return type ? (0, import_luaut_parser2.formatType)(type) : void 0;
+  return type ? pretty(type) : void 0;
+}
+function aliasText(analysis, statement) {
+  const name = statement.name.name;
+  const alias = analysis.types.aliases.get(name);
+  if (!alias) return void 0;
+  const generics = statement.generics ?? [];
+  const parameters = generics.length ? `<${generics.map((g) => typeParameterSignature(analysis, g)).join(", ")}>` : "";
+  return `type ${name}${parameters} = ${pretty(alias)}`;
+}
+function declareText(analysis, statement) {
+  const name = statement.name;
+  const own = analysis.types.typeOfTypeNode.get(statement.valueType);
+  if (!own) return void 0;
+  if (own.kind !== "function") return `declare ${name}: ${pretty(own)}`;
+  const total = analysis.program.body.statements.filter((s) => s.type === "DeclareStatement" && s.name === name).reduce((n, s) => n + signaturesOf(analysis.types.typeOfTypeNode.get(s.valueType)).length, 0);
+  const others = total - 1;
+  const overloads = others > 0 ? `  (+${others} overload${others > 1 ? "s" : ""})` : "";
+  return `declare function ${name}${(0, import_luaut_parser4.formatType)(own)}${overloads}`;
+}
+function typeParameterText(analysis, parameter) {
+  return `(type parameter) ${typeParameterSignature(analysis, parameter)}`;
+}
+function typeParameterSignature(analysis, parameter) {
+  const p = parameter;
+  if (p.infer) return `infer ${p.name}`;
+  const constraint = p.constraint ? analysis.types.typeOfTypeNode.get(p.constraint) : void 0;
+  return `${p.isConst ? "const " : ""}${p.name}${constraint ? ` extends ${(0, import_luaut_parser4.formatType)(constraint)}` : ""}`;
+}
+function typeParameterInScope(path, index, name) {
+  for (let i = index - 1; i >= 0; i--) {
+    const a = path[i];
+    const generic = a.generics?.find((g) => g.name === name);
+    if (generic) return generic;
+    if (a.type === "MappedTypeNode" && a.parameter === name) return { name };
+    if (a.type === "ConditionalTypeNode" && bindsInfer(a.extendsType, name)) return { name, infer: true };
+  }
+  return void 0;
+}
+function bindsInfer(node, name) {
+  if (!node || typeof node !== "object") return false;
+  if (Array.isArray(node)) return node.some((n2) => bindsInfer(n2, name));
+  const n = node;
+  if (n.type === "InferTypeNode" && n.name === name) return true;
+  return Object.values(n).some((v) => bindsInfer(v, name));
+}
+function referenceText(analysis, reference) {
+  const name = reference.namespace ? `${reference.namespace}.${reference.base}` : reference.base;
+  const args = reference.typeArguments ?? [];
+  if (!args.length) return name;
+  const resolved = args.map((a) => {
+    const t = analysis.types.typeOfTypeNode.get(a);
+    return t ? (0, import_luaut_parser4.formatType)(t) : "?";
+  });
+  return `${name}<${resolved.join(", ")}>`;
+}
+function fieldWithKey(table, key) {
+  const fields = table.fields;
+  return fields.find((f) => f.type === "TableFieldNamed" && f.key === key);
+}
+function pretty(type) {
+  const flat = (0, import_luaut_parser4.formatType)(type);
+  if (flat.length <= 80) return flat;
+  if (type.kind === "object") {
+    const lines = [];
+    if (type.indexer) lines.push(`    [${(0, import_luaut_parser4.formatType)(type.indexer.key)}]: ${(0, import_luaut_parser4.formatType)(type.indexer.value)},`);
+    for (const [name, property] of type.properties) {
+      const readonly = property.readonly ? "readonly " : "";
+      lines.push(`    ${readonly}${name}${property.optional ? "?" : ""}: ${(0, import_luaut_parser4.formatType)(property.type)},`);
+    }
+    return `{
+${lines.join("\n")}
+}`;
+  }
+  if (type.kind === "intersection" && type.types.every((t) => t.kind === "function")) {
+    return type.types.map(import_luaut_parser4.formatType).join("\n& ");
+  }
+  return flat;
 }
 function keyword(binding) {
   if (binding.kind === "param" || binding.kind === "self") return "(parameter)";
@@ -272,11 +819,11 @@ function keyword(binding) {
   return binding.isConst ? "const" : "let";
 }
 function code(text) {
-  return "```luaut\n" + text + "\n```";
+  return "```luaut-hover\n" + text + "\n```";
 }
 
 // src/features/navigation.ts
-var import_vscode_languageserver2 = require("vscode-languageserver");
+var import_vscode_languageserver3 = require("vscode-languageserver");
 var NAMING = /* @__PURE__ */ new Set(["Identifier", "IdentifierPattern", "FunctionParameter", "TypedIdentifier"]);
 function bindingAt(analysis, position) {
   const path = pathAt(analysis.program, position, true);
@@ -310,7 +857,7 @@ function highlights(analysis, position) {
   if (!binding) return [];
   return sites(binding).map((node) => ({
     range: toRange(node),
-    kind: node === binding.declarationNode ? import_vscode_languageserver2.DocumentHighlightKind.Write : import_vscode_languageserver2.DocumentHighlightKind.Read
+    kind: node === binding.declarationNode ? import_vscode_languageserver3.DocumentHighlightKind.Write : import_vscode_languageserver3.DocumentHighlightKind.Read
   }));
 }
 function prepareRename(analysis, position) {
@@ -318,9 +865,9 @@ function prepareRename(analysis, position) {
   if (!binding) return null;
   if (binding.isBuiltin || !binding.declarationNode) return null;
   const path = pathAt(analysis.program, position, true);
-  const identifier = [...path].reverse().find((n) => !!n.type && NAMING.has(n.type));
-  if (!identifier) return null;
-  return { range: toRange(identifier), placeholder: binding.name };
+  const identifier2 = [...path].reverse().find((n) => !!n.type && NAMING.has(n.type));
+  if (!identifier2) return null;
+  return { range: toRange(identifier2), placeholder: binding.name };
 }
 function rename(analysis, position, newName) {
   if (!isIdentifier(newName)) return null;
@@ -335,113 +882,90 @@ function isIdentifier(name) {
 }
 
 // src/features/completion.ts
-var import_vscode_languageserver3 = require("vscode-languageserver");
-var import_luaut_parser4 = require("luaut-parser");
-
-// src/features/members.ts
-var import_luaut_parser3 = require("luaut-parser");
-function membersOf(type, aliases, seen = /* @__PURE__ */ new Set()) {
-  if (!type || seen.has(type)) return [];
-  seen.add(type);
-  switch (type.kind) {
-    case "object": {
-      const out = [];
-      for (const [name, property] of type.properties) {
-        out.push({ name, property, isMethod: takesSelf(property.type) });
-      }
-      return out;
-    }
-    case "intersection": {
-      const merged = /* @__PURE__ */ new Map();
-      for (const part of type.types) {
-        for (const member of membersOf(part, aliases, seen)) merged.set(member.name, member);
-      }
-      return [...merged.values()];
-    }
-    case "union": {
-      const perBranch = type.types.map((part) => membersOf(part, aliases, seen));
-      if (!perBranch.length) return [];
-      const [first, ...rest] = perBranch;
-      return first.filter((member) => rest.every((other) => other.some((m) => m.name === member.name)));
-    }
-    case "genericRef": {
-      const alias = aliases.get(type.name);
-      return alias ? membersOf(alias, aliases, seen) : [];
-    }
-    case "typeParam":
-      return membersOf(type.constraint, aliases, seen);
-    default:
-      return [];
-  }
-}
-function takesSelf(type) {
-  for (const signature of signaturesOf(type)) {
-    if (signature.params[0]?.name === "self") return true;
-  }
-  return false;
-}
-function signaturesOf(type, aliases) {
-  if (!type) return [];
-  if (type.kind === "function") return [type];
-  if (type.kind === "intersection") return type.types.flatMap((t) => signaturesOf(t, aliases));
-  if (type.kind === "genericRef" && aliases) {
-    const alias = aliases.get(type.name);
-    return alias ? signaturesOf(alias, aliases) : [];
-  }
-  return [];
-}
-function signatureLabel(signature) {
-  const parameters = signature.params.map((p, i) => {
-    const name = p.name ?? `arg${i + 1}`;
-    return `${name}${p.optional ? "?" : ""}: ${(0, import_luaut_parser3.formatType)(p.type)}`;
-  });
-  const generics = signature.typeParams?.length ? `<${signature.typeParams.join(", ")}>` : "";
-  const varargs = signature.varargs ? [`...: ${(0, import_luaut_parser3.formatType)(signature.varargs)}`] : [];
-  const label = `${generics}(${[...parameters, ...varargs].join(", ")}) -> ${(0, import_luaut_parser3.formatType)(signature.returns)}`;
-  return { label, parameters };
-}
-
-// src/features/completion.ts
+var import_vscode_languageserver4 = require("vscode-languageserver");
+var import_luaut_parser5 = require("luaut-parser");
 var PLACEHOLDER = "__luautCompletion__";
 var IDENTIFIER_CHAR = /[A-Za-z0-9_]/;
 function completion(analyzer, document, position) {
+  const inImport = importCompletion(analyzer, document, position);
+  if (inImport) return inImport;
   const source = document.getText();
   const offset = document.offsetAt(position);
   let start = offset;
   while (start > 0 && IDENTIFIER_CHAR.test(source[start - 1])) start--;
   let end = offset;
   while (end < source.length && IDENTIFIER_CHAR.test(source[end])) end++;
-  const afterColon = source[start - 1] === ":";
+  const operator = memberOperator(source, start);
   const alreadyCalled = /^\s*\(/.test(source.slice(end));
-  const stand_in = afterColon && !alreadyCalled ? `${PLACEHOLDER}()` : PLACEHOLDER;
-  const patched = source.slice(0, start) + stand_in + source.slice(end);
-  const analysis = analyzer.analyze(document.uri, -1, patched);
+  const standIns = operator === ":" ? [alreadyCalled ? PLACEHOLDER : `${PLACEHOLDER}()`] : operator === "." && !alreadyCalled ? [PLACEHOLDER, `${PLACEHOLDER}()`] : [PLACEHOLDER];
   const at = { line: position.line, character: position.character - (offset - start) };
-  const path = pathAt(analysis.program, at, true);
-  const placeholder = [...path].reverse().find(
-    (n) => n.type === "Identifier" && n.name === PLACEHOLDER
-  );
-  const parent = placeholder ? path[path.indexOf(placeholder) - 1] : path[path.length - 1];
-  if (parent && (parent.type === "MemberExpression" || parent.type === "MethodCallExpression")) {
-    const object = parent.object;
-    const type = analysis.types.typeOf.get(object);
-    const wantMethods = parent.type === "MethodCallExpression";
-    return membersOf(type, analysis.types.aliases).filter((member) => wantMethods ? member.isMethod : true).map((member) => memberItem(member.name, member.property.type, member.property.readonly));
-  }
-  if (inTypePosition(path)) {
-    const named = [...analysis.types.aliases.keys()].map((name) => ({
+  let first;
+  for (const standIn of standIns) {
+    const patched = source.slice(0, start) + standIn + source.slice(end);
+    const analysis = analyzer.analyze(document.uri, -1, patched);
+    const path = pathAt(analysis.program, at, true);
+    const index = path.findLastIndex(
+      (n) => n.type === "Identifier" && n.name === PLACEHOLDER
+    );
+    const parent = index > 0 ? path[index - 1] : void 0;
+    if (parent && (parent.type === "MemberExpression" || parent.type === "MethodCallExpression")) {
+      return memberItems(analysis, parent);
+    }
+    first ??= { analysis, path };
+  }
+  if (operator || !first) return [];
+  if (inTypePosition(first.path)) {
+    const named = [...first.analysis.types.aliases.keys()].map((name) => ({
       label: name,
-      kind: import_vscode_languageserver3.CompletionItemKind.Interface,
+      kind: import_vscode_languageserver4.CompletionItemKind.Interface,
       detail: "type"
     }));
-    const primitives = PRIMITIVES.map((name) => ({
+    const primitives = PRIMITIVES2.map((name) => ({
       label: name,
-      kind: import_vscode_languageserver3.CompletionItemKind.Keyword,
+      kind: import_vscode_languageserver4.CompletionItemKind.Keyword,
       detail: "type"
     }));
     return [...named, ...primitives];
   }
-  return valueItems(analysis, at);
+  return valueItems(first.analysis, at);
+}
+function memberOperator(source, wordStart) {
+  const ch = source[wordStart - 1];
+  if (ch === ":") return source[wordStart - 2] === ":" ? void 0 : ":";
+  if (ch !== ".") return void 0;
+  if (source[wordStart - 2] === ".") return void 0;
+  let i = wordStart - 2;
+  while (i >= 0 && /[0-9]/.test(source[i])) i--;
+  const digits = wordStart - 2 - i;
+  if (digits > 0 && (i < 0 || !/[A-Za-z_]/.test(source[i]))) return void 0;
+  return ".";
+}
+function memberItems(analysis, access) {
+  const object = access.object;
+  const type = analysis.types.typeOf.get(object);
+  const colon = access.type === "MethodCallExpression";
+  if (isStringLike(type)) {
+    if (!colon) return [];
+    const id = analysis.scopes.globalsByName.get("string");
+    const library = id === void 0 ? void 0 : analysis.types.bindingType.get(id);
+    return membersOf(library, analysis.types.aliases).filter((member) => signaturesOf(member.property.type).length > 0).map((member) => memberItem(member.name, member.property.type, member.property.readonly));
+  }
+  return membersOf(type, analysis.types.aliases).filter((member) => colon ? member.isMethod : true).map((member) => memberItem(member.name, member.property.type, member.property.readonly));
+}
+function isStringLike(type) {
+  if (!type) return false;
+  switch (type.kind) {
+    case "primitive":
+      return type.name === "string";
+    case "literal":
+      return typeof type.value === "string";
+    case "templateLiteral":
+      return true;
+    case "union":
+      return type.types.length > 0 && type.types.every(isStringLike);
+    default:
+      return false;
+  }
 }
 function valueItems(analysis, at) {
   const items = [];
@@ -455,13 +979,13 @@ function valueItems(analysis, at) {
     items.push({
       label: binding.name,
       kind: kindOf(type, binding.kind),
-      detail: type ? (0, import_luaut_parser4.formatType)(type) : void 0,
+      detail: type ? (0, import_luaut_parser5.formatType)(type) : void 0,
       // Locals before globals, and globals before library names.
       sortText: `${binding.isBuiltin ? 2 : binding.kind === "global" ? 1 : 0}${binding.name}`
     });
   }
   for (const keyword2 of KEYWORDS) {
-    items.push({ label: keyword2, kind: import_vscode_languageserver3.CompletionItemKind.Keyword, sortText: `3${keyword2}` });
+    items.push({ label: keyword2, kind: import_vscode_languageserver4.CompletionItemKind.Keyword, sortText: `3${keyword2}` });
   }
   return items;
 }
@@ -470,29 +994,29 @@ function memberItem(name, type, readonly) {
   if (signatures.length) {
     return {
       label: name,
-      kind: import_vscode_languageserver3.CompletionItemKind.Method,
+      kind: import_vscode_languageserver4.CompletionItemKind.Method,
       detail: signatureLabel(signatures[0]).label,
       insertText: `${name}($0)`,
-      insertTextFormat: import_vscode_languageserver3.InsertTextFormat.Snippet
+      insertTextFormat: import_vscode_languageserver4.InsertTextFormat.Snippet
     };
   }
   return {
     label: name,
-    kind: import_vscode_languageserver3.CompletionItemKind.Field,
-    detail: `${readonly ? "readonly " : ""}${(0, import_luaut_parser4.formatType)(type)}`
+    kind: import_vscode_languageserver4.CompletionItemKind.Field,
+    detail: `${readonly ? "readonly " : ""}${(0, import_luaut_parser5.formatType)(type)}`
   };
 }
 function kindOf(type, bindingKind) {
-  if (type && signaturesOf(type).length) return import_vscode_languageserver3.CompletionItemKind.Function;
-  if (bindingKind === "param" || bindingKind === "self") return import_vscode_languageserver3.CompletionItemKind.Variable;
-  return import_vscode_languageserver3.CompletionItemKind.Variable;
+  if (type && signaturesOf(type).length) return import_vscode_languageserver4.CompletionItemKind.Function;
+  if (bindingKind === "param" || bindingKind === "self") return import_vscode_languageserver4.CompletionItemKind.Variable;
+  return import_vscode_languageserver4.CompletionItemKind.Variable;
 }
 function inTypePosition(path) {
   return path.some(
     (n) => !!n.type && (n.type.endsWith("TypeNode") || n.type === "TypeReference" || n.type === "TypeAliasStatement" || n.type === "ExportTypeAliasStatement")
   );
 }
-var PRIMITIVES = [
+var PRIMITIVES2 = [
   "any",
   "unknown",
   "never",
@@ -608,8 +1132,8 @@ function activeArgument(call, position) {
 }
 
 // src/features/symbols.ts
-var import_vscode_languageserver4 = require("vscode-languageserver");
-var import_luaut_parser5 = require("luaut-parser");
+var import_vscode_languageserver5 = require("vscode-languageserver");
+var import_luaut_parser6 = require("luaut-parser");
 function documentSymbols(analysis) {
   const out = [];
   walk(analysis.program, (node) => {
@@ -617,7 +1141,7 @@ function documentSymbols(analysis) {
       case "FunctionDeclaration":
       case "FunctionDeclarationStatement": {
         const name = functionName(node);
-        if (name) out.push(symbol(name, import_vscode_languageserver4.SymbolKind.Function, node, detailOf(analysis, node)));
+        if (name) out.push(symbol(name, import_vscode_languageserver5.SymbolKind.Function, node, detailOf(analysis, node)));
         break;
       }
       case "TypeAliasStatement":
@@ -626,14 +1150,14 @@ function documentSymbols(analysis) {
         const name = typeof named === "string" ? named : named?.name;
         if (name) {
           const alias = analysis.types.aliases.get(name);
-          out.push(symbol(name, import_vscode_languageserver4.SymbolKind.Interface, node, alias ? (0, import_luaut_parser5.formatType)(alias) : void 0));
+          out.push(symbol(name, import_vscode_languageserver5.SymbolKind.Interface, node, alias ? (0, import_luaut_parser6.formatType)(alias) : void 0));
         }
         break;
       }
       case "VariableDeclaration": {
         for (const target of node.names ?? []) {
           const name = target.name;
-          if (name) out.push(symbol(name, import_vscode_languageserver4.SymbolKind.Variable, target));
+          if (name) out.push(symbol(name, import_vscode_languageserver5.SymbolKind.Variable, target));
         }
         break;
       }
@@ -657,7 +1181,7 @@ function detailOf(analysis, node) {
   if (name && typeof name === "object") {
     const binding = bindingOfNode(analysis, name);
     const type = binding && analysis.types.bindingType.get(binding.id);
-    if (type) return (0, import_luaut_parser5.formatType)(type);
+    if (type) return (0, import_luaut_parser6.formatType)(type);
   }
   return void 0;
 }
@@ -666,10 +1190,245 @@ function symbol(name, kind, node, detail) {
   return { name, kind, detail, range, selectionRange: range };
 }
 
+// src/features/semanticTokens.ts
+var import_luaut_parser7 = require("luaut-parser");
+var TOKEN_TYPES = [
+  "namespace",
+  "type",
+  "typeParameter",
+  "parameter",
+  "variable",
+  "property",
+  "function",
+  "method",
+  "keyword"
+];
+var TOKEN_MODIFIERS = ["declaration", "readonly", "defaultLibrary"];
+var semanticTokensLegend = {
+  tokenTypes: [...TOKEN_TYPES],
+  tokenModifiers: [...TOKEN_MODIFIERS]
+};
+var SOFT_KEYWORDS = /* @__PURE__ */ new Set([
+  "type",
+  "declare",
+  "extends",
+  "keyof",
+  "infer",
+  "readonly",
+  "is",
+  "asserts",
+  "satisfies",
+  "typeof"
+]);
+var PRIMITIVES3 = /* @__PURE__ */ new Set(["any", "unknown", "never", "nil", "boolean", "number", "string", "thread", "buffer"]);
+function semanticTokens(analysis) {
+  const entries = /* @__PURE__ */ new Map();
+  const add = (at, length, type, modifiers = []) => {
+    const line = at.line.start - 1;
+    const character = at.column.start - 1;
+    const key = `${line}:${character}`;
+    if (!entries.has(key)) entries.set(key, { line, character, length, type, modifiers });
+  };
+  let tokens = [];
+  try {
+    tokens = (0, import_luaut_parser7.tokenize)(analysis.source);
+  } catch {
+  }
+  const identifiers = tokens.filter((t) => t.type === "Identifier");
+  const ancestors = [];
+  const walk2 = (node) => {
+    classify(analysis, node, ancestors, identifiers, add);
+    ancestors.push(node);
+    for (const child of children(node)) walk2(child);
+    ancestors.pop();
+  };
+  walk2(analysis.program);
+  for (const token of tokens) {
+    const value = token.value;
+    if (typeof value !== "string") continue;
+    if (token.type === "Keyword" && value !== "true" && value !== "false" && value !== "nil") {
+      add(token, value.length, "keyword");
+    } else if (token.type === "Identifier" && SOFT_KEYWORDS.has(value)) {
+      add(token, value.length, "keyword");
+    }
+  }
+  return { data: encode([...entries.values()]) };
+}
+function classify(analysis, spanned, ancestors, identifiers, add) {
+  const node = spanned;
+  switch (node.type) {
+    case "Identifier":
+      identifier(analysis, node, ancestors[ancestors.length - 1], add);
+      return;
+    // Declarations whose node starts at the name.
+    case "IdentifierPattern":
+    case "TypedIdentifier":
+    case "FunctionParameter": {
+      const name = node.name;
+      if (typeof name !== "string" || !name) return;
+      const binding = bindingOfNode(analysis, node);
+      add(node, name.length, valueKind(analysis, binding), modifiersOf(binding, true));
+      return;
+    }
+    case "TypeReference": {
+      const base = node.base;
+      const namespace = node.namespace;
+      const names = firstTokensWithin(identifiers, node, namespace ? 2 : 1);
+      if (namespace && names[0]) add(names[0], namespace.length, "namespace");
+      const baseToken = names[namespace ? 1 : 0];
+      if (!baseToken) return;
+      if (!namespace && typeParameterInScope2(ancestors, base)) {
+        add(baseToken, base.length, "typeParameter");
+      } else {
+        add(baseToken, base.length, "type", PRIMITIVES3.has(base) ? ["defaultLibrary"] : []);
+      }
+      return;
+    }
+  }
+}
+function identifier(analysis, node, parent, add) {
+  const name = node.name;
+  const as = (type, modifiers = []) => add(node, name.length, type, modifiers);
+  const typeOfNode = (n) => analysis.types.typeOfTypeNode.get(n);
+  switch (parent?.type) {
+    case "MemberExpression":
+      if (parent.property === node) {
+        return as(isFunction(analysis.types.typeOf.get(parent)) ? "method" : "property");
+      }
+      break;
+    case "MethodCallExpression":
+      if (parent.method === node) return as("method");
+      break;
+    case "TableExpression":
+      if (isFieldKey(parent, node)) return as("property", ["declaration"]);
+      break;
+    case "TypeAliasStatement":
+    case "ExportTypeAliasStatement":
+      if (parent.name === node) return as("type", ["declaration"]);
+      break;
+    case "DeclareStatement":
+      if (parent.id === node) return as(isFunction(typeOfNode(parent.valueType)) ? "function" : "variable", ["declaration"]);
+      break;
+    case "TableTypeProperty":
+      if (parent.key === node) {
+        return as(
+          isFunction(typeOfNode(parent.valueType)) ? "method" : "property",
+          parent.readonly ? ["declaration", "readonly"] : ["declaration"]
+        );
+      }
+      break;
+    case "FunctionTypeParameter":
+      if (parent.id === node) return as("parameter", ["declaration"]);
+      break;
+    case "GenericTypeParameter":
+    case "InferTypeNode":
+      if (parent.id === node) return as("typeParameter", ["declaration"]);
+      break;
+    case "MappedTypeNode":
+      if (parent.parameterId === node) return as("typeParameter", ["declaration"]);
+      break;
+    case "ImportSpecifier": {
+      const binding2 = bindingOfNode(analysis, node);
+      const value = binding2 && analysis.types.bindingType.get(binding2.id);
+      if (analysis.types.aliases.has(name) && (!value || value.kind === "any")) return as("type", ["declaration"]);
+      break;
+    }
+    case "ExportSpecifier":
+      if (!bindingOfNode(analysis, node) && analysis.types.aliases.has(name)) return as("type");
+      break;
+    case "FunctionName":
+      if (parent.path.includes(node)) return as("property");
+      if (parent.method === node) return as("method", ["declaration"]);
+      break;
+  }
+  const binding = bindingOfNode(analysis, node);
+  if (!binding) return;
+  as(valueKind(analysis, binding), modifiersOf(binding, binding.declarationNode === node));
+}
+function valueKind(analysis, binding) {
+  if (!binding) return "variable";
+  if (binding.kind === "param" || binding.kind === "self") return "parameter";
+  return isFunction(analysis.types.bindingType.get(binding.id)) ? "function" : "variable";
+}
+function modifiersOf(binding, isDeclaration) {
+  const modifiers = [];
+  if (isDeclaration) modifiers.push("declaration");
+  if (binding?.isConst) modifiers.push("readonly");
+  if (binding?.isBuiltin) modifiers.push("defaultLibrary");
+  return modifiers;
+}
+function isFunction(type) {
+  return signaturesOf(type).length > 0;
+}
+function isFieldKey(table, key) {
+  const fields = table.fields;
+  return fields.some((f) => f.type === "TableFieldNamed" && f.key === key);
+}
+function typeParameterInScope2(ancestors, name) {
+  for (let i = ancestors.length - 1; i >= 0; i--) {
+    const a = ancestors[i];
+    if (a.generics?.some((g) => g.name === name)) return true;
+    if (a.type === "MappedTypeNode" && a.parameter === name) return true;
+    if (a.type === "ConditionalTypeNode" && bindsInfer2(a.extendsType, name)) return true;
+  }
+  return false;
+}
+function bindsInfer2(node, name) {
+  if (!node || typeof node !== "object") return false;
+  if (Array.isArray(node)) return node.some((n2) => bindsInfer2(n2, name));
+  const n = node;
+  if (n.type === "InferTypeNode" && n.name === name) return true;
+  return Object.values(n).some((v) => bindsInfer2(v, name));
+}
+function firstTokensWithin(tokens, node, count) {
+  let lo = 0;
+  let hi = tokens.length;
+  while (lo < hi) {
+    const mid = lo + hi >> 1;
+    const t = tokens[mid];
+    const before = t.line.start < node.line.start || t.line.start === node.line.start && t.column.start < node.column.start;
+    if (before) lo = mid + 1;
+    else hi = mid;
+  }
+  const out = [];
+  for (let i = lo; i < tokens.length && out.length < count; i++) {
+    const t = tokens[i];
+    const after = t.line.start > node.line.end || t.line.start === node.line.end && t.column.start >= node.column.end;
+    if (after) break;
+    out.push(t);
+  }
+  return out;
+}
+function encode(entries) {
+  entries.sort((a, b) => a.line - b.line || a.character - b.character);
+  const data = [];
+  let line = 0;
+  let character = 0;
+  for (const e of entries) {
+    const deltaLine = e.line - line;
+    data.push(
+      deltaLine,
+      deltaLine === 0 ? e.character - character : e.character,
+      e.length,
+      TOKEN_TYPES.indexOf(e.type),
+      e.modifiers.reduce((bits, m) => bits | 1 << TOKEN_MODIFIERS.indexOf(m), 0)
+    );
+    line = e.line;
+    character = e.character;
+  }
+  return data;
+}
+
 // src/server.ts
 function createServer(connection, options = {}) {
-  const analyzer = new Analyzer(options);
   const documents = new import_node.TextDocuments(import_vscode_languageserver_textdocument.TextDocument);
+  const analyzer = new Analyzer({
+    ...options,
+    openDocument: (path) => documents.all().find((document) => {
+      const documentPath = pathOfUri(document.uri);
+      return documentPath !== void 0 && samePath(documentPath, path);
+    })
+  });
   connection.onInitialize((_params) => ({
     capabilities: {
       textDocumentSync: import_node.TextDocumentSyncKind.Incremental,
@@ -682,13 +1441,21 @@ function createServer(connection, options = {}) {
       completionProvider: {
         // `.` and `:` open a member list; the rest of the time
         // completion is asked for as you type a word.
-        triggerCharacters: [".", ":"],
+        // plus the characters that start or extend an import path.
+        triggerCharacters: [".", ":", '"', "'", "/"],
         resolveProvider: false
       },
-      signatureHelpProvider: { triggerCharacters: ["(", ","], retriggerCharacters: [","] }
+      signatureHelpProvider: { triggerCharacters: ["(", ","], retriggerCharacters: [","] },
+      // Colours from the parser, not from patterns: whether a word is a
+      // keyword, a type or a name depends on where it stands.
+      semanticTokensProvider: { legend: semanticTokensLegend, full: true }
     },
     serverInfo: { name: "luaut-language-server" }
   }));
+  connection.languages.semanticTokens.on((p) => {
+    const document = documents.get(p.textDocument.uri);
+    return document ? semanticTokens(analyzer.get(document)) : { data: [] };
+  });
   const publish = (document) => {
     void connection.sendDiagnostics({
       uri: document.uri,
@@ -697,7 +1464,11 @@ function createServer(connection, options = {}) {
     });
   };
   documents.onDidOpen((e) => publish(e.document));
-  documents.onDidChangeContent((e) => publish(e.document));
+  const publishAll = () => {
+    for (const document of documents.all()) publish(document);
+  };
+  documents.onDidChangeContent(publishAll);
+  connection.onDidChangeWatchedFiles(publishAll);
   documents.onDidClose((e) => {
     analyzer.forget(e.document.uri);
     void connection.sendDiagnostics({ uri: e.document.uri, diagnostics: [] });
@@ -713,7 +1484,11 @@ function createServer(connection, options = {}) {
   ));
   connection.onDefinition((p) => withDocument(
     p.textDocument.uri,
-    (d) => definition(analyzer.get(d), p.position),
+    (d) => {
+      const analysis = analyzer.get(d);
+      const across = importDefinition(analyzer, analysis, p.position);
+      return across !== void 0 ? across : definition(analysis, p.position);
+    },
     null
   ));
   connection.onReferences((p) => withDocument(
@@ -772,20 +1547,28 @@ function startServer(options = {}) {
   diagnostics,
   documentSymbols,
   enclosing,
+  exportDeclaration,
   highlights,
   hover,
+  importCompletion,
+  importDefinition,
   membersOf,
   nodeAt,
   pathAt,
+  pathOfUri,
   prepareRename,
   references,
   rename,
+  samePath,
+  semanticTokens,
+  semanticTokensLegend,
   signatureHelp,
   signatureLabel,
   signaturesOf,
   startServer,
   toPosition,
   toRange,
+  uriOfPath,
   walk
 });
 //# sourceMappingURL=index.cjs.map