luaut-language-server 3.1.0 → 5.0.0

package/README.md

@@ -18,11 +18,12 @@ luaut-language-server --stdio
 |---|---|
 | `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 |
+| `luaut/hover` | the same hover, at a level the editor asks for (`depth`), and whether there is another (`canExpand`). Level 0 is the shortest true reading — names left as names — and each one opens the names standing a step further in: `const b: Shape`, then `{ kind: "circle", size: number }`, then whatever those are named after. A class stays its name, and a type that names itself opens once. LSP has no way to ask for this, so every other editor gets level 0 through `hover` |
 | `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. 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 |
+| `completion` | members after `.` / `:` (never the globals there), names in scope — including what hoisting makes visible before its declaration: a function declaration anywhere in its block, and every name of the module inside a function body — 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 |
 
@@ -91,6 +92,14 @@ name. The grammar in the editor extension keeps just what characters decide
 alone — comments, strings, numbers, reserved words — so a file looks right
 before the server answers, and never disagrees with it after.
 
+### Saying more
+
+A hover opens with the shortest thing that is true and says more when asked,
+as TypeScript's does. The server answers `luaut/hover` at whatever level it is
+given; how the editor offers the next one is the editor's business. The VS
+Code extension puts a link under the type, because the hover API that would
+draw the buttons is still a proposed one.
+
 ## Not yet
 
 - **One file at a time.** No workspace indexing, so no cross-file

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

@@ -1,5 +1,5 @@
 // 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;
@@ -48,13 +48,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 : 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 [];
   }
 }
 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;
 }
@@ -75,7 +90,7 @@ function signatureLabel(signature) {
   });
   const generics = signature.typeParams?.length ? `<${signature.typeParams.join(", ")}>` : "";
   const varargs = signature.varargs ? [`...: ${formatType(signature.varargs)}`] : [];
-  const label = `${generics}(${[...parameters, ...varargs].join(", ")}) -> ${formatType(signature.returns)}`;
+  const label = `${generics}(${[...parameters, ...varargs].join(", ")}) => ${formatType(signature.returns)}`;
   return { label, parameters };
 }
 
@@ -683,7 +698,7 @@ function exportDeclaration(analyzer, module, name, seen = /* @__PURE__ */ new Se
         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) {
@@ -797,17 +812,101 @@ function diagnostics(analysis) {
 // src/features/hover.ts
 import {
   formatType as formatType3,
-  isClassType
+  isClassType as isClassType2
 } from "luaut-parser";
-function hover(analysis, position) {
+
+// src/features/expand.ts
+import { isClassType, arrayOf, tuple, objectType, fn, union as union2, intersection } from "luaut-parser";
+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 (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 = 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 arrayOf(f(type.element));
+    case "tuple":
+      return tuple(type.elements.map(f), type.isPack);
+    case "union":
+      return union2(type.types.map(f));
+    case "intersection": {
+      const out = intersection(type.types.map(f));
+      return type.name && out.kind === "intersection" ? { ...out, name: type.name } : out;
+    }
+    case "object": {
+      if (isClassType(type)) return type;
+      const out = 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 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",
@@ -840,8 +939,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)}`;
         }
@@ -889,6 +988,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);
@@ -939,7 +1051,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.
@@ -953,7 +1065,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 && isClassType(alias)) return classText(analysis, qualified);
+        if (alias && isClassType2(alias)) return classText(analysis, qualified);
         if (alias) return `type ${qualified} = ${pretty(alias)}`;
       }
       const type2 = typeOfNode(node);
@@ -985,16 +1097,25 @@ function declareText(analysis, statement) {
 }
 function classText(analysis, name) {
   const type = analysis.types.aliases.get(name);
-  if (!type || !isClassType(type)) return void 0;
+  if (!type || !isClassType2(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 ? "?" : ""}: ${formatType3(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 ? "?" : ""}: ${formatType3(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)}`;
@@ -1036,7 +1157,27 @@ function fieldWithKey(table, key) {
   const fields = table.fields;
   return fields.find((f) => f.type === "TableFieldNamed" && f.key === key);
 }
-function pretty(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 = formatType3(type);
   if (flat.length <= 80) return flat;
   if (type.kind === "object") {
@@ -1055,11 +1196,11 @@ ${lines.join("\n")}
   }
   return flat;
 }
-function bindingText(binding, type) {
+function bindingText(binding, type, written) {
   if (binding.declaredBy === "function" && type.kind === "function") {
-    return `function ${binding.name}${formatType3(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)";
@@ -1140,7 +1281,7 @@ import {
   CompletionItemKind as CompletionItemKind3,
   InsertTextFormat
 } from "vscode-languageserver";
-import { formatType as formatType4, isClassType as isClassType2 } from "luaut-parser";
+import { formatType as formatType4, isClassType as isClassType3 } from "luaut-parser";
 
 // src/features/autoImport.ts
 import { readdirSync as readdirSync2 } from "fs";
@@ -1177,7 +1318,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;
@@ -1188,8 +1329,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;
@@ -1201,24 +1342,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}
 ` };
@@ -1311,12 +1452,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
     );
@@ -1332,8 +1473,8 @@ function completion(analyzer, document, position) {
   if (inTypePosition(first.path)) {
     const named = [...first.analysis.types.aliases].map(([name, type]) => ({
       label: name,
-      kind: isClassType2(type) ? CompletionItemKind3.Class : CompletionItemKind3.Interface,
-      detail: isClassType2(type) ? "class" : "type"
+      kind: isClassType3(type) ? CompletionItemKind3.Class : CompletionItemKind3.Interface,
+      detail: isClassType3(type) ? "class" : "type"
     }));
     const primitives = PRIMITIVES2.map((name) => ({
       label: name,
@@ -1353,7 +1494,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)
@@ -1427,8 +1568,8 @@ function objectKeyItems(analysis, path, after) {
 }
 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) {
@@ -1495,12 +1636,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) {
@@ -1508,29 +1644,35 @@ 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({
@@ -1668,9 +1810,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;
@@ -1722,6 +1864,15 @@ function documentSymbols(analysis) {
         }
         break;
       }
+      case "ClassDeclaration": {
+        const declaration = node;
+        const superclass = declaration.superclass?.name;
+        out.push({
+          ...symbol(declaration.name.name, 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;
@@ -1739,6 +1890,23 @@ function documentSymbols(analysis) {
   });
   return out;
 }
+function classMember(analysis, member) {
+  switch (member.type) {
+    case "ClassConstructor":
+      return symbol("constructor", SymbolKind.Constructor, member);
+    case "ClassField":
+      return symbol(
+        member.name.name,
+        member.isStatic ? SymbolKind.Constant : SymbolKind.Field,
+        member,
+        member.typeAnnotation ? void 0 : detailOf(analysis, member)
+      );
+    case "ClassAccessor":
+      return symbol(member.name.name, SymbolKind.Property, member, member.kind);
+    case "ClassMethod":
+      return symbol(member.name.name, SymbolKind.Method, member, member.isStatic ? "static" : void 0);
+  }
+}
 function functionName(node) {
   const named = node;
   if (typeof named.name === "string") return named.name;
@@ -1765,7 +1933,7 @@ function symbol(name, kind, node, detail) {
 }
 
 // src/features/semanticTokens.ts
-import { tokenize, isClassType as isClassType3, unknownType } from "luaut-parser";
+import { tokenize, isClassType as isClassType4, unknownType } from "luaut-parser";
 var TOKEN_TYPES = [
   "namespace",
   "type",
@@ -1795,15 +1963,17 @@ 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 });
   };
@@ -1844,6 +2014,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;
@@ -1853,7 +2042,7 @@ function classify(analysis, spanned, ancestors, identifiers, add) {
       if (!baseToken) return;
       if (!namespace && typeParameterInScope2(ancestors, base)) {
         add(baseToken, base.length, "typeParameter");
-      } else if (isClassType3(analysis.types.aliases.get(namespace ? `${namespace}.${base}` : base) ?? unknownType)) {
+      } else if (isClassType4(analysis.types.aliases.get(namespace ? `${namespace}.${base}` : base) ?? unknownType)) {
         add(baseToken, base.length, "class");
       } else {
         add(baseToken, base.length, "type", PRIMITIVES3.has(base) ? ["defaultLibrary"] : []);
@@ -1862,6 +2051,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);
@@ -1885,6 +2078,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;
@@ -2094,7 +2300,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);
@@ -2113,6 +2319,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) => {
@@ -2202,4 +2413,4 @@ export {
   createServer,
   startServer
 };
-//# sourceMappingURL=chunk-SCZTSX3Y.js.map
+//# sourceMappingURL=chunk-GHAR7NOH.js.map