luaut-language-server 3.0.0 → 4.0.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-X2GHHRWT.js → chunk-XK3KS3T4.js}

@@ -1,5 +1,18 @@
 // src/features/members.ts
-import { formatType } from "luaut-parser";
+import { formatType, substitute, union } 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": {
@@ -30,6 +48,20 @@ function membersOf(type, aliases, seen = /* @__PURE__ */ new Set()) {
     }
     case "typeParam":
       return membersOf(type.constraint, aliases, seen);
+    // An array and a string answer to the methods the language gives them
+    // — `names:filter(f)`, `text:trim()`. They are written in the parser's
+    // prelude as `ArrayMethods<T>` and `StringMethods`, so the element
+    // type goes in where `T` stands.
+    case "array":
+    case "tuple": {
+      const element = type.kind === "array" ? type.element : union(type.elements);
+      const methods = aliases.get("ArrayMethods");
+      return methods ? membersOf(substitute(methods, /* @__PURE__ */ new Map([["T", element]])), aliases, seen) : [];
+    }
+    case "primitive":
+      return type.name === "string" ? membersOf(aliases.get("StringMethods"), aliases, seen) : [];
+    case "literal":
+      return type.base === "string" ? membersOf(aliases.get("StringMethods"), aliases, seen) : [];
     default:
       return [];
   }
@@ -343,11 +375,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 +395,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 +484,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 +763,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 +777,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;
@@ -814,6 +859,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);
@@ -876,6 +942,11 @@ function describe(analysis, path, index) {
       }
       return void 0;
     }
+    // `...` — 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":
@@ -1080,10 +1151,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) {
@@ -1116,28 +1341,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 ? {
@@ -1146,10 +1401,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);
@@ -1181,27 +1507,29 @@ 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 [];
-    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));
-  }
+  if (isMethodOnly(type) && !colon) return [];
   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) {
+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 isMethodOnly(type) {
   if (!type) return false;
   switch (type.kind) {
+    case "array":
+    case "tuple":
+    case "templateLiteral":
+      return true;
     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);
+      return type.types.length > 0 && type.types.every(isMethodOnly);
     default:
       return false;
   }
@@ -1225,7 +1553,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;
 }
@@ -1234,7 +1562,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
@@ -1242,14 +1570,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(
@@ -1267,6 +1595,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",
@@ -1766,7 +2105,7 @@ function createServer(connection, options = {}) {
       severity: DiagnosticSeverity2.Information,
       source: "luaut",
       code: "no-config",
-      message: 'No luaut.config.json applies to this file, so no types are loaded \u2014 not even `print`. Add one to this folder or a folder above, such as { "types": ["luau"], "paths": {}, "sourceMap": null }'
+      message: 'No luaut.config.json applies to this file, so no types are loaded \u2014 not even `print`. Add one to this folder or a folder above: { "types": [], "paths": {}, "sourceMap": null }, listing in `types` the type libraries the project has installed.'
     }];
   };
   documents.onDidOpen(publishAll);
@@ -1874,4 +2213,4 @@ export {
   createServer,
   startServer
 };
-//# sourceMappingURL=chunk-X2GHHRWT.js.map
+//# sourceMappingURL=chunk-XK3KS3T4.js.map