luaut-language-server 2.0.0 → 3.0.0

package/dist/cli.js

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
 import {
   startServer
-} from "./chunk-SXRYJV32.js";
+} from "./chunk-X2GHHRWT.js";
 
 // src/cli.ts
 startServer();

package/dist/index.cjs

@@ -819,11 +819,28 @@ var import_luaut_parser4 = require("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;
@@ -865,6 +882,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);
@@ -896,7 +916,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);
@@ -904,13 +924,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.
@@ -921,9 +941,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 && (0, import_luaut_parser4.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)}`;
@@ -952,6 +974,19 @@ function declareText(analysis, statement) {
   const overloads = others > 0 ? `  (+${others} overload${others > 1 ? "s" : ""})` : "";
   return `declare function ${name}${(0, import_luaut_parser4.formatType)(own)}${overloads}`;
 }
+function classText(analysis, name) {
+  const type = analysis.types.aliases.get(name);
+  if (!type || !(0, import_luaut_parser4.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_parser4.formatType)(property.type)},`);
+  return `${head} {
+${lines.join("\n")}
+}`;
+}
 function typeParameterText(analysis, parameter) {
   return `(type parameter) ${typeParameterSignature(analysis, parameter)}`;
 }
@@ -1011,10 +1046,19 @@ ${lines.join("\n")}
   }
   return flat;
 }
+function bindingText(binding, type) {
+  if (binding.declaredBy === "function" && type.kind === "function") {
+    return `function ${binding.name}${(0, import_luaut_parser4.formatType)(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) {
@@ -1116,10 +1160,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: import_vscode_languageserver4.CompletionItemKind.Interface,
-      detail: "type"
+      kind: (0, import_luaut_parser5.isClassType)(type) ? import_vscode_languageserver4.CompletionItemKind.Class : import_vscode_languageserver4.CompletionItemKind.Interface,
+      detail: (0, import_luaut_parser5.isClassType)(type) ? "class" : "type"
     }));
     const primitives = PRIMITIVES2.map((name) => ({
       label: name,
@@ -1210,6 +1254,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);
@@ -1251,7 +1296,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 = [
@@ -1392,6 +1437,12 @@ function documentSymbols(analysis) {
         }
         break;
       }
+      case "DeclareClassStatement": {
+        const name = node.name.name;
+        const superclass = node.superclass?.base;
+        out.push(symbol(name, import_vscode_languageserver5.SymbolKind.Class, node, superclass && `extends ${superclass}`));
+        break;
+      }
       case "VariableDeclaration": {
         for (const target of node.names ?? []) {
           const name = target.name;
@@ -1433,6 +1484,7 @@ var import_luaut_parser7 = require("luaut-parser");
 var TOKEN_TYPES = [
   "namespace",
   "type",
+  "class",
   "typeParameter",
   "parameter",
   "variable",
@@ -1449,6 +1501,7 @@ var semanticTokensLegend = {
 var SOFT_KEYWORDS = /* @__PURE__ */ new Set([
   "type",
   "declare",
+  "class",
   "extends",
   "keyof",
   "infer",
@@ -1515,6 +1568,8 @@ 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_parser7.isClassType)(analysis.types.aliases.get(namespace ? `${namespace}.${base}` : base) ?? import_luaut_parser7.unknownType)) {
+        add(baseToken, base.length, "class");
       } else {
         add(baseToken, base.length, "type", PRIMITIVES3.has(base) ? ["defaultLibrary"] : []);
       }
@@ -1542,6 +1597,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;
@@ -1565,10 +1623,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;
@@ -1584,6 +1646,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) {