luaut-language-server 2.0.0 → 2.1.0

package/dist/cli.cjs

@@ -799,6 +799,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);
@@ -855,9 +858,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)}`;
@@ -886,6 +891,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)}`;
 }
@@ -1050,10 +1068,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,
@@ -1185,7 +1203,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 = [
@@ -1326,6 +1344,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;
@@ -1367,6 +1391,7 @@ var import_luaut_parser7 = require("luaut-parser");
 var TOKEN_TYPES = [
   "namespace",
   "type",
+  "class",
   "typeParameter",
   "parameter",
   "variable",
@@ -1383,6 +1408,7 @@ var semanticTokensLegend = {
 var SOFT_KEYWORDS = /* @__PURE__ */ new Set([
   "type",
   "declare",
+  "class",
   "extends",
   "keyof",
   "infer",
@@ -1449,6 +1475,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"] : []);
       }
@@ -1476,6 +1504,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;