luaut-language-server 3.1.0 → 5.0.0

package/dist/cli.cjs

@@ -61,13 +61,28 @@ 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 : (0, import_luaut_parser.union)(type.elements);
+      const methods = aliases.get("ArrayMethods");
+      return methods ? membersOf((0, import_luaut_parser.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 [];
   }
 }
 function takesSelf(type) {
   for (const signature of signaturesOf(type)) {
-    if (signature.params[0]?.name === "self") return true;
+    const first = signature.params[0]?.name;
+    if (first === "self" || first === "this") return true;
   }
   return false;
 }
@@ -88,7 +103,7 @@ function signatureLabel(signature) {
   });
   const generics = signature.typeParams?.length ? `<${signature.typeParams.join(", ")}>` : "";
   const varargs = signature.varargs ? [`...: ${(0, import_luaut_parser.formatType)(signature.varargs)}`] : [];
-  const label = `${generics}(${[...parameters, ...varargs].join(", ")}) -> ${(0, import_luaut_parser.formatType)(signature.returns)}`;
+  const label = `${generics}(${[...parameters, ...varargs].join(", ")}) => ${(0, import_luaut_parser.formatType)(signature.returns)}`;
   return { label, parameters };
 }
 
@@ -668,7 +683,7 @@ function exportDeclaration(analyzer, module2, name, seen = /* @__PURE__ */ new S
         break;
       case "ExportStatement": {
         const declaration = statement.declaration;
-        if (declaration.type === "FunctionDeclaration") {
+        if (declaration.type === "FunctionDeclaration" || declaration.type === "ClassDeclaration") {
           if (declaration.name.name === name) return here(declaration.name);
         } else {
           for (const target of declaration.names) {
@@ -780,16 +795,100 @@ function diagnostics(analysis) {
 }
 
 // src/features/hover.ts
+var import_luaut_parser6 = require("luaut-parser");
+
+// src/features/expand.ts
 var import_luaut_parser5 = require("luaut-parser");
-function hover(analysis, position) {
+function expandAliases(type, aliases, depth, seen = []) {
+  if (depth <= 0) return type;
+  const name = withheldName(type);
+  if (name !== void 0 && !seen.includes(name)) {
+    const opened = aliases.get(name) ?? type;
+    const inner = [...seen, name];
+    return children2(unnamed(opened), (t) => expandAliases(t, aliases, depth - 1, inner));
+  }
+  return children2(type, (t) => expandAliases(t, aliases, depth, seen));
+}
+function withheldName(type) {
+  if ((0, import_luaut_parser5.isClassType)(type)) return void 0;
+  if (type.kind === "object" || type.kind === "intersection") return type.name;
+  if (type.kind === "genericRef") return type.typeArguments.length ? void 0 : type.name;
+  return void 0;
+}
+function unnamed(type) {
+  if (type.kind === "object") {
+    const out = (0, import_luaut_parser5.objectType)(type.properties, type.indexer, type.frozen);
+    return type.class ? Object.assign(out, { class: type.class, name: type.name }) : out;
+  }
+  if (type.kind === "intersection" && type.name) return { ...type, name: void 0 };
+  return type;
+}
+function children2(type, f) {
+  switch (type.kind) {
+    case "array":
+      return (0, import_luaut_parser5.arrayOf)(f(type.element));
+    case "tuple":
+      return (0, import_luaut_parser5.tuple)(type.elements.map(f), type.isPack);
+    case "union":
+      return (0, import_luaut_parser5.union)(type.types.map(f));
+    case "intersection": {
+      const out = (0, import_luaut_parser5.intersection)(type.types.map(f));
+      return type.name && out.kind === "intersection" ? { ...out, name: type.name } : out;
+    }
+    case "object": {
+      if ((0, import_luaut_parser5.isClassType)(type)) return type;
+      const out = (0, import_luaut_parser5.objectType)(
+        [...type.properties].map(([name, property]) => [name, { ...property, type: f(property.type) }]),
+        type.indexer && { key: type.indexer.key, value: f(type.indexer.value) },
+        type.frozen
+      );
+      if (type.name) out.name = type.name;
+      return out;
+    }
+    case "function":
+      return (0, import_luaut_parser5.fn)(
+        type.params.map((p) => ({ ...p, type: f(p.type) })),
+        f(type.returns),
+        type.varargs && f(type.varargs),
+        type.typeParams,
+        type.predicate
+      );
+    default:
+      return type;
+  }
+}
+
+// src/features/hover.ts
+function hover(analysis, position, depth = 0) {
   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]) };
+    const text = at(analysis, path, i, depth);
+    if (!text) continue;
+    const canExpand = at(analysis, path, i, depth + 1) !== text;
+    return {
+      contents: { kind: "markdown", value: code(text) },
+      range: toRange(path[i]),
+      depth,
+      canExpand
+    };
   }
   return null;
 }
+function at(analysis, path, index, depth) {
+  const previous = expansion;
+  expansion = { depth, aliases: analysis.types.aliases, source: analysis.source };
+  try {
+    return describe(analysis, path, index);
+  } finally {
+    expansion = previous;
+  }
+}
+var expansion = {
+  depth: 0,
+  aliases: /* @__PURE__ */ new Map(),
+  source: ""
+};
 var UNNAMED = /* @__PURE__ */ new Set([
   "BinaryExpression",
   "UnaryExpression",
@@ -822,8 +921,8 @@ function describe(analysis, path, index) {
         case "TableExpression": {
           const field = fieldWithKey(parent, node);
           if (!field) break;
-          const objectType = types.typeOf.get(parent);
-          const property = objectType?.kind === "object" ? objectType.properties.get(name) : void 0;
+          const objectType2 = types.typeOf.get(parent);
+          const property = objectType2?.kind === "object" ? objectType2.properties.get(name) : void 0;
           const type2 = property?.type ?? types.typeOf.get(field.value);
           return type2 && `(property) ${name}: ${pretty(type2)}`;
         }
@@ -871,6 +970,19 @@ function describe(analysis, path, index) {
         case "DeclareClassStatement":
           if (parent.name === node) return classText(analysis, name);
           break;
+        case "ClassDeclaration":
+          if (parent.name === node) return classText(analysis, name);
+          break;
+        case "ClassField":
+          if (parent.name === node) {
+            const type2 = typeOfNode(parent.typeAnnotation) ?? types.typeOf.get(parent.init);
+            const prefix = parent.isStatic ? "(static) " : "(field) ";
+            return type2 ? `${prefix}${name}: ${pretty(type2)}` : `${prefix}${name}`;
+          }
+          break;
+        case "ClassAccessor":
+          if (parent.name === node) return `(${parent.kind === "get" ? "getter" : "setter"}) ${name}`;
+          break;
         case "TableTypeProperty":
           if (parent.key === node) {
             const type2 = typeOfNode(parent.valueType);
@@ -893,7 +1005,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_parser5.formatType)(keys)}` : ""}`;
+            return `(type parameter) ${name}${keys ? ` in ${(0, import_luaut_parser6.formatType)(keys)}` : ""}`;
           }
           break;
       }
@@ -921,7 +1033,7 @@ function describe(analysis, path, index) {
     case "TypedIdentifier": {
       const binding = bindingOfNode(analysis, node);
       const type2 = binding && types.bindingType.get(binding.id);
-      return type2 ? bindingText(binding, type2) : void 0;
+      return type2 ? bindingText(binding, type2, asWritten(node.typeAnnotation)) : void 0;
     }
     // A type written by name: `number`, `Shape`, `Partial<User>`, or a type
     // parameter in scope.
@@ -935,7 +1047,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_parser5.isClassType)(alias)) return classText(analysis, qualified);
+        if (alias && (0, import_luaut_parser6.isClassType)(alias)) return classText(analysis, qualified);
         if (alias) return `type ${qualified} = ${pretty(alias)}`;
       }
       const type2 = typeOfNode(node);
@@ -963,20 +1075,29 @@ 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_parser5.formatType)(own)}${overloads}`;
+  return `declare function ${name}${(0, import_luaut_parser6.formatType)(own)}${overloads}`;
 }
 function classText(analysis, name) {
   const type = analysis.types.aliases.get(name);
-  if (!type || !(0, import_luaut_parser5.isClassType)(type)) return void 0;
+  if (!type || !(0, import_luaut_parser6.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_parser5.formatType)(property.type)},`);
-  return `${head} {
+  const own = [...type.properties].filter(([key, property]) => (
+    // `ClassObject` is on every instance and says nothing about this one.
+    key !== "ClassObject" && (inherited?.kind !== "object" || inherited.properties.get(key) !== property)
+  ));
+  const written = isRuntimeClass(analysis, name);
+  const head = `${written ? "" : "declare "}class ${name}${superclass ? ` extends ${superclass}` : ""}`;
+  const lines = own.map(([key, property]) => `    ${property.readonly ? "readonly " : ""}${key}${property.optional ? "?" : ""}: ${(0, import_luaut_parser6.formatType)(property.type)}${written ? "" : ","}`);
+  return own.length ? `${head} {
 ${lines.join("\n")}
-}`;
+}` : `${head} {}`;
+}
+function isRuntimeClass(analysis, name) {
+  return analysis.program.body.statements.some((statement) => {
+    const declaration = statement.type === "ExportStatement" ? statement.declaration : statement;
+    return declaration.type === "ClassDeclaration" && declaration.name.name === name;
+  });
 }
 function typeParameterText(analysis, parameter) {
   return `(type parameter) ${typeParameterSignature(analysis, parameter)}`;
@@ -985,7 +1106,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_parser5.formatType)(constraint)}` : ""}`;
+  return `${p.isConst ? "const " : ""}${p.name}${constraint ? ` extends ${(0, import_luaut_parser6.formatType)(constraint)}` : ""}`;
 }
 function typeParameterInScope(path, index, name) {
   for (let i = index - 1; i >= 0; i--) {
@@ -1010,7 +1131,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_parser5.formatType)(t) : "?";
+    return t ? (0, import_luaut_parser6.formatType)(t) : "?";
   });
   return `${name}<${resolved.join(", ")}>`;
 }
@@ -1018,30 +1139,50 @@ function fieldWithKey(table, key) {
   const fields = table.fields;
   return fields.find((f) => f.type === "TableFieldNamed" && f.key === key);
 }
-function pretty(type) {
-  const flat = (0, import_luaut_parser5.formatType)(type);
+function pretty(type, written) {
+  const named = render(expandAliases(type, expansion.aliases, 0));
+  const shorthand = written !== void 0 && written !== named ? written : void 0;
+  const depth = shorthand === void 0 ? expansion.depth : expansion.depth - 1;
+  if (depth < 0) return shorthand;
+  return depth === 0 ? named : render(expandAliases(type, expansion.aliases, depth));
+}
+function asWritten(node) {
+  if (!isSpanned(node) || !expansion.source) return void 0;
+  const lines = expansion.source.split(/\r?\n/);
+  const { line, column } = node;
+  if (line.start < 1 || line.end > lines.length) return void 0;
+  const text = line.start === line.end ? lines[line.start - 1].slice(column.start - 1, column.end - 1) : [
+    lines[line.start - 1].slice(column.start - 1),
+    ...lines.slice(line.start, line.end - 1),
+    lines[line.end - 1].slice(0, column.end - 1)
+  ].join(" ");
+  const folded = text.trim().replace(/\s+/g, " ");
+  return folded.length ? folded : void 0;
+}
+function render(type) {
+  const flat = (0, import_luaut_parser6.formatType)(type);
   if (flat.length <= 80) return flat;
   if (type.kind === "object") {
     const lines = [];
-    if (type.indexer) lines.push(`    [${(0, import_luaut_parser5.formatType)(type.indexer.key)}]: ${(0, import_luaut_parser5.formatType)(type.indexer.value)},`);
+    if (type.indexer) lines.push(`    [${(0, import_luaut_parser6.formatType)(type.indexer.key)}]: ${(0, import_luaut_parser6.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_parser5.formatType)(property.type)},`);
+      lines.push(`    ${readonly}${name}${property.optional ? "?" : ""}: ${(0, import_luaut_parser6.formatType)(property.type)},`);
     }
     return `{
 ${lines.join("\n")}
 }`;
   }
   if (type.kind === "intersection" && type.types.every((t) => t.kind === "function")) {
-    return type.types.map(import_luaut_parser5.formatType).join("\n& ");
+    return type.types.map(import_luaut_parser6.formatType).join("\n& ");
   }
   return flat;
 }
-function bindingText(binding, type) {
+function bindingText(binding, type, written) {
   if (binding.declaredBy === "function" && type.kind === "function") {
-    return `function ${binding.name}${(0, import_luaut_parser5.formatType)(type)}`;
+    return `function ${binding.name}${pretty(type)}`;
   }
-  return `${keyword(binding)} ${binding.name}: ${pretty(type)}`;
+  return `${keyword(binding)} ${binding.name}: ${pretty(type, written)}`;
 }
 function keyword(binding) {
   if (binding.kind === "param" || binding.kind === "self") return "(parameter)";
@@ -1117,7 +1258,7 @@ function isIdentifier(name) {
 
 // src/features/completion.ts
 var import_vscode_languageserver5 = require("vscode-languageserver");
-var import_luaut_parser6 = require("luaut-parser");
+var import_luaut_parser7 = require("luaut-parser");
 
 // src/features/autoImport.ts
 var import_node_fs3 = require("fs");
@@ -1154,7 +1295,7 @@ function importItems(analyzer, analysis, typePosition, taken) {
 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 at2 = serviceInsertion(analysis.program.body.statements);
   const items = [];
   for (const name of services.properties.keys()) {
     if (taken.has(name)) continue;
@@ -1165,8 +1306,8 @@ function serviceItems(analysis, taken) {
       labelDetails: { description: "service" },
       detail: line,
       sortText: `5${name}`,
-      additionalTextEdits: [{ range: { start: at.position, end: at.position }, newText: `${line}
-${at.gap}` }]
+      additionalTextEdits: [{ range: { start: at2.position, end: at2.position }, newText: `${line}
+${at2.gap}` }]
     });
   }
   return items;
@@ -1178,24 +1319,24 @@ function importEdit(analyzer, analysis, file, name, specifier, typePosition) {
   if (existing) {
     const last = existing.specifiers[existing.specifiers.length - 1];
     if (last) {
-      const at2 = endOf(last);
-      return { range: { start: at2, end: at2 }, newText: `, ${name}` };
+      const at3 = endOf(last);
+      return { range: { start: at3, end: at3 }, newText: `, ${name}` };
     }
     if (existing.defaultImport) {
-      const at2 = endOf(existing.defaultImport);
-      return { range: { start: at2, end: at2 }, newText: `, { ${name} }` };
+      const at3 = endOf(existing.defaultImport);
+      return { range: { start: at3, end: at3 }, 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 at3 = { line: lastImport.line.end, character: 0 };
+    return { range: { start: at3, end: at3 }, 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}
+  const at2 = { line: first ? first.line.start - 1 : 0, character: 0 };
+  return { range: { start: at2, end: at2 }, newText: first ? `${line}
 
 ` : `${line}
 ` };
@@ -1288,12 +1429,12 @@ function completion(analyzer, document, position) {
   const operator = memberOperator(source, start);
   const alreadyCalled = /^\s*\(/.test(source.slice(end));
   const standIns = operator === ":" ? [alreadyCalled ? PLACEHOLDER : `${PLACEHOLDER}()`] : operator === "." && !alreadyCalled ? [PLACEHOLDER, `${PLACEHOLDER}()`] : [PLACEHOLDER];
-  const at = { line: position.line, character: position.character - (offset - start) };
+  const at2 = { line: position.line, character: position.character - (offset - start) };
   let first;
   for (const standIn of standIns) {
     const patched = source.slice(0, start) + standIn + source.slice(end);
     const analysis = analyzer.analyze(document.uri, -1, patched);
-    const path = pathAt(analysis.program, at, true);
+    const path = pathAt(analysis.program, at2, true);
     const index = path.findLastIndex(
       (n) => n.type === "Identifier" && n.name === PLACEHOLDER
     );
@@ -1309,8 +1450,8 @@ function completion(analyzer, document, position) {
   if (inTypePosition(first.path)) {
     const named = [...first.analysis.types.aliases].map(([name, type]) => ({
       label: name,
-      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"
+      kind: (0, import_luaut_parser7.isClassType)(type) ? import_vscode_languageserver5.CompletionItemKind.Class : import_vscode_languageserver5.CompletionItemKind.Interface,
+      detail: (0, import_luaut_parser7.isClassType)(type) ? "class" : "type"
     }));
     const primitives = PRIMITIVES2.map((name) => ({
       label: name,
@@ -1330,7 +1471,7 @@ function completion(analyzer, document, position) {
   for (const binding of first.analysis.scopes.bindings.values()) taken.add(binding.name);
   const current = analyzer.get(document);
   return [
-    ...valueItems(first.analysis, at),
+    ...valueItems(first.analysis, at2, insideFunction(first.path)),
     ...contextKeywords(source.slice(0, start)),
     ...importItems(analyzer, current, false, taken),
     ...serviceItems(current, taken)
@@ -1398,14 +1539,14 @@ function objectKeyItems(analysis, path, 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)}`,
+    detail: `${member.property.optional ? "?" : ""}: ${(0, import_luaut_parser7.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;
+  const at2 = path.indexOf(literal);
+  const parent = at2 > 0 ? path[at2 - 1] : void 0;
   if (!parent) return [];
   let indexed;
   if (parent.type === "IndexedAccessTypeNode" && parent.indexType === literal) {
@@ -1472,12 +1613,7 @@ function memberItems(analysis, access) {
   const object = access.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 withoutNil(type) {
@@ -1485,35 +1621,41 @@ function withoutNil(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) {
+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;
   }
 }
-function valueItems(analysis, at) {
+function insideFunction(path) {
+  return path.some((n) => n.type === "FunctionExpression" || n.type === "FunctionDeclaration" || n.type === "FunctionDeclarationStatement" || n.type === "FunctionBody");
+}
+function valueItems(analysis, at2, inFunction) {
   const items = [];
   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;
+    const later = declaration !== void 0 && declaration.line.start - 1 > at2.line;
+    if (later && !inFunction && binding.declaredBy !== "function") continue;
     seen.add(binding.name);
     const type = analysis.types.bindingType.get(binding.id);
     items.push({
       label: binding.name,
       kind: kindOf(type, binding.kind),
-      detail: type ? (0, import_luaut_parser6.formatType)(type) : void 0,
+      detail: type ? (0, import_luaut_parser7.formatType)(type) : void 0,
       // Locals before globals, and globals before library names.
       sortText: `${binding.isBuiltin ? 2 : binding.kind === "global" ? 1 : 0}${binding.name}`
     });
@@ -1537,7 +1679,7 @@ function memberItem(name, type, readonly) {
   return {
     label: name,
     kind: import_vscode_languageserver5.CompletionItemKind.Field,
-    detail: `${readonly ? "readonly " : ""}${(0, import_luaut_parser6.formatType)(type)}`
+    detail: `${readonly ? "readonly " : ""}${(0, import_luaut_parser7.formatType)(type)}`
   };
 }
 function kindOf(type, bindingKind) {
@@ -1645,9 +1787,9 @@ function helpAt(analysis, position) {
 function methodType(analysis, call) {
   const object = call.object;
   const method = call.method;
-  const objectType = analysis.types.typeOf.get(object);
-  if (!objectType) return void 0;
-  return memberType(objectType, method.name, analysis);
+  const objectType2 = analysis.types.typeOf.get(object);
+  if (!objectType2) return void 0;
+  return memberType(objectType2, method.name, analysis);
 }
 function memberType(type, name, analysis) {
   if (type.kind === "object") return type.properties.get(name)?.type;
@@ -1678,7 +1820,7 @@ function activeArgument(call, position) {
 
 // src/features/symbols.ts
 var import_vscode_languageserver6 = require("vscode-languageserver");
-var import_luaut_parser7 = require("luaut-parser");
+var import_luaut_parser8 = require("luaut-parser");
 function documentSymbols(analysis) {
   const out = [];
   walk(analysis.program, (node) => {
@@ -1695,10 +1837,19 @@ 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_languageserver6.SymbolKind.Interface, node, alias ? (0, import_luaut_parser7.formatType)(alias) : void 0));
+          out.push(symbol(name, import_vscode_languageserver6.SymbolKind.Interface, node, alias ? (0, import_luaut_parser8.formatType)(alias) : void 0));
         }
         break;
       }
+      case "ClassDeclaration": {
+        const declaration = node;
+        const superclass = declaration.superclass?.name;
+        out.push({
+          ...symbol(declaration.name.name, import_vscode_languageserver6.SymbolKind.Class, node, superclass && `extends ${superclass}`),
+          children: declaration.members.map((member) => classMember(analysis, member))
+        });
+        break;
+      }
       case "DeclareClassStatement": {
         const name = node.name.name;
         const superclass = node.superclass?.base;
@@ -1716,6 +1867,23 @@ function documentSymbols(analysis) {
   });
   return out;
 }
+function classMember(analysis, member) {
+  switch (member.type) {
+    case "ClassConstructor":
+      return symbol("constructor", import_vscode_languageserver6.SymbolKind.Constructor, member);
+    case "ClassField":
+      return symbol(
+        member.name.name,
+        member.isStatic ? import_vscode_languageserver6.SymbolKind.Constant : import_vscode_languageserver6.SymbolKind.Field,
+        member,
+        member.typeAnnotation ? void 0 : detailOf(analysis, member)
+      );
+    case "ClassAccessor":
+      return symbol(member.name.name, import_vscode_languageserver6.SymbolKind.Property, member, member.kind);
+    case "ClassMethod":
+      return symbol(member.name.name, import_vscode_languageserver6.SymbolKind.Method, member, member.isStatic ? "static" : void 0);
+  }
+}
 function functionName(node) {
   const named = node;
   if (typeof named.name === "string") return named.name;
@@ -1732,7 +1900,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_parser7.formatType)(type);
+    if (type) return (0, import_luaut_parser8.formatType)(type);
   }
   return void 0;
 }
@@ -1742,7 +1910,7 @@ function symbol(name, kind, node, detail) {
 }
 
 // src/features/semanticTokens.ts
-var import_luaut_parser8 = require("luaut-parser");
+var import_luaut_parser9 = require("luaut-parser");
 var TOKEN_TYPES = [
   "namespace",
   "type",
@@ -1772,21 +1940,23 @@ var SOFT_KEYWORDS = /* @__PURE__ */ new Set([
   "asserts",
   "satisfies",
   "typeof",
-  "default"
+  "default",
+  "new",
+  "super"
 ]);
 var CONTROL_KEYWORDS = /* @__PURE__ */ new Set(["default"]);
 var PRIMITIVES3 = /* @__PURE__ */ new Set(["any", "unknown", "never", "nil", "boolean", "number", "string", "thread", "buffer"]);
 function semanticTokens(analysis) {
   const entries = /* @__PURE__ */ new Map();
-  const add = (at, length, type, modifiers = []) => {
-    const line = at.line.start - 1;
-    const character = at.column.start - 1;
+  const add = (at2, length, type, modifiers = []) => {
+    const line = at2.line.start - 1;
+    const character = at2.column.start - 1;
     const key = `${line}:${character}`;
     if (!entries.has(key)) entries.set(key, { line, character, length, type, modifiers });
   };
   let tokens = [];
   try {
-    tokens = (0, import_luaut_parser8.tokenize)(analysis.source);
+    tokens = (0, import_luaut_parser9.tokenize)(analysis.source);
   } catch {
   }
   const identifiers = tokens.filter((t) => t.type === "Identifier");
@@ -1821,6 +1991,25 @@ function classify(analysis, spanned, ancestors, identifiers, add) {
       add(node, name.length, valueKind(analysis, binding), modifiersOf(binding, true));
       return;
     }
+    // A class body's own words. `get`, `set`, `static` and `constructor`
+    // are ordinary names anywhere else, so they are coloured from the
+    // member they open rather than wherever they are written.
+    case "ClassMethod":
+    case "ClassField":
+    case "ClassAccessor":
+    case "ClassConstructor": {
+      const opener = node.type === "ClassConstructor" ? "constructor" : node.type === "ClassAccessor" ? node.kind : void 0;
+      const words = firstTokensWithin(identifiers, node, 2);
+      let index = 0;
+      if (node.isStatic === true && words[index] && wordOf(words[index]) === "static") {
+        add(words[index], "static".length, "keyword");
+        index++;
+      }
+      if (opener && words[index] && wordOf(words[index]) === opener) {
+        add(words[index], opener.length, "keyword");
+      }
+      return;
+    }
     case "TypeReference": {
       const base = node.base;
       const namespace = node.namespace;
@@ -1830,7 +2019,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_parser8.isClassType)(analysis.types.aliases.get(namespace ? `${namespace}.${base}` : base) ?? import_luaut_parser8.unknownType)) {
+      } else if ((0, import_luaut_parser9.isClassType)(analysis.types.aliases.get(namespace ? `${namespace}.${base}` : base) ?? import_luaut_parser9.unknownType)) {
         add(baseToken, base.length, "class");
       } else {
         add(baseToken, base.length, "type", PRIMITIVES3.has(base) ? ["defaultLibrary"] : []);
@@ -1839,6 +2028,10 @@ function classify(analysis, spanned, ancestors, identifiers, add) {
     }
   }
 }
+function wordOf(token) {
+  const value = token.value;
+  return typeof value === "string" ? value : void 0;
+}
 function identifier(analysis, node, parent, add) {
   const name = node.name;
   const as = (type, modifiers = []) => add(node, name.length, type, modifiers);
@@ -1862,6 +2055,19 @@ function identifier(analysis, node, parent, add) {
     case "DeclareClassStatement":
       if (parent.name === node) return as("class", ["declaration"]);
       break;
+    case "ClassDeclaration":
+      if (parent.name === node) return as("class", ["declaration"]);
+      if (parent.superclass === node) return as("class");
+      break;
+    case "ClassMethod":
+      if (parent.name === node) return as("method", ["declaration"]);
+      break;
+    case "ClassField":
+      if (parent.name === node) return as("property", ["declaration"]);
+      break;
+    case "ClassAccessor":
+      if (parent.name === node) return as("property", ["declaration"]);
+      break;
     case "DeclareStatement":
       if (parent.id === node) return as(isFunction(typeOfNode(parent.valueType)) ? "function" : "variable", ["declaration"]);
       break;
@@ -2063,7 +2269,7 @@ function createServer(connection, options = {}) {
       severity: import_node.DiagnosticSeverity.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);
@@ -2082,6 +2288,11 @@ function createServer(connection, options = {}) {
     (d) => hover(analyzer.get(d), p.position),
     null
   ));
+  connection.onRequest("luaut/hover", (p) => withDocument(
+    p.textDocument.uri,
+    (d) => hover(analyzer.get(d), p.position, Math.max(0, p.depth ?? 0)),
+    null
+  ));
   connection.onDefinition((p) => withDocument(
     p.textDocument.uri,
     (d) => {