luaut-language-server 2.1.0 → 3.1.0

package/dist/index.cjs

@@ -68,6 +68,19 @@ var import_luaut_parser2 = require("luaut-parser");
 
 // src/features/members.ts
 var import_luaut_parser = require("luaut-parser");
+function literalKeys(key, aliases) {
+  if (!key) return [];
+  const resolved = key.kind === "genericRef" ? aliases.get(key.name) : key;
+  if (!resolved) return [];
+  const parts = resolved.kind === "union" ? resolved.types : [resolved];
+  const out = [];
+  for (const part of parts) {
+    const member = part.kind === "genericRef" ? aliases.get(part.name) ?? part : part;
+    if (member.kind !== "literal" || typeof member.value !== "string") return [];
+    out.push(member.value);
+  }
+  return out;
+}
 function membersOf(type, aliases, seen = /* @__PURE__ */ new Set()) {
   if (!type || seen.has(type)) return [];
   seen.add(type);
@@ -77,6 +90,11 @@ function membersOf(type, aliases, seen = /* @__PURE__ */ new Set()) {
       for (const [name, property] of type.properties) {
         out.push({ name, property, isMethod: takesSelf(property.type) });
       }
+      for (const name of literalKeys(type.indexer?.key, aliases)) {
+        if (type.properties.has(name)) continue;
+        const property = { type: type.indexer.value, optional: true };
+        out.push({ name, property, isMethod: takesSelf(property.type) });
+      }
       return out;
     }
     case "intersection": {
@@ -396,11 +414,13 @@ var Analyzer = class {
     const script = path ? context.sourceMap?.scriptFor(path) : void 0;
     const libs = script ? [...context.libs, script] : context.libs;
     const globals = script ? [...context.globals, "script"] : context.globals;
-    const { program, errors } = (0, import_luaut_parser2.parseWithRecovery)(source);
-    const scopes = (0, import_luaut_parser2.analyzeScopes)(program, { builtinGlobals: [...globals] });
+    const { program, errors, directives } = (0, import_luaut_parser2.parseWithRecovery)(source);
+    const reportUndeclared = context.libs.length > 0;
+    const scopes = (0, import_luaut_parser2.analyzeScopes)(program, { builtinGlobals: [...globals], reportUndeclared });
     const dependencies = new Map(context.reads);
     const types = (0, import_luaut_parser2.analyzeTypes)(program, scopes, {
       libs,
+      reportUnknownTypes: reportUndeclared,
       resolveModule: (specifier) => {
         if (!path) return void 0;
         const candidates = this.candidatesFor(path, specifier);
@@ -414,7 +434,7 @@ var Analyzer = class {
         return exports2;
       }
     });
-    return { uri, version, source, program, parseErrors: errors, scopes, types, dependencies, project: context.project };
+    return { uri, version, source, program, parseErrors: errors, directives, scopes, types, dependencies, project: context.project };
   }
   exportsOf(path, importing) {
     const key = pathKey(path);
@@ -509,7 +529,7 @@ function collect(container, out) {
   }
 }
 function isSpanlessNode(v) {
-  return !!v && typeof v === "object" && typeof v.type === "string";
+  return !!v && typeof v === "object" && !Array.isArray(v);
 }
 function pathAt(root, pos, inclusive = false) {
   let best;
@@ -780,6 +800,7 @@ function patternNamed(target, name) {
 
 // src/features/diagnostics.ts
 var import_vscode_languageserver2 = require("vscode-languageserver");
+var import_luaut_parser4 = require("luaut-parser");
 function diagnostics(analysis) {
   const out = [];
   for (const error of analysis.parseErrors) {
@@ -793,37 +814,64 @@ function diagnostics(analysis) {
       message: error.message.replace(/\s*\(\d+:\d+\)$/, "")
     });
   }
-  for (const d of analysis.scopes.diagnostics) {
-    out.push({
+  const semantic = [
+    ...analysis.scopes.diagnostics.map((d) => ({
       range: toRange(d.node),
       severity: import_vscode_languageserver2.DiagnosticSeverity.Error,
       source: "luaut",
       code: d.kind,
       message: d.message
-    });
-  }
-  for (const d of analysis.types.diagnostics) {
-    out.push({
+    })),
+    ...analysis.types.diagnostics.map((d) => ({
       range: toRange(d.node),
       severity: import_vscode_languageserver2.DiagnosticSeverity.Error,
       source: "luaut",
       code: "type",
       message: d.message
+    }))
+  ];
+  const { kept, unusedExpectErrors } = (0, import_luaut_parser4.applyDirectives)(analysis.directives, semantic, (d) => d.range.start.line + 1);
+  out.push(...kept);
+  for (const directive of unusedExpectErrors) {
+    const start = toPosition(directive.line, directive.column);
+    out.push({
+      range: { start, end: { line: start.line, character: start.character + "--@luaut-expect-error".length } },
+      severity: import_vscode_languageserver2.DiagnosticSeverity.Error,
+      source: "luaut",
+      code: "directive",
+      message: import_luaut_parser4.UNUSED_EXPECT_ERROR
     });
   }
   return out;
 }
 
 // src/features/hover.ts
-var import_luaut_parser4 = require("luaut-parser");
+var import_luaut_parser5 = require("luaut-parser");
 function hover(analysis, position) {
   const path = pathAt(analysis.program, position, true);
   for (let i = path.length - 1; i >= 0; i--) {
+    if (UNNAMED.has(path[i].type)) return null;
     const text = describe(analysis, path, i);
     if (text) return { contents: { kind: "markdown", value: code(text) }, range: toRange(path[i]) };
   }
   return null;
 }
+var UNNAMED = /* @__PURE__ */ new Set([
+  "BinaryExpression",
+  "UnaryExpression",
+  "CallExpression",
+  "MethodCallExpression",
+  "MemberExpression",
+  "IndexExpression",
+  "ParenthesizedExpression",
+  "IfElseExpression",
+  "TableExpression",
+  "ArrayExpression",
+  "TypeAssertionExpression",
+  "SatisfiesExpression",
+  "AsConstExpression",
+  "InterpolatedStringExpression"
+]);
 var PRIMITIVES = /* @__PURE__ */ new Set(["any", "unknown", "never", "nil", "boolean", "number", "string", "thread", "buffer"]);
 function describe(analysis, path, index) {
   const { types } = analysis;
@@ -845,6 +893,27 @@ function describe(analysis, path, index) {
           const type2 = property?.type ?? types.typeOf.get(field.value);
           return type2 && `(property) ${name}: ${pretty(type2)}`;
         }
+        // `const { name } = t`: a shorthand key *is* the binding it
+        // declares, and has the same span, so the cursor can land on
+        // either. A renamed key (`{ name: other }`) names the property
+        // the value is read from.
+        case "ObjectPatternProperty": {
+          if (parent.key !== node || parent.computed) break;
+          const value = parent.value;
+          if (parent.shorthand) return describe(analysis, [...path.slice(0, index), value], index);
+          const binding2 = value.type === "IdentifierPattern" ? bindingOfNode(analysis, value) : void 0;
+          const type2 = binding2 && types.bindingType.get(binding2.id);
+          return type2 && `(property) ${name}: ${pretty(type2)}`;
+        }
+        // One line of an overload set reads as its own signature.
+        // The line the body is on reads as the whole set, which is
+        // what the binding says and what the default path gives.
+        case "FunctionSignature": {
+          if (parent.name !== node) break;
+          const own = types.typeOfTypeNode.get(parent);
+          if (own) return `function ${name}${pretty(own)}`;
+          break;
+        }
         case "ImportSpecifier": {
           const alias = types.aliases.get(name);
           const binding2 = bindingOfNode(analysis, identifier2);
@@ -890,7 +959,7 @@ function describe(analysis, path, index) {
         case "MappedTypeNode":
           if (parent.parameterId === node) {
             const keys = typeOfNode(parent.constraint);
-            return `(type parameter) ${name}${keys ? ` in ${(0, import_luaut_parser4.formatType)(keys)}` : ""}`;
+            return `(type parameter) ${name}${keys ? ` in ${(0, import_luaut_parser5.formatType)(keys)}` : ""}`;
           }
           break;
       }
@@ -899,7 +968,7 @@ function describe(analysis, path, index) {
       const binding = bindingOfNode(analysis, identifier2);
       if (binding) {
         const type2 = types.bindingType.get(binding.id);
-        if (type2) return `${keyword(binding)} ${binding.name}: ${pretty(type2)}`;
+        if (type2) return bindingText(binding, type2);
       }
       if (parent?.type === "MemberExpression" || parent?.type === "MethodCallExpression") {
         const type2 = types.typeOf.get(parent);
@@ -907,13 +976,18 @@ function describe(analysis, path, index) {
       }
       return void 0;
     }
-    // Declarations: `const x`, a parameter, `const function f`.
+    // `...` — what this function's extra arguments are.
+    case "VarargExpression": {
+      const type2 = types.typeOf.get(node);
+      return type2 ? `(vararg) ...: ${pretty(type2)}` : void 0;
+    }
+    // Declarations: `const x`, a parameter.
     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;
+      return type2 ? bindingText(binding, type2) : void 0;
     }
     // A type written by name: `number`, `Shape`, `Partial<User>`, or a type
     // parameter in scope.
@@ -927,7 +1001,7 @@ function describe(analysis, path, index) {
       if (!node.typeArguments.length) {
         const qualified = node.namespace ? `${node.namespace}.${base}` : base;
         const alias = types.aliases.get(qualified);
-        if (alias && (0, import_luaut_parser4.isClassType)(alias)) return classText(analysis, qualified);
+        if (alias && (0, import_luaut_parser5.isClassType)(alias)) return classText(analysis, qualified);
         if (alias) return `type ${qualified} = ${pretty(alias)}`;
       }
       const type2 = typeOfNode(node);
@@ -955,17 +1029,17 @@ function declareText(analysis, statement) {
   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}`;
+  return `declare function ${name}${(0, import_luaut_parser5.formatType)(own)}${overloads}`;
 }
 function classText(analysis, name) {
   const type = analysis.types.aliases.get(name);
-  if (!type || !(0, import_luaut_parser4.isClassType)(type)) return void 0;
+  if (!type || !(0, import_luaut_parser5.isClassType)(type)) return void 0;
   const superclass = type.class.superclass;
   const inherited = superclass ? analysis.types.aliases.get(superclass) : void 0;
   const own = [...type.properties].filter(([key, property]) => inherited?.kind !== "object" || inherited.properties.get(key) !== property);
   const head = `declare class ${name}${superclass ? ` extends ${superclass}` : ""}`;
   if (!own.length) return `${head} {}`;
-  const lines = own.map(([key, property]) => `    ${property.readonly ? "readonly " : ""}${key}${property.optional ? "?" : ""}: ${(0, import_luaut_parser4.formatType)(property.type)},`);
+  const lines = own.map(([key, property]) => `    ${property.readonly ? "readonly " : ""}${key}${property.optional ? "?" : ""}: ${(0, import_luaut_parser5.formatType)(property.type)},`);
   return `${head} {
 ${lines.join("\n")}
 }`;
@@ -977,7 +1051,7 @@ 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)}` : ""}`;
+  return `${p.isConst ? "const " : ""}${p.name}${constraint ? ` extends ${(0, import_luaut_parser5.formatType)(constraint)}` : ""}`;
 }
 function typeParameterInScope(path, index, name) {
   for (let i = index - 1; i >= 0; i--) {
@@ -1002,7 +1076,7 @@ function referenceText(analysis, reference) {
   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 t ? (0, import_luaut_parser5.formatType)(t) : "?";
   });
   return `${name}<${resolved.join(", ")}>`;
 }
@@ -1011,28 +1085,37 @@ function fieldWithKey(table, key) {
   return fields.find((f) => f.type === "TableFieldNamed" && f.key === key);
 }
 function pretty(type) {
-  const flat = (0, import_luaut_parser4.formatType)(type);
+  const flat = (0, import_luaut_parser5.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)},`);
+    if (type.indexer) lines.push(`    [${(0, import_luaut_parser5.formatType)(type.indexer.key)}]: ${(0, import_luaut_parser5.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)},`);
+      lines.push(`    ${readonly}${name}${property.optional ? "?" : ""}: ${(0, import_luaut_parser5.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 type.types.map(import_luaut_parser5.formatType).join("\n& ");
   }
   return flat;
 }
+function bindingText(binding, type) {
+  if (binding.declaredBy === "function" && type.kind === "function") {
+    return `function ${binding.name}${(0, import_luaut_parser5.formatType)(type)}`;
+  }
+  return `${keyword(binding)} ${binding.name}: ${pretty(type)}`;
+}
 function keyword(binding) {
   if (binding.kind === "param" || binding.kind === "self") return "(parameter)";
   if (binding.kind === "global") return "(global)";
   if (binding.kind.startsWith("for-")) return "(loop variable)";
+  if (binding.declaredBy === "import" || binding.declaredBy === "namespace") return "(import)";
+  if (binding.declaredBy === "type") return "(type import)";
+  if (binding.declaredBy === "function") return "function";
   return binding.isConst ? "const" : "let";
 }
 function code(text) {
@@ -1099,8 +1182,162 @@ function isIdentifier(name) {
 }
 
 // src/features/completion.ts
+var import_vscode_languageserver5 = require("vscode-languageserver");
+var import_luaut_parser6 = require("luaut-parser");
+
+// src/features/autoImport.ts
+var import_node_fs3 = require("fs");
+var import_node_path3 = require("path");
 var import_vscode_languageserver4 = require("vscode-languageserver");
-var import_luaut_parser5 = require("luaut-parser");
+function importItems(analyzer, analysis, typePosition, taken) {
+  const from = pathOfUri(analysis.uri);
+  if (!from) return [];
+  const config = analysis.project.config;
+  const items = [];
+  const offered = /* @__PURE__ */ new Set();
+  for (const file of projectFiles(config?.directory ?? (0, import_node_path3.dirname)(from))) {
+    if (samePath(file, from)) continue;
+    const exports2 = analyzer.exportsAt(file);
+    if (!exports2 || exports2.partial) continue;
+    const names = typePosition ? [...exports2.types.keys()] : [...exports2.values.keys()];
+    const specifier = specifierFor(from, file, config);
+    for (const name of names) {
+      if (taken.has(name) || offered.has(name)) continue;
+      offered.add(name);
+      const type = typePosition ? exports2.types.get(name)?.type : exports2.values.get(name);
+      items.push({
+        label: name,
+        kind: typePosition ? import_vscode_languageserver4.CompletionItemKind.Interface : type && signaturesOf(type).length ? import_vscode_languageserver4.CompletionItemKind.Function : import_vscode_languageserver4.CompletionItemKind.Variable,
+        labelDetails: { description: specifier },
+        detail: `import { ${name} } from "${specifier}"`,
+        sortText: `4${name}`,
+        additionalTextEdits: [importEdit(analyzer, analysis, file, name, specifier, typePosition)]
+      });
+    }
+  }
+  return items;
+}
+function serviceItems(analysis, taken) {
+  const services = analysis.types.aliases.get("Services");
+  if (!services || services.kind !== "object") return [];
+  const at = serviceInsertion(analysis.program.body.statements);
+  const items = [];
+  for (const name of services.properties.keys()) {
+    if (taken.has(name)) continue;
+    const line = `const ${name} = game:GetService("${name}")`;
+    items.push({
+      label: name,
+      kind: import_vscode_languageserver4.CompletionItemKind.Module,
+      labelDetails: { description: "service" },
+      detail: line,
+      sortText: `5${name}`,
+      additionalTextEdits: [{ range: { start: at.position, end: at.position }, newText: `${line}
+${at.gap}` }]
+    });
+  }
+  return items;
+}
+function importEdit(analyzer, analysis, file, name, specifier, typePosition) {
+  const statements = analysis.program.body.statements;
+  const imports = statements.filter((s) => s.type === "ImportStatement");
+  const existing = imports.find((s) => !s.namespaceImport && (typePosition || !s.isTypeOnly) && samePathOrUndefined(analyzer.resolveModulePath(analysis.uri, s.source.value), file));
+  if (existing) {
+    const last = existing.specifiers[existing.specifiers.length - 1];
+    if (last) {
+      const at2 = endOf(last);
+      return { range: { start: at2, end: at2 }, newText: `, ${name}` };
+    }
+    if (existing.defaultImport) {
+      const at2 = endOf(existing.defaultImport);
+      return { range: { start: at2, end: at2 }, newText: `, { ${name} }` };
+    }
+  }
+  const line = `import { ${name} } from "${specifier}"`;
+  const lastImport = imports[imports.length - 1];
+  if (lastImport) {
+    const at2 = { line: lastImport.line.end, character: 0 };
+    return { range: { start: at2, end: at2 }, newText: `${line}
+` };
+  }
+  const first = statements[0];
+  const at = { line: first ? first.line.start - 1 : 0, character: 0 };
+  return { range: { start: at, end: at }, newText: first ? `${line}
+
+` : `${line}
+` };
+}
+function serviceInsertion(statements) {
+  let last;
+  for (const statement of statements) {
+    if (statement.type !== "ImportStatement" && !isServiceDeclaration(statement)) break;
+    last = statement;
+  }
+  if (last) return { position: { line: last.line.end, character: 0 }, gap: "" };
+  const first = statements[0];
+  return first ? { position: { line: first.line.start - 1, character: 0 }, gap: "\n" } : { position: { line: 0, character: 0 }, gap: "" };
+}
+function isServiceDeclaration(statement) {
+  if (statement.type !== "VariableDeclaration") return false;
+  const init = statement.init[0];
+  return init?.type === "MethodCallExpression" && init.method.name === "GetService" && init.object.type === "Identifier" && init.object.name === "game";
+}
+function endOf(node) {
+  return { line: node.line.end - 1, character: node.column.end - 1 };
+}
+function samePathOrUndefined(a, b) {
+  return a !== void 0 && samePath(a, b);
+}
+function specifierFor(from, target, config) {
+  const withoutExtension = (path) => {
+    const bare = path.replace(/\\/g, "/").replace(/\.luaut$/, "");
+    return bare.endsWith("/index") ? bare.slice(0, -"/index".length) : bare;
+  };
+  let relativePath = withoutExtension((0, import_node_path3.relative)((0, import_node_path3.dirname)(from), target));
+  if (!relativePath.startsWith(".")) relativePath = `./${relativePath}`;
+  if (!relativePath.startsWith("../") || !config) return relativePath;
+  for (const [pattern, targets] of Object.entries(config.paths)) {
+    const star = pattern.indexOf("*");
+    if (star < 0) continue;
+    for (const targetPattern of targets) {
+      const cut = targetPattern.indexOf("*");
+      if (cut < 0) continue;
+      const head = (0, import_node_path3.resolve)(config.baseUrl, targetPattern.slice(0, cut));
+      const rest = (0, import_node_path3.relative)(head, target);
+      if (rest.startsWith("..") || (0, import_node_path3.resolve)(head, rest) !== (0, import_node_path3.resolve)(target)) continue;
+      return `${pattern.slice(0, star)}${withoutExtension(rest)}${pattern.slice(star + 1)}`;
+    }
+  }
+  return relativePath;
+}
+var FILE_LIMIT = 2e3;
+var LISTING_TTL = 3e3;
+var listings = /* @__PURE__ */ new Map();
+function projectFiles(root) {
+  const cached = listings.get(root);
+  if (cached && Date.now() - cached.at < LISTING_TTL) return cached.files;
+  const files = [];
+  const walk2 = (directory, depth) => {
+    if (files.length >= FILE_LIMIT || depth > 12) return;
+    let entries;
+    try {
+      entries = (0, import_node_fs3.readdirSync)(directory, { withFileTypes: true });
+    } catch {
+      return;
+    }
+    for (const entry of entries) {
+      if (entry.name.startsWith(".") || entry.name === "node_modules") continue;
+      const path = (0, import_node_path3.join)(directory, entry.name);
+      if (entry.isDirectory()) walk2(path, depth + 1);
+      else if (entry.name.endsWith(".luaut") && !entry.name.endsWith(".d.luaut")) files.push(path);
+      if (files.length >= FILE_LIMIT) return;
+    }
+  };
+  walk2(root, 0);
+  listings.set(root, { at: Date.now(), files });
+  return files;
+}
+
+// src/features/completion.ts
 var PLACEHOLDER = "__luautCompletion__";
 var IDENTIFIER_CHAR = /[A-Za-z0-9_]/;
 function completion(analyzer, document, position) {
@@ -1133,28 +1370,58 @@ function completion(analyzer, document, position) {
     first ??= { analysis, path };
   }
   if (operator || !first) return [];
+  const keys = objectKeyItems(first.analysis, first.path, source.slice(end));
+  if (keys) return keys;
   if (inTypePosition(first.path)) {
     const named = [...first.analysis.types.aliases].map(([name, type]) => ({
       label: name,
-      kind: (0, import_luaut_parser5.isClassType)(type) ? import_vscode_languageserver4.CompletionItemKind.Class : import_vscode_languageserver4.CompletionItemKind.Interface,
-      detail: (0, import_luaut_parser5.isClassType)(type) ? "class" : "type"
+      kind: (0, import_luaut_parser6.isClassType)(type) ? import_vscode_languageserver5.CompletionItemKind.Class : import_vscode_languageserver5.CompletionItemKind.Interface,
+      detail: (0, import_luaut_parser6.isClassType)(type) ? "class" : "type"
     }));
     const primitives = PRIMITIVES2.map((name) => ({
       label: name,
-      kind: import_vscode_languageserver4.CompletionItemKind.Keyword,
+      kind: import_vscode_languageserver5.CompletionItemKind.Keyword,
       detail: "type"
     }));
-    return [...named, ...primitives];
-  }
-  return valueItems(first.analysis, at);
+    const keywords = TYPE_KEYWORDS.map((name) => ({
+      label: name,
+      kind: import_vscode_languageserver5.CompletionItemKind.Keyword,
+      sortText: `3${name}`
+    }));
+    const typeNames = new Set(first.analysis.types.aliases.keys());
+    const imported = importItems(analyzer, analyzer.get(document), true, typeNames);
+    return [...named, ...primitives, ...keywords, ...imported];
+  }
+  const taken = /* @__PURE__ */ new Set();
+  for (const binding of first.analysis.scopes.bindings.values()) taken.add(binding.name);
+  const current = analyzer.get(document);
+  return [
+    ...valueItems(first.analysis, at),
+    ...contextKeywords(source.slice(0, start)),
+    ...importItems(analyzer, current, false, taken),
+    ...serviceItems(current, taken)
+  ];
 }
 function stringCompletion(analyzer, document, position) {
-  const analysis = analyzer.get(document);
-  const path = pathAt(analysis.program, position, false);
-  const literal = [...path].reverse().find((n) => n.type === "StringLiteral");
-  if (!literal) return void 0;
+  let analysis = analyzer.get(document);
+  let literal = stringAt(analysis, position);
+  if (!literal) {
+    const repaired = repairedStrings(document, position);
+    for (const text of repaired) {
+      const candidate = analyzer.analyze(document.uri, -1, text);
+      literal = stringAt(candidate, position);
+      if (literal) {
+        analysis = candidate;
+        break;
+      }
+    }
+    if (!literal) return repaired.length ? [] : void 0;
+  }
   const expected = analysis.types.expectedTypeOf.get(literal);
-  const values = stringLiterals(expected, analysis.types.aliases);
+  const values = [.../* @__PURE__ */ new Set([
+    ...stringLiterals(expected, analysis.types.aliases),
+    ...indexKeys(analysis, position, literal)
+  ])];
   if (!values.length) return [];
   const line = literal.line.start - 1;
   const range = literal.line.start === literal.line.end ? {
@@ -1163,10 +1430,81 @@ function stringCompletion(analyzer, document, position) {
   } : void 0;
   return values.map((value) => ({
     label: value,
-    kind: import_vscode_languageserver4.CompletionItemKind.Constant,
+    kind: import_vscode_languageserver5.CompletionItemKind.Constant,
     ...range ? { textEdit: { range, newText: value } } : {}
   }));
 }
+function stringAt(analysis, position) {
+  const path = pathAt(analysis.program, position, false);
+  return [...path].reverse().find((n) => n.type === "StringLiteral" || n.type === "TypeLiteralString");
+}
+function objectKeyItems(analysis, path, after) {
+  const index = path.findLastIndex(
+    (n) => n.type === "Identifier" && n.name === PLACEHOLDER
+  );
+  const literal = index > 0 ? path[index - 1] : void 0;
+  if (literal?.type !== "TableExpression") return void 0;
+  const fields = literal.fields;
+  const atKey = fields.some((f) => f.type === "TableFieldShorthand" && f.name?.name === PLACEHOLDER);
+  if (!atKey) return void 0;
+  let expected = analysis.types.expectedTypeOf.get(literal);
+  for (let up = index - 2; expected === void 0 && up >= 0; up--) {
+    const outer = path[up];
+    if (outer.type !== "AsConstExpression" && outer.type !== "ParenthesizedExpression") break;
+    expected = analysis.types.expectedTypeOf.get(outer);
+  }
+  const members = membersOf(expected, analysis.types.aliases);
+  if (!members.length) return void 0;
+  const written = /* @__PURE__ */ new Set();
+  for (const field of fields) {
+    if (field.type === "TableFieldNamed") written.add(field.key?.name ?? field.key?.value ?? "");
+    else if (field.type === "TableFieldShorthand" && field.name?.name !== PLACEHOLDER) written.add(field.name.name);
+  }
+  const colon = /^\s*:/.test(after);
+  return members.filter((member) => !written.has(member.name)).map((member) => ({
+    label: member.name,
+    kind: import_vscode_languageserver5.CompletionItemKind.Field,
+    detail: `${member.property.optional ? "?" : ""}: ${(0, import_luaut_parser6.formatType)(member.property.type)}`,
+    insertText: colon ? member.name : `${member.name}: `
+  }));
+}
+function indexKeys(analysis, position, literal) {
+  const path = pathAt(analysis.program, position, false);
+  const at = path.indexOf(literal);
+  const parent = at > 0 ? path[at - 1] : void 0;
+  if (!parent) return [];
+  let indexed;
+  if (parent.type === "IndexedAccessTypeNode" && parent.indexType === literal) {
+    indexed = analysis.types.typeOfTypeNode.get(parent.objectType);
+  } else if (parent.type === "IndexExpression" && parent.index === literal) {
+    indexed = withoutNil(analysis.types.typeOf.get(parent.object));
+  }
+  return membersOf(indexed, analysis.types.aliases).map((member) => member.name);
+}
+function repairedStrings(document, position) {
+  const source = document.getText();
+  const offset = document.offsetAt(position);
+  const lineStart = offset - position.character;
+  const lineEndIndex = source.indexOf("\n", offset);
+  const lineEnd = lineEndIndex < 0 ? source.length : lineEndIndex;
+  const before = source.slice(lineStart, offset);
+  let quote;
+  for (let i = 0; i < before.length; i++) {
+    const ch = before[i];
+    if (quote) {
+      if (ch === "\\") i++;
+      else if (ch === quote) quote = void 0;
+    } else if (ch === '"' || ch === "'") {
+      quote = ch;
+    }
+  }
+  if (!quote) return [];
+  let rest = source.slice(offset, lineEnd).replace(/\r$/, "");
+  if (!rest.includes(quote)) rest += quote;
+  const line = before + rest;
+  const endings = ["", " then end", " do end", ")", ") then end", "]"];
+  return endings.map((ending) => source.slice(0, lineStart) + line + ending + source.slice(lineEnd));
+}
 function stringLiterals(type, aliases, seen = /* @__PURE__ */ new Set()) {
   if (!type || seen.has(type)) return [];
   seen.add(type);
@@ -1198,7 +1536,7 @@ function memberOperator(source, wordStart) {
 }
 function memberItems(analysis, access) {
   const object = access.object;
-  const type = analysis.types.typeOf.get(object);
+  const type = withoutNil(analysis.types.typeOf.get(object));
   const colon = access.type === "MethodCallExpression";
   if (isStringLike(type)) {
     if (!colon) return [];
@@ -1208,6 +1546,11 @@ function memberItems(analysis, access) {
   }
   return membersOf(type, analysis.types.aliases).filter((member) => colon ? member.isMethod : true).map((member) => memberItem(member.name, member.property.type, member.property.readonly));
 }
+function withoutNil(type) {
+  if (type?.kind !== "union") return type;
+  const kept = type.types.filter((t) => !(t.kind === "primitive" && t.name === "nil"));
+  return kept.length === 1 ? kept[0] : { ...type, types: kept };
+}
 function isStringLike(type) {
   if (!type) return false;
   switch (type.kind) {
@@ -1228,6 +1571,7 @@ function valueItems(analysis, at) {
   const seen = /* @__PURE__ */ new Set();
   for (const binding of analysis.scopes.bindings.values()) {
     if (binding.name === PLACEHOLDER || seen.has(binding.name)) continue;
+    if (binding.declaredBy === "type") continue;
     const declaration = binding.declarationNode;
     if (declaration && declaration.line.start - 1 > at.line) continue;
     seen.add(binding.name);
@@ -1235,13 +1579,13 @@ function valueItems(analysis, at) {
     items.push({
       label: binding.name,
       kind: kindOf(type, binding.kind),
-      detail: type ? (0, import_luaut_parser5.formatType)(type) : void 0,
+      detail: type ? (0, import_luaut_parser6.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_languageserver4.CompletionItemKind.Keyword, sortText: `3${keyword2}` });
+    items.push({ label: keyword2, kind: import_vscode_languageserver5.CompletionItemKind.Keyword, sortText: `3${keyword2}` });
   }
   return items;
 }
@@ -1250,22 +1594,22 @@ function memberItem(name, type, readonly) {
   if (signatures.length) {
     return {
       label: name,
-      kind: import_vscode_languageserver4.CompletionItemKind.Method,
+      kind: import_vscode_languageserver5.CompletionItemKind.Method,
       detail: signatureLabel(signatures[0]).label,
       insertText: `${name}($0)`,
-      insertTextFormat: import_vscode_languageserver4.InsertTextFormat.Snippet
+      insertTextFormat: import_vscode_languageserver5.InsertTextFormat.Snippet
     };
   }
   return {
     label: name,
-    kind: import_vscode_languageserver4.CompletionItemKind.Field,
-    detail: `${readonly ? "readonly " : ""}${(0, import_luaut_parser5.formatType)(type)}`
+    kind: import_vscode_languageserver5.CompletionItemKind.Field,
+    detail: `${readonly ? "readonly " : ""}${(0, import_luaut_parser6.formatType)(type)}`
   };
 }
 function kindOf(type, bindingKind) {
-  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;
+  if (type && signaturesOf(type).length) return import_vscode_languageserver5.CompletionItemKind.Function;
+  if (bindingKind === "param" || bindingKind === "self") return import_vscode_languageserver5.CompletionItemKind.Variable;
+  return import_vscode_languageserver5.CompletionItemKind.Variable;
 }
 function inTypePosition(path) {
   return path.some(
@@ -1283,6 +1627,17 @@ var PRIMITIVES2 = [
   "thread",
   "buffer"
 ];
+var TYPE_KEYWORDS = ["keyof", "typeof", "infer", "extends"];
+function contextKeywords(before) {
+  const keyword2 = (name) => ({
+    label: name,
+    kind: import_vscode_languageserver5.CompletionItemKind.Keyword,
+    sortText: `3${name}`
+  });
+  if (/<\s*[A-Za-z_]\w*(?:\s*,\s*[A-Za-z_]\w*)*\s+$/.test(before)) return [keyword2("extends")];
+  if (/[)\]}"'`\w][^\S\n]+$/.test(before)) return [keyword2("as"), keyword2("satisfies")];
+  return [];
+}
 var KEYWORDS = [
   "const",
   "let",
@@ -1388,8 +1743,8 @@ function activeArgument(call, position) {
 }
 
 // src/features/symbols.ts
-var import_vscode_languageserver5 = require("vscode-languageserver");
-var import_luaut_parser6 = require("luaut-parser");
+var import_vscode_languageserver6 = require("vscode-languageserver");
+var import_luaut_parser7 = require("luaut-parser");
 function documentSymbols(analysis) {
   const out = [];
   walk(analysis.program, (node) => {
@@ -1397,7 +1752,7 @@ function documentSymbols(analysis) {
       case "FunctionDeclaration":
       case "FunctionDeclarationStatement": {
         const name = functionName(node);
-        if (name) out.push(symbol(name, import_vscode_languageserver5.SymbolKind.Function, node, detailOf(analysis, node)));
+        if (name) out.push(symbol(name, import_vscode_languageserver6.SymbolKind.Function, node, detailOf(analysis, node)));
         break;
       }
       case "TypeAliasStatement":
@@ -1406,20 +1761,20 @@ 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_languageserver5.SymbolKind.Interface, node, alias ? (0, import_luaut_parser6.formatType)(alias) : void 0));
+          out.push(symbol(name, import_vscode_languageserver6.SymbolKind.Interface, node, alias ? (0, import_luaut_parser7.formatType)(alias) : void 0));
         }
         break;
       }
       case "DeclareClassStatement": {
         const name = node.name.name;
         const superclass = node.superclass?.base;
-        out.push(symbol(name, import_vscode_languageserver5.SymbolKind.Class, node, superclass && `extends ${superclass}`));
+        out.push(symbol(name, import_vscode_languageserver6.SymbolKind.Class, node, superclass && `extends ${superclass}`));
         break;
       }
       case "VariableDeclaration": {
         for (const target of node.names ?? []) {
           const name = target.name;
-          if (name) out.push(symbol(name, import_vscode_languageserver5.SymbolKind.Variable, target));
+          if (name) out.push(symbol(name, import_vscode_languageserver6.SymbolKind.Variable, target));
         }
         break;
       }
@@ -1443,7 +1798,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_parser6.formatType)(type);
+    if (type) return (0, import_luaut_parser7.formatType)(type);
   }
   return void 0;
 }
@@ -1453,7 +1808,7 @@ function symbol(name, kind, node, detail) {
 }
 
 // src/features/semanticTokens.ts
-var import_luaut_parser7 = require("luaut-parser");
+var import_luaut_parser8 = require("luaut-parser");
 var TOKEN_TYPES = [
   "namespace",
   "type",
@@ -1497,7 +1852,7 @@ function semanticTokens(analysis) {
   };
   let tokens = [];
   try {
-    tokens = (0, import_luaut_parser7.tokenize)(analysis.source);
+    tokens = (0, import_luaut_parser8.tokenize)(analysis.source);
   } catch {
   }
   const identifiers = tokens.filter((t) => t.type === "Identifier");
@@ -1541,7 +1896,7 @@ function classify(analysis, spanned, ancestors, identifiers, add) {
       if (!baseToken) return;
       if (!namespace && typeParameterInScope2(ancestors, base)) {
         add(baseToken, base.length, "typeParameter");
-      } else if ((0, import_luaut_parser7.isClassType)(analysis.types.aliases.get(namespace ? `${namespace}.${base}` : base) ?? import_luaut_parser7.unknownType)) {
+      } else if ((0, import_luaut_parser8.isClassType)(analysis.types.aliases.get(namespace ? `${namespace}.${base}` : base) ?? import_luaut_parser8.unknownType)) {
         add(baseToken, base.length, "class");
       } else {
         add(baseToken, base.length, "type", PRIMITIVES3.has(base) ? ["defaultLibrary"] : []);
@@ -1596,10 +1951,14 @@ function identifier(analysis, node, parent, add) {
       break;
     case "ImportSpecifier": {
       const binding2 = bindingOfNode(analysis, node);
+      if (binding2?.declaredBy === "type") return as("type", ["declaration"]);
       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 "ImportStatement":
+      if (parent.namespaceImport === node) return as("namespace", ["declaration"]);
+      break;
     case "ExportSpecifier":
       if (!bindingOfNode(analysis, node) && analysis.types.aliases.has(name)) return as("type");
       break;
@@ -1615,6 +1974,7 @@ function identifier(analysis, node, parent, add) {
 function valueKind(analysis, binding) {
   if (!binding) return "variable";
   if (binding.kind === "param" || binding.kind === "self") return "parameter";
+  if (binding.declaredBy === "namespace") return "namespace";
   return isFunction(analysis.types.bindingType.get(binding.id)) ? "function" : "variable";
 }
 function modifiersOf(binding, isDeclaration) {