luaut-language-server 1.1.1 → 2.1.0

package/dist/{chunk-OQWE7ISD.js → chunk-HJ2C3OFZ.js}

@@ -1,24 +1,90 @@
+// src/features/members.ts
+import { formatType } from "luaut-parser";
+function membersOf(type, aliases, seen = /* @__PURE__ */ new Set()) {
+  if (!type || seen.has(type)) return [];
+  seen.add(type);
+  switch (type.kind) {
+    case "object": {
+      const out = [];
+      for (const [name, property] of type.properties) {
+        out.push({ name, property, isMethod: takesSelf(property.type) });
+      }
+      return out;
+    }
+    case "intersection": {
+      const merged = /* @__PURE__ */ new Map();
+      for (const part of type.types) {
+        for (const member of membersOf(part, aliases, seen)) merged.set(member.name, member);
+      }
+      return [...merged.values()];
+    }
+    case "union": {
+      const perBranch = type.types.map((part) => membersOf(part, aliases, seen));
+      if (!perBranch.length) return [];
+      const [first, ...rest] = perBranch;
+      return first.filter((member) => rest.every((other) => other.some((m) => m.name === member.name)));
+    }
+    case "genericRef": {
+      const alias = aliases.get(type.name);
+      return alias ? membersOf(alias, aliases, seen) : [];
+    }
+    case "typeParam":
+      return membersOf(type.constraint, aliases, seen);
+    default:
+      return [];
+  }
+}
+function takesSelf(type) {
+  for (const signature of signaturesOf(type)) {
+    if (signature.params[0]?.name === "self") return true;
+  }
+  return false;
+}
+function signaturesOf(type, aliases) {
+  if (!type) return [];
+  if (type.kind === "function") return [type];
+  if (type.kind === "intersection") return type.types.flatMap((t) => signaturesOf(t, aliases));
+  if (type.kind === "genericRef" && aliases) {
+    const alias = aliases.get(type.name);
+    return alias ? signaturesOf(alias, aliases) : [];
+  }
+  return [];
+}
+function signatureLabel(signature) {
+  const parameters = signature.params.map((p, i) => {
+    const name = p.name ?? `arg${i + 1}`;
+    return `${name}${p.optional ? "?" : ""}: ${formatType(p.type)}`;
+  });
+  const generics = signature.typeParams?.length ? `<${signature.typeParams.join(", ")}>` : "";
+  const varargs = signature.varargs ? [`...: ${formatType(signature.varargs)}`] : [];
+  const label = `${generics}(${[...parameters, ...varargs].join(", ")}) -> ${formatType(signature.returns)}`;
+  return { label, parameters };
+}
+
 // src/analysis.ts
 import { readFileSync, statSync } from "fs";
-import { dirname, join, resolve } from "path";
+import { dirname, resolve } from "path";
 import { fileURLToPath, pathToFileURL } from "url";
 import {
+  parse,
   parseWithRecovery,
   analyzeScopes,
   analyzeTypes,
   moduleExports,
-  defaultLibs,
-  getBinding
+  getBinding,
+  findConfig,
+  resolveTypeLibraries,
+  moduleCandidates,
+  sourceMapTypes
 } from "luaut-parser";
 function globalsOf(libs) {
   const names = /* @__PURE__ */ new Set();
-  for (const lib of libs) collect(lib.body.statements, names);
-  return [...names];
-}
-function collect(statements, into) {
-  for (const statement of statements) {
-    if (statement.type === "DeclareStatement") into.add(statement.name);
+  for (const lib of libs) {
+    for (const statement of lib.body.statements) {
+      if (statement.type === "DeclareStatement") names.add(statement.name);
+    }
   }
+  return [...names];
 }
 function bindingOfNode(analysis, node) {
   const used = getBinding(analysis.scopes, node);
@@ -56,20 +122,34 @@ function pathKey(path) {
   return process.platform === "win32" ? normalized.toLowerCase() : normalized;
 }
 var CYCLE = { values: /* @__PURE__ */ new Map(), types: /* @__PURE__ */ new Map(), partial: true };
+var NO_PROJECT = { project: { fixed: false, problems: [] }, libs: [], globals: [], reads: /* @__PURE__ */ new Map() };
 var Analyzer = class {
-  libs;
-  builtinGlobals;
+  fixed;
   openDocument;
   cache = /* @__PURE__ */ new Map();
   /** Imported modules, by path key. */
   modules = /* @__PURE__ */ new Map();
+  /** Project contexts, by folder. */
+  contexts = /* @__PURE__ */ new Map();
+  /** Parsed type libraries, by path — reparsed only when the text changes. */
+  libraries = /* @__PURE__ */ new Map();
+  /** Sourcemaps turned into types, by path, with what they were built from. */
+  sourceMaps = /* @__PURE__ */ new Map();
+  /** The analysis run in progress, if any. */
+  run;
   constructor(options = {}) {
-    this.libs = options.libs ?? defaultLibs;
-    this.builtinGlobals = globalsOf(this.libs);
     this.openDocument = options.openDocument;
+    if (options.libs) {
+      this.fixed = {
+        project: { fixed: true, problems: [] },
+        libs: options.libs,
+        globals: globalsOf(options.libs),
+        reads: /* @__PURE__ */ new Map()
+      };
+    }
   }
   /** Analyze `document`, reusing the previous result while neither it nor
-   *  anything it imports has changed. */
+   *  anything it read has changed. */
   get(document) {
     const cached = this.cache.get(document.uri);
     const source = document.getText();
@@ -84,34 +164,41 @@ var Analyzer = class {
    *  completion, which analyzes a speculatively edited copy of the file. */
   analyze(uri, version, source) {
     const path = pathOfUri(uri);
-    return this.analyzeModule(uri, version, source, new Set(path ? [pathKey(path)] : []));
+    if (!path) return this.analyzeModule(uri, version, source, /* @__PURE__ */ new Set());
+    const key = pathKey(path);
+    return this.resolvingCycles(key, () => {
+      const analysis = this.analyzeModule(uri, version, source, /* @__PURE__ */ new Set([key]));
+      return { result: analysis, exports: () => this.exportsFrom(analysis, /* @__PURE__ */ new Set([key])) };
+    });
   }
   forget(uri) {
     this.cache.delete(uri);
   }
-  /** The file an import in `fromUri` names. Relative paths only (`./x`,
-   *  `../x`); the extension may be left off, and a folder means its
-   *  `index.luaut`. */
-  resolveModulePath(fromUri, specifier) {
-    return this.moduleCandidates(fromUri, specifier).find((candidate) => this.sourceOf(candidate) !== void 0);
+  /** The project a file belongs to. */
+  projectOf(uri) {
+    return this.contextFor(pathOfUri(uri)).project;
   }
-  /** Every file an import could mean, in the order they are tried. */
-  moduleCandidates(fromUri, specifier) {
+  /** The file an import in `fromUri` names: a relative path, or a `paths`
+   *  alias from the file's config. */
+  resolveModulePath(fromUri, specifier) {
     const from = pathOfUri(fromUri);
-    if (!from || !(specifier.startsWith("./") || specifier.startsWith("../"))) return [];
-    const base = resolve(dirname(from), specifier);
-    return specifier.endsWith(".luaut") ? [base] : [`${base}.luaut`, `${base}.d.luaut`, join(base, "index.luaut")];
+    if (!from) return void 0;
+    return this.candidatesFor(from, specifier).find((candidate) => this.readFile(candidate) !== void 0);
   }
   /** What the module at `path` exports, analyzing it if need be. */
   exportsAt(path) {
-    return this.exportsOf(path, /* @__PURE__ */ new Set());
+    return this.resolvingCycles(pathKey(path), () => {
+      const exports = this.exportsOf(path, /* @__PURE__ */ new Set());
+      return { result: exports, exports: () => exports };
+    });
   }
   /** The analysis of the module at `path`, analyzing it if need be. */
   moduleAt(path) {
-    this.exportsOf(path, /* @__PURE__ */ new Set());
+    this.exportsAt(path);
     return this.modules.get(pathKey(path))?.analysis;
   }
-  sourceOf(path) {
+  /** A file's text: the open document if there is one, else the disk. */
+  readFile(path) {
     const open = this.openDocument?.(path);
     if (open) return open.getText();
     try {
@@ -120,60 +207,206 @@ var Analyzer = class {
       return void 0;
     }
   }
+  candidatesFor(from, specifier) {
+    return moduleCandidates(from, specifier, this.contextFor(from).project.config);
+  }
+  // ---------------------------------------------------------------- projects
+  contextFor(path) {
+    if (this.fixed) return this.fixed;
+    if (!path) return NO_PROJECT;
+    const key = pathKey(dirname(path));
+    const cached = this.contexts.get(key);
+    if (cached && this.unchanged(cached.reads)) return cached;
+    const context = this.buildContext(path);
+    this.contexts.set(key, context);
+    return context;
+  }
+  buildContext(path) {
+    const reads = /* @__PURE__ */ new Map();
+    const host = {
+      readFile: (file) => {
+        const text = this.readFile(file);
+        reads.set(file, text);
+        return text;
+      }
+    };
+    const lookup = findConfig(path, host);
+    const problems = [...lookup.problems];
+    const config = lookup.config;
+    if (!config) return { project: { fixed: false, problems }, libs: [], globals: [], reads };
+    const libraries = resolveTypeLibraries(config, host);
+    problems.push(...libraries.problems);
+    const libs = [];
+    for (const file of libraries.files) {
+      const program = this.library(file, host, problems);
+      if (program) libs.push(program);
+    }
+    let sourceMap;
+    if (config.sourceMap) {
+      const text = host.readFile(config.sourceMap);
+      if (text === void 0) {
+        problems.push({
+          file: config.path,
+          message: `Cannot find the sourceMap file ${config.sourceMap}`,
+          ...optionPosition(config, "sourceMap")
+        });
+      } else {
+        const result = this.sourceMap(config.sourceMap, text, libs, libraries.files);
+        if (result.problem) problems.push({ file: config.sourceMap, message: result.problem, line: 1, column: 1 });
+        sourceMap = result.types;
+        if (sourceMap) libs.push(sourceMap.program);
+      }
+    }
+    return { project: { config, fixed: false, problems }, libs, globals: globalsOf(libs), sourceMap, reads };
+  }
+  /** A type library's definitions, parsed once per text. */
+  library(file, host, problems) {
+    const source = host.readFile(file);
+    if (source === void 0) return void 0;
+    const key = pathKey(file);
+    let entry = this.libraries.get(key);
+    if (!entry || entry.source !== source) {
+      try {
+        entry = { source, program: parse(source) };
+      } catch (error) {
+        const { message, line, column } = error;
+        entry = {
+          source,
+          problem: { file, message: `Syntax error in type library: ${message.replace(/\s*\(\d+:\d+\)$/, "")}`, line, column }
+        };
+      }
+      this.libraries.set(key, entry);
+    }
+    if (entry.problem) problems.push(entry.problem);
+    return entry.program;
+  }
+  /** A sourcemap's types, rebuilt only when it or the libraries change. */
+  sourceMap(path, text, libs, files) {
+    const key = pathKey(path);
+    const libraries = files.join("\n");
+    const cached = this.sourceMaps.get(key);
+    if (cached && cached.text === text && cached.libraries === libraries) return cached.result;
+    const aliases = aliasesOf(libs);
+    const members = /* @__PURE__ */ new Map();
+    const result = sourceMapTypes(text, path, {
+      classes: new Set(aliases.keys()),
+      membersOf: (className) => {
+        let names = members.get(className);
+        if (!names) {
+          names = new Set(membersOf(aliases.get(className), aliases).map((member) => member.name));
+          members.set(className, names);
+        }
+        return names;
+      }
+    });
+    this.sourceMaps.set(key, { text, libraries, result });
+    return result;
+  }
+  unchanged(reads) {
+    for (const [file, text] of reads) if (this.readFile(file) !== text) return false;
+    return true;
+  }
+  // ----------------------------------------------------------------- modules
+  /** Run one analysis of `root` and everything it imports; if that met an
+   *  import cycle, run it once more with the first pass's exports standing
+   *  in for the `any` the cycle left (see `Run`). A call made while a run is
+   *  already going is part of that run. */
+  resolvingCycles(root, analyzeRoot) {
+    if (this.run) return analyzeRoot().result;
+    const run = { cycles: /* @__PURE__ */ new Set(), analyzed: /* @__PURE__ */ new Set(), provisional: /* @__PURE__ */ new Map() };
+    this.run = run;
+    try {
+      const first = analyzeRoot();
+      if (!run.cycles.size) return first.result;
+      for (const key of run.cycles) {
+        const exports = key === root ? first.exports() : this.modules.get(key)?.exports;
+        if (exports && !exports.partial) run.provisional.set(key, exports);
+      }
+      for (const key of run.analyzed) this.modules.delete(key);
+      return analyzeRoot().result;
+    } finally {
+      this.run = void 0;
+    }
+  }
+  /** A module's exports, from its analysis. */
+  exportsFrom(analysis, importing) {
+    return moduleExports(analysis.program, analysis.scopes, analysis.types, (specifier) => {
+      const next = this.resolveModulePath(analysis.uri, specifier);
+      return next ? this.exportsOf(next, importing) : void 0;
+    });
+  }
   /** `importing` holds every module on the current import chain, so an
    *  import back into one of them is recognized as a cycle. */
   analyzeModule(uri, version, source, importing) {
+    const path = pathOfUri(uri);
+    const context = this.contextFor(path);
+    const script = path ? context.sourceMap?.scriptFor(path) : void 0;
+    const libs = script ? [...context.libs, script] : context.libs;
+    const globals = script ? [...context.globals, "script"] : context.globals;
     const { program, errors } = parseWithRecovery(source);
-    const scopes = analyzeScopes(program, { builtinGlobals: this.builtinGlobals });
-    const dependencies = /* @__PURE__ */ new Map();
+    const scopes = analyzeScopes(program, { builtinGlobals: [...globals] });
+    const dependencies = new Map(context.reads);
     const types = analyzeTypes(program, scopes, {
-      libs: this.libs,
+      libs,
       resolveModule: (specifier) => {
-        const target = this.resolveModulePath(uri, specifier);
+        if (!path) return void 0;
+        const candidates = this.candidatesFor(path, specifier);
+        const target = candidates.find((candidate) => this.readFile(candidate) !== void 0);
         if (!target) {
-          for (const candidate of this.moduleCandidates(uri, specifier)) dependencies.set(candidate, void 0);
+          for (const candidate of candidates) dependencies.set(candidate, void 0);
           return void 0;
         }
         const exports = this.exportsOf(target, importing);
-        dependencies.set(target, this.sourceOf(target));
+        dependencies.set(target, this.readFile(target));
         return exports;
       }
     });
-    return { uri, version, source, program, parseErrors: errors, scopes, types, dependencies };
+    return { uri, version, source, program, parseErrors: errors, scopes, types, dependencies, project: context.project };
   }
   exportsOf(path, importing) {
     const key = pathKey(path);
-    if (importing.has(key)) return CYCLE;
-    const source = this.sourceOf(path);
+    if (importing.has(key)) {
+      this.run?.cycles.add(key);
+      return this.run?.provisional.get(key) ?? CYCLE;
+    }
+    const source = this.readFile(path);
     if (source === void 0) return void 0;
     const cached = this.modules.get(key);
     if (cached && cached.analysis.source === source && this.isFresh(cached.analysis)) return cached.exports;
     importing.add(key);
     try {
       const analysis = this.analyzeModule(uriOfPath(path), -1, source, importing);
-      const exports = moduleExports(analysis.program, analysis.scopes, analysis.types, (specifier) => {
-        const next = this.resolveModulePath(analysis.uri, specifier);
-        return next ? this.exportsOf(next, importing) : void 0;
-      });
+      const exports = this.exportsFrom(analysis, importing);
       this.modules.set(key, { analysis, exports });
+      this.run?.analyzed.add(key);
       return exports;
     } finally {
       importing.delete(key);
     }
   }
-  /** Does every module `analysis` imported — and everything those import —
-   *  still have the text it was analyzed against? */
+  /** Does every file `analysis` read — and everything the modules it
+   *  imported read — still have the text it was analyzed against? */
   isFresh(analysis, seen = /* @__PURE__ */ new Set()) {
     if (seen.has(analysis)) return true;
     seen.add(analysis);
     for (const [path, source] of analysis.dependencies) {
-      if (this.sourceOf(path) !== source) return false;
+      if (this.readFile(path) !== source) return false;
       const module = this.modules.get(pathKey(path));
       if (module && !this.isFresh(module.analysis, seen)) return false;
     }
     return true;
   }
 };
+function aliasesOf(libs) {
+  const empty = parse("");
+  return analyzeTypes(empty, analyzeScopes(empty, {}), { libs, diagnostics: false }).aliases;
+}
+function optionPosition(config, key) {
+  const offset = config.source.indexOf(JSON.stringify(key));
+  if (offset < 0) return { line: 1, column: 1 };
+  const before = config.source.slice(0, offset);
+  return { line: before.split("\n").length, column: offset - before.lastIndexOf("\n") };
+}
 
 // src/ast-utils.ts
 function isSpanned(v) {
@@ -203,16 +436,16 @@ function containsPosition(node, pos, inclusive = false) {
 }
 function children(node) {
   const out = [];
-  collect2(node, out);
+  collect(node, out);
   return out;
 }
-function collect2(container, out) {
+function collect(container, out) {
   for (const key of Object.keys(container)) {
     if (key === "line" || key === "column") continue;
     const value = container[key];
     for (const item of Array.isArray(value) ? value : [value]) {
       if (isSpanned(item)) out.push(item);
-      else if (isSpanlessNode(item)) collect2(item, out);
+      else if (isSpanlessNode(item)) collect(item, out);
     }
   }
 }
@@ -253,69 +486,6 @@ function walk(root, visit, parent) {
   for (const child of children(root)) walk(child, visit, root);
 }
 
-// src/features/members.ts
-import { formatType } from "luaut-parser";
-function membersOf(type, aliases, seen = /* @__PURE__ */ new Set()) {
-  if (!type || seen.has(type)) return [];
-  seen.add(type);
-  switch (type.kind) {
-    case "object": {
-      const out = [];
-      for (const [name, property] of type.properties) {
-        out.push({ name, property, isMethod: takesSelf(property.type) });
-      }
-      return out;
-    }
-    case "intersection": {
-      const merged = /* @__PURE__ */ new Map();
-      for (const part of type.types) {
-        for (const member of membersOf(part, aliases, seen)) merged.set(member.name, member);
-      }
-      return [...merged.values()];
-    }
-    case "union": {
-      const perBranch = type.types.map((part) => membersOf(part, aliases, seen));
-      if (!perBranch.length) return [];
-      const [first, ...rest] = perBranch;
-      return first.filter((member) => rest.every((other) => other.some((m) => m.name === member.name)));
-    }
-    case "genericRef": {
-      const alias = aliases.get(type.name);
-      return alias ? membersOf(alias, aliases, seen) : [];
-    }
-    case "typeParam":
-      return membersOf(type.constraint, aliases, seen);
-    default:
-      return [];
-  }
-}
-function takesSelf(type) {
-  for (const signature of signaturesOf(type)) {
-    if (signature.params[0]?.name === "self") return true;
-  }
-  return false;
-}
-function signaturesOf(type, aliases) {
-  if (!type) return [];
-  if (type.kind === "function") return [type];
-  if (type.kind === "intersection") return type.types.flatMap((t) => signaturesOf(t, aliases));
-  if (type.kind === "genericRef" && aliases) {
-    const alias = aliases.get(type.name);
-    return alias ? signaturesOf(alias, aliases) : [];
-  }
-  return [];
-}
-function signatureLabel(signature) {
-  const parameters = signature.params.map((p, i) => {
-    const name = p.name ?? `arg${i + 1}`;
-    return `${name}${p.optional ? "?" : ""}: ${formatType(p.type)}`;
-  });
-  const generics = signature.typeParams?.length ? `<${signature.typeParams.join(", ")}>` : "";
-  const varargs = signature.varargs ? [`...: ${formatType(signature.varargs)}`] : [];
-  const label = `${generics}(${[...parameters, ...varargs].join(", ")}) -> ${formatType(signature.returns)}`;
-  return { label, parameters };
-}
-
 // src/features/imports.ts
 import { readdirSync } from "fs";
 import { dirname as dirname2, resolve as resolve2 } from "path";
@@ -335,7 +505,7 @@ function importCompletion(analyzer, document, position) {
   const after = text.slice(cursor, lineEnd);
   if (!/^\s*(?:import|export)\b/.test(before)) return void 0;
   const path = /\bfrom\s*(["'])([^"']*)$/.exec(before);
-  if (path) return pathItems(document.uri, position, path[2]);
+  if (path) return pathItems(analyzer, document.uri, position, path[2]);
   const braces = /^\s*(import|export)\s+(?:[A-Za-z_][A-Za-z0-9_]*\s*,\s*)?\{[^}]*$/.exec(before);
   if (braces) {
     const module = /\}\s*from\s*(["'])([^"']+)\1/.exec(after);
@@ -344,21 +514,52 @@ function importCompletion(analyzer, document, position) {
   }
   return void 0;
 }
-function pathItems(fromUri, position, typed) {
+function pathItems(analyzer, fromUri, position, typed) {
   const from = pathOfUri(fromUri);
   if (!from) return [];
-  if (!typed.startsWith("./") && !typed.startsWith("../")) {
-    const range2 = rangeBack(position, typed.length);
-    return ["./", "../"].map((label) => ({
+  if (typed.startsWith("./") || typed.startsWith("../")) {
+    const slash = typed.lastIndexOf("/");
+    return entryItems(resolve2(dirname2(from), typed.slice(0, slash + 1)), rangeBack(position, typed.length - slash - 1), from);
+  }
+  const items = /* @__PURE__ */ new Map();
+  const whole = rangeBack(position, typed.length);
+  const offer = (label, folder) => {
+    if (!label.startsWith(typed) || label === typed) return;
+    items.set(label, {
       label,
-      kind: CompletionItemKind.Folder,
-      textEdit: { range: range2, newText: label },
-      command: SUGGEST_AGAIN
-    }));
+      kind: folder ? CompletionItemKind.Folder : CompletionItemKind.File,
+      textEdit: { range: whole, newText: label },
+      command: folder ? SUGGEST_AGAIN : void 0
+    });
+  };
+  offer("./", true);
+  offer("../", true);
+  const config = analyzer.projectOf(fromUri).config;
+  for (const [pattern, targets] of Object.entries(config?.paths ?? {})) {
+    const star = pattern.indexOf("*");
+    if (star < 0) {
+      offer(pattern, false);
+      continue;
+    }
+    const prefix = pattern.slice(0, star);
+    if (!typed.startsWith(prefix)) {
+      offer(prefix, true);
+      continue;
+    }
+    const rest = typed.slice(prefix.length);
+    const slash = rest.lastIndexOf("/");
+    const range = rangeBack(position, rest.length - slash - 1);
+    for (const target of targets) {
+      const cut = target.indexOf("*");
+      const head = cut < 0 ? target : target.slice(0, cut);
+      for (const item of entryItems(resolve2(config.baseUrl, head + rest.slice(0, slash + 1)), range, from)) {
+        items.set(item.label, item);
+      }
+    }
   }
-  const slash = typed.lastIndexOf("/");
-  const directory = resolve2(dirname2(from), typed.slice(0, slash + 1));
-  const range = rangeBack(position, typed.length - slash - 1);
+  return [...items.values()];
+}
+function entryItems(directory, range, from) {
   let entries;
   try {
     entries = readdirSync(directory, { withFileTypes: true });
@@ -564,7 +765,8 @@ 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);
@@ -615,6 +817,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);
@@ -671,9 +876,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)}`;
@@ -702,6 +909,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)}`;
 }
@@ -837,7 +1057,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) {
@@ -871,10 +1091,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,
@@ -1006,7 +1226,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 = [
@@ -1147,6 +1367,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;
@@ -1184,10 +1410,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",
@@ -1204,6 +1431,7 @@ var semanticTokensLegend = {
 var SOFT_KEYWORDS = /* @__PURE__ */ new Set([
   "type",
   "declare",
+  "class",
   "extends",
   "keyof",
   "infer",
@@ -1270,6 +1498,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"] : []);
       }
@@ -1297,6 +1527,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;
@@ -1413,6 +1646,7 @@ function encode(entries) {
 // src/server.ts
 import {
   createConnection,
+  DiagnosticSeverity as DiagnosticSeverity2,
   ProposedFeatures,
   TextDocuments,
   TextDocumentSyncKind
@@ -1454,17 +1688,56 @@ function createServer(connection, options = {}) {
     const document = documents.get(p.textDocument.uri);
     return document ? semanticTokens(analyzer.get(document)) : { data: [] };
   });
-  const publish = (document) => {
-    void connection.sendDiagnostics({
-      uri: document.uri,
-      version: document.version,
-      diagnostics: diagnostics(analyzer.get(document))
-    });
-  };
-  documents.onDidOpen((e) => publish(e.document));
+  let configUris = /* @__PURE__ */ new Set();
   const publishAll = () => {
-    for (const document of documents.all()) publish(document);
+    const problems = /* @__PURE__ */ new Map();
+    for (const document of documents.all()) {
+      const analysis = analyzer.get(document);
+      void connection.sendDiagnostics({
+        uri: document.uri,
+        version: document.version,
+        diagnostics: [...diagnostics(analysis), ...projectHint(analysis)]
+      });
+      for (const problem of analysis.project.problems) {
+        const uri = uriOfPath(problem.file);
+        const list = problems.get(uri) ?? [];
+        if (!list.some((p) => p.message === problem.message && p.line === problem.line)) list.push(problem);
+        problems.set(uri, list);
+      }
+    }
+    for (const [uri, list] of problems) {
+      void connection.sendDiagnostics({ uri, diagnostics: list.map(problemDiagnostic) });
+    }
+    for (const uri of configUris) {
+      if (!problems.has(uri)) void connection.sendDiagnostics({ uri, diagnostics: [] });
+    }
+    configUris = new Set(problems.keys());
   };
+  const problemDiagnostic = (problem) => {
+    const line = Math.max((problem.line ?? 1) - 1, 0);
+    const character = Math.max((problem.column ?? 1) - 1, 0);
+    const text = analyzer.readFile(problem.file)?.split("\n")[line] ?? "";
+    const end = Math.max(text.replace(/\r$/, "").trimEnd().length, character + 1);
+    return {
+      range: { start: { line, character }, end: { line, character: end } },
+      severity: DiagnosticSeverity2.Error,
+      source: "luaut",
+      code: "config",
+      message: problem.message
+    };
+  };
+  const projectHint = (analysis) => {
+    const { project } = analysis;
+    if (project.fixed || project.config || !pathOfUri(analysis.uri)) return [];
+    return [{
+      range: { start: { line: 0, character: 0 }, end: { line: 0, character: 0 } },
+      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 }'
+    }];
+  };
+  documents.onDidOpen(publishAll);
   documents.onDidChangeContent(publishAll);
   connection.onDidChangeWatchedFiles(publishAll);
   documents.onDidClose((e) => {
@@ -1535,6 +1808,9 @@ function startServer(options = {}) {
 }
 
 export {
+  membersOf,
+  signaturesOf,
+  signatureLabel,
   pathOfUri,
   uriOfPath,
   samePath,
@@ -1547,9 +1823,6 @@ export {
   nodeAt,
   enclosing,
   walk,
-  membersOf,
-  signaturesOf,
-  signatureLabel,
   importCompletion,
   importDefinition,
   exportDeclaration,
@@ -1569,4 +1842,4 @@ export {
   createServer,
   startServer
 };
-//# sourceMappingURL=chunk-OQWE7ISD.js.map
+//# sourceMappingURL=chunk-HJ2C3OFZ.js.map