luaut-language-server 2.0.0 → 3.0.0

package/README.md

@@ -17,7 +17,7 @@ luaut-language-server --stdio
 | request | notes |
 |---|---|
 | `publishDiagnostics` | syntax, scope (redeclare, assign-to-`const`) and type errors, on open and on every keystroke |
-| `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), alias names, object-type properties, type parameters, `infer` names, and any type annotation, which reads as what it resolves to |
+| `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 |

package/dist/{chunk-SXRYJV32.js → chunk-X2GHHRWT.js}

@@ -765,16 +765,34 @@ function diagnostics(analysis) {
 
 // src/features/hover.ts
 import {
-  formatType as formatType3
+  formatType as formatType3,
+  isClassType
 } from "luaut-parser";
 function hover(analysis, position) {
   const path = pathAt(analysis.program, position, true);
   for (let i = path.length - 1; i >= 0; i--) {
+    if (UNNAMED.has(path[i].type)) return null;
     const text = describe(analysis, path, i);
     if (text) return { contents: { kind: "markdown", value: code(text) }, range: toRange(path[i]) };
   }
   return null;
 }
+var UNNAMED = /* @__PURE__ */ new Set([
+  "BinaryExpression",
+  "UnaryExpression",
+  "CallExpression",
+  "MethodCallExpression",
+  "MemberExpression",
+  "IndexExpression",
+  "ParenthesizedExpression",
+  "IfElseExpression",
+  "TableExpression",
+  "ArrayExpression",
+  "TypeAssertionExpression",
+  "SatisfiesExpression",
+  "AsConstExpression",
+  "InterpolatedStringExpression"
+]);
 var PRIMITIVES = /* @__PURE__ */ new Set(["any", "unknown", "never", "nil", "boolean", "number", "string", "thread", "buffer"]);
 function describe(analysis, path, index) {
   const { types } = analysis;
@@ -816,6 +834,9 @@ function describe(analysis, path, index) {
         case "DeclareStatement":
           if (parent.id === node) return declareText(analysis, parent);
           break;
+        case "DeclareClassStatement":
+          if (parent.name === node) return classText(analysis, name);
+          break;
         case "TableTypeProperty":
           if (parent.key === node) {
             const type2 = typeOfNode(parent.valueType);
@@ -847,7 +868,7 @@ function describe(analysis, path, index) {
       const binding = bindingOfNode(analysis, identifier2);
       if (binding) {
         const type2 = types.bindingType.get(binding.id);
-        if (type2) return `${keyword(binding)} ${binding.name}: ${pretty(type2)}`;
+        if (type2) return bindingText(binding, type2);
       }
       if (parent?.type === "MemberExpression" || parent?.type === "MethodCallExpression") {
         const type2 = types.typeOf.get(parent);
@@ -855,13 +876,13 @@ function describe(analysis, path, index) {
       }
       return void 0;
     }
-    // Declarations: `const x`, a parameter, `const function f`.
+    // Declarations: `const x`, a parameter.
     case "IdentifierPattern":
     case "FunctionParameter":
     case "TypedIdentifier": {
       const binding = bindingOfNode(analysis, node);
       const type2 = binding && types.bindingType.get(binding.id);
-      return type2 ? `${keyword(binding)} ${binding.name}: ${pretty(type2)}` : void 0;
+      return type2 ? bindingText(binding, type2) : void 0;
     }
     // A type written by name: `number`, `Shape`, `Partial<User>`, or a type
     // parameter in scope.
@@ -872,9 +893,11 @@ function describe(analysis, path, index) {
         if (parameter) return typeParameterText(analysis, parameter);
         if (PRIMITIVES.has(base)) return `type ${base}`;
       }
-      if (!node.namespace && !node.typeArguments.length) {
-        const alias = types.aliases.get(base);
-        if (alias) return `type ${base} = ${pretty(alias)}`;
+      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) return `type ${qualified} = ${pretty(alias)}`;
       }
       const type2 = typeOfNode(node);
       return type2 && `type ${referenceText(analysis, node)} = ${pretty(type2)}`;
@@ -903,6 +926,19 @@ function declareText(analysis, statement) {
   const overloads = others > 0 ? `  (+${others} overload${others > 1 ? "s" : ""})` : "";
   return `declare function ${name}${formatType3(own)}${overloads}`;
 }
+function classText(analysis, name) {
+  const type = analysis.types.aliases.get(name);
+  if (!type || !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 ? "?" : ""}: ${formatType3(property.type)},`);
+  return `${head} {
+${lines.join("\n")}
+}`;
+}
 function typeParameterText(analysis, parameter) {
   return `(type parameter) ${typeParameterSignature(analysis, parameter)}`;
 }
@@ -962,10 +998,19 @@ ${lines.join("\n")}
   }
   return flat;
 }
+function bindingText(binding, type) {
+  if (binding.declaredBy === "function" && type.kind === "function") {
+    return `function ${binding.name}${formatType3(type)}`;
+  }
+  return `${keyword(binding)} ${binding.name}: ${pretty(type)}`;
+}
 function keyword(binding) {
   if (binding.kind === "param" || binding.kind === "self") return "(parameter)";
   if (binding.kind === "global") return "(global)";
   if (binding.kind.startsWith("for-")) return "(loop variable)";
+  if (binding.declaredBy === "import" || binding.declaredBy === "namespace") return "(import)";
+  if (binding.declaredBy === "type") return "(type import)";
+  if (binding.declaredBy === "function") return "function";
   return binding.isConst ? "const" : "let";
 }
 function code(text) {
@@ -1038,7 +1083,7 @@ import {
   CompletionItemKind as CompletionItemKind2,
   InsertTextFormat
 } from "vscode-languageserver";
-import { formatType as formatType4 } from "luaut-parser";
+import { formatType as formatType4, isClassType as isClassType2 } from "luaut-parser";
 var PLACEHOLDER = "__luautCompletion__";
 var IDENTIFIER_CHAR = /[A-Za-z0-9_]/;
 function completion(analyzer, document, position) {
@@ -1072,10 +1117,10 @@ function completion(analyzer, document, position) {
   }
   if (operator || !first) return [];
   if (inTypePosition(first.path)) {
-    const named = [...first.analysis.types.aliases.keys()].map((name) => ({
+    const named = [...first.analysis.types.aliases].map(([name, type]) => ({
       label: name,
-      kind: CompletionItemKind2.Interface,
-      detail: "type"
+      kind: isClassType2(type) ? CompletionItemKind2.Class : CompletionItemKind2.Interface,
+      detail: isClassType2(type) ? "class" : "type"
     }));
     const primitives = PRIMITIVES2.map((name) => ({
       label: name,
@@ -1166,6 +1211,7 @@ function valueItems(analysis, at) {
   const seen = /* @__PURE__ */ new Set();
   for (const binding of analysis.scopes.bindings.values()) {
     if (binding.name === PLACEHOLDER || seen.has(binding.name)) continue;
+    if (binding.declaredBy === "type") continue;
     const declaration = binding.declarationNode;
     if (declaration && declaration.line.start - 1 > at.line) continue;
     seen.add(binding.name);
@@ -1207,7 +1253,7 @@ function kindOf(type, bindingKind) {
 }
 function inTypePosition(path) {
   return path.some(
-    (n) => !!n.type && (n.type.endsWith("TypeNode") || n.type === "TypeReference" || n.type === "TypeAliasStatement" || n.type === "ExportTypeAliasStatement")
+    (n) => !!n.type && (n.type.endsWith("TypeNode") || n.type === "TypeReference" || n.type === "TypeAliasStatement" || n.type === "ExportTypeAliasStatement" || n.type === "DeclareClassStatement")
   );
 }
 var PRIMITIVES2 = [
@@ -1348,6 +1394,12 @@ function documentSymbols(analysis) {
         }
         break;
       }
+      case "DeclareClassStatement": {
+        const name = node.name.name;
+        const superclass = node.superclass?.base;
+        out.push(symbol(name, SymbolKind.Class, node, superclass && `extends ${superclass}`));
+        break;
+      }
       case "VariableDeclaration": {
         for (const target of node.names ?? []) {
           const name = target.name;
@@ -1385,10 +1437,11 @@ function symbol(name, kind, node, detail) {
 }
 
 // src/features/semanticTokens.ts
-import { tokenize } from "luaut-parser";
+import { tokenize, isClassType as isClassType3, unknownType } from "luaut-parser";
 var TOKEN_TYPES = [
   "namespace",
   "type",
+  "class",
   "typeParameter",
   "parameter",
   "variable",
@@ -1405,6 +1458,7 @@ var semanticTokensLegend = {
 var SOFT_KEYWORDS = /* @__PURE__ */ new Set([
   "type",
   "declare",
+  "class",
   "extends",
   "keyof",
   "infer",
@@ -1471,6 +1525,8 @@ 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)) {
+        add(baseToken, base.length, "class");
       } else {
         add(baseToken, base.length, "type", PRIMITIVES3.has(base) ? ["defaultLibrary"] : []);
       }
@@ -1498,6 +1554,9 @@ function identifier(analysis, node, parent, add) {
     case "ExportTypeAliasStatement":
       if (parent.name === node) return as("type", ["declaration"]);
       break;
+    case "DeclareClassStatement":
+      if (parent.name === node) return as("class", ["declaration"]);
+      break;
     case "DeclareStatement":
       if (parent.id === node) return as(isFunction(typeOfNode(parent.valueType)) ? "function" : "variable", ["declaration"]);
       break;
@@ -1521,10 +1580,14 @@ function identifier(analysis, node, parent, add) {
       break;
     case "ImportSpecifier": {
       const binding2 = bindingOfNode(analysis, node);
+      if (binding2?.declaredBy === "type") return as("type", ["declaration"]);
       const value = binding2 && analysis.types.bindingType.get(binding2.id);
       if (analysis.types.aliases.has(name) && (!value || value.kind === "any")) return as("type", ["declaration"]);
       break;
     }
+    case "ImportStatement":
+      if (parent.namespaceImport === node) return as("namespace", ["declaration"]);
+      break;
     case "ExportSpecifier":
       if (!bindingOfNode(analysis, node) && analysis.types.aliases.has(name)) return as("type");
       break;
@@ -1540,6 +1603,7 @@ function identifier(analysis, node, parent, add) {
 function valueKind(analysis, binding) {
   if (!binding) return "variable";
   if (binding.kind === "param" || binding.kind === "self") return "parameter";
+  if (binding.declaredBy === "namespace") return "namespace";
   return isFunction(analysis.types.bindingType.get(binding.id)) ? "function" : "variable";
 }
 function modifiersOf(binding, isDeclaration) {
@@ -1810,4 +1874,4 @@ export {
   createServer,
   startServer
 };
-//# sourceMappingURL=chunk-SXRYJV32.js.map
+//# sourceMappingURL=chunk-X2GHHRWT.js.map