luaut-language-server 2.1.0 → 3.1.0

package/README.md

@@ -16,13 +16,13 @@ luaut-language-server --stdio
 
 | request | notes |
 |---|---|
-| `publishDiagnostics` | syntax, scope (redeclare, assign-to-`const`) and type errors, on open and on every keystroke |
+| `publishDiagnostics` | syntax, scope (redeclare, assign-to-`const`) and type errors, on open and on every keystroke. A name nothing declares is an error ("Cannot find name 'x'") whenever type libraries are loaded. `--@luaut-nocheck`, `--@luaut-ignore` and `--@luaut-expect-error` silence scope and type errors |
 | `hover` | the type as luaut writes it — the **narrowed** type at a reference, so a guarded `v` reads `string`, not `string \| nil`. Also every name in a type or definitions file: `declare` names (with their overload count), classes (`declare class Part extends BasePart { ...what it adds }`), alias names, object-type properties, type parameters, `infer` names, and any type annotation, which reads as what it resolves to |
 | `semanticTokens` | colours from the parser, not from patterns — see [Highlighting](#highlighting) |
 | `definition` | the binding's declaration — and from an `import`, the export in the other module |
 | `references`, `documentHighlight` | every use of the binding |
 | `rename`, `prepareRename` | refuses names that are not identifiers, and builtins from the definitions files |
-| `completion` | members after `.` / `:` (never the globals there), names in scope, type names in a type position; inside an `import`, module paths and the exported names |
+| `completion` | members after `.` / `:` (never the globals there), names in scope, type names in a type position; inside an `import`, module paths and the exported names. Inside an object literal written against a type — an annotation, `satisfies`, an argument — the keys that type names, minus the ones already there. A name another file of the project exports is offered too, and picking it adds `import { name } from "./path"` at the top (or joins the import of that file already there). With the Roblox types, each service is offered, and picking one adds `const Players = game:GetService("Players")` under the imports and the services already declared |
 | `signatureHelp` | every overload, with the active parameter — `:` calls count `self` for you |
 | `documentSymbol` | functions, type aliases, top-level bindings |
 

package/dist/{chunk-HJ2C3OFZ.js → chunk-SCZTSX3Y.js}

@@ -1,5 +1,18 @@
 // src/features/members.ts
 import { formatType } from "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);
@@ -9,6 +22,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": {
@@ -343,11 +361,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 } = parseWithRecovery(source);
-    const scopes = analyzeScopes(program, { builtinGlobals: [...globals] });
+    const { program, errors, directives } = parseWithRecovery(source);
+    const reportUndeclared = context.libs.length > 0;
+    const scopes = analyzeScopes(program, { builtinGlobals: [...globals], reportUndeclared });
     const dependencies = new Map(context.reads);
     const types = analyzeTypes(program, scopes, {
       libs,
+      reportUnknownTypes: reportUndeclared,
       resolveModule: (specifier) => {
         if (!path) return void 0;
         const candidates = this.candidatesFor(path, specifier);
@@ -361,7 +381,7 @@ var Analyzer = class {
         return exports;
       }
     });
-    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);
@@ -450,7 +470,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;
@@ -729,6 +749,7 @@ function patternNamed(target, name) {
 
 // src/features/diagnostics.ts
 import { DiagnosticSeverity } from "vscode-languageserver";
+import { applyDirectives, UNUSED_EXPECT_ERROR } from "luaut-parser";
 function diagnostics(analysis) {
   const out = [];
   for (const error of analysis.parseErrors) {
@@ -742,22 +763,32 @@ 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: 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: DiagnosticSeverity.Error,
       source: "luaut",
       code: "type",
       message: d.message
+    }))
+  ];
+  const { kept, unusedExpectErrors } = 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: DiagnosticSeverity.Error,
+      source: "luaut",
+      code: "directive",
+      message: UNUSED_EXPECT_ERROR
     });
   }
   return out;
@@ -771,11 +802,28 @@ import {
 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;
@@ -797,6 +845,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);
@@ -851,7 +920,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);
@@ -859,13 +928,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.
@@ -981,10 +1055,19 @@ ${lines.join("\n")}
   }
   return flat;
 }
+function bindingText(binding, type) {
+  if (binding.declaredBy === "function" && type.kind === "function") {
+    return `function ${binding.name}${formatType3(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) {
@@ -1054,10 +1137,164 @@ function isIdentifier(name) {
 
 // src/features/completion.ts
 import {
-  CompletionItemKind as CompletionItemKind2,
+  CompletionItemKind as CompletionItemKind3,
   InsertTextFormat
 } from "vscode-languageserver";
 import { formatType as formatType4, isClassType as isClassType2 } from "luaut-parser";
+
+// src/features/autoImport.ts
+import { readdirSync as readdirSync2 } from "fs";
+import { dirname as dirname3, join, relative, resolve as resolve3 } from "path";
+import { CompletionItemKind as CompletionItemKind2 } from "vscode-languageserver";
+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 ?? dirname3(from))) {
+    if (samePath(file, from)) continue;
+    const exports = analyzer.exportsAt(file);
+    if (!exports || exports.partial) continue;
+    const names = typePosition ? [...exports.types.keys()] : [...exports.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 ? exports.types.get(name)?.type : exports.values.get(name);
+      items.push({
+        label: name,
+        kind: typePosition ? CompletionItemKind2.Interface : type && signaturesOf(type).length ? CompletionItemKind2.Function : CompletionItemKind2.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: CompletionItemKind2.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(relative(dirname3(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 = resolve3(config.baseUrl, targetPattern.slice(0, cut));
+      const rest = relative(head, target);
+      if (rest.startsWith("..") || resolve3(head, rest) !== resolve3(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 = readdirSync2(directory, { withFileTypes: true });
+    } catch {
+      return;
+    }
+    for (const entry of entries) {
+      if (entry.name.startsWith(".") || entry.name === "node_modules") continue;
+      const path = 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) {
@@ -1090,28 +1327,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: isClassType2(type) ? CompletionItemKind2.Class : CompletionItemKind2.Interface,
+      kind: isClassType2(type) ? CompletionItemKind3.Class : CompletionItemKind3.Interface,
       detail: isClassType2(type) ? "class" : "type"
     }));
     const primitives = PRIMITIVES2.map((name) => ({
       label: name,
-      kind: CompletionItemKind2.Keyword,
+      kind: CompletionItemKind3.Keyword,
       detail: "type"
     }));
-    return [...named, ...primitives];
-  }
-  return valueItems(first.analysis, at);
+    const keywords = TYPE_KEYWORDS.map((name) => ({
+      label: name,
+      kind: CompletionItemKind3.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 ? {
@@ -1120,10 +1387,81 @@ function stringCompletion(analyzer, document, position) {
   } : void 0;
   return values.map((value) => ({
     label: value,
-    kind: CompletionItemKind2.Constant,
+    kind: CompletionItemKind3.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: CompletionItemKind3.Field,
+    detail: `${member.property.optional ? "?" : ""}: ${formatType4(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);
@@ -1155,7 +1493,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 [];
@@ -1165,6 +1503,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) {
@@ -1185,6 +1528,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);
@@ -1198,7 +1542,7 @@ function valueItems(analysis, at) {
     });
   }
   for (const keyword2 of KEYWORDS) {
-    items.push({ label: keyword2, kind: CompletionItemKind2.Keyword, sortText: `3${keyword2}` });
+    items.push({ label: keyword2, kind: CompletionItemKind3.Keyword, sortText: `3${keyword2}` });
   }
   return items;
 }
@@ -1207,7 +1551,7 @@ function memberItem(name, type, readonly) {
   if (signatures.length) {
     return {
       label: name,
-      kind: CompletionItemKind2.Method,
+      kind: CompletionItemKind3.Method,
       detail: signatureLabel(signatures[0]).label,
       insertText: `${name}($0)`,
       insertTextFormat: InsertTextFormat.Snippet
@@ -1215,14 +1559,14 @@ function memberItem(name, type, readonly) {
   }
   return {
     label: name,
-    kind: CompletionItemKind2.Field,
+    kind: CompletionItemKind3.Field,
     detail: `${readonly ? "readonly " : ""}${formatType4(type)}`
   };
 }
 function kindOf(type, bindingKind) {
-  if (type && signaturesOf(type).length) return CompletionItemKind2.Function;
-  if (bindingKind === "param" || bindingKind === "self") return CompletionItemKind2.Variable;
-  return CompletionItemKind2.Variable;
+  if (type && signaturesOf(type).length) return CompletionItemKind3.Function;
+  if (bindingKind === "param" || bindingKind === "self") return CompletionItemKind3.Variable;
+  return CompletionItemKind3.Variable;
 }
 function inTypePosition(path) {
   return path.some(
@@ -1240,6 +1584,17 @@ var PRIMITIVES2 = [
   "thread",
   "buffer"
 ];
+var TYPE_KEYWORDS = ["keyof", "typeof", "infer", "extends"];
+function contextKeywords(before) {
+  const keyword2 = (name) => ({
+    label: name,
+    kind: CompletionItemKind3.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",
@@ -1553,10 +1908,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;
@@ -1572,6 +1931,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) {
@@ -1842,4 +2202,4 @@ export {
   createServer,
   startServer
 };
-//# sourceMappingURL=chunk-HJ2C3OFZ.js.map
+//# sourceMappingURL=chunk-SCZTSX3Y.js.map