luaut-parser 1.0.0 → 1.2.0

package/dist/index.js

@@ -541,6 +541,17 @@ function spanFrom(start, end) {
     column: { start: start.column.start, end: end.column.end }
   };
 }
+function tokenIdentifier(t) {
+  return { type: "Identifier", name: t.value, ...spanFrom(t, t) };
+}
+function nameIdentifier(name, at) {
+  return {
+    type: "Identifier",
+    name,
+    line: { start: at.line.start, end: at.line.start },
+    column: { start: at.column.start, end: at.column.start + name.length }
+  };
+}
 var BINARY_PRECEDENCE = {
   "or": 1,
   "and": 2,
@@ -859,9 +870,11 @@ var Parser = class {
       const params = head.params.map((p) => ({
         type: "FunctionTypeParameter",
         name: p.name || void 0,
+        id: p.name ? nameIdentifier(p.name, p) : void 0,
         optional: p.optional,
-        typeAnnotation: p.typeAnnotation ?? { type: "TypeReference", base: "any", typeArguments: [], ...spanFrom(start, start) },
-        ...spanFrom(start, this.previous())
+        typeAnnotation: p.typeAnnotation ?? { type: "TypeReference", base: "any", typeArguments: [], line: p.line, column: p.column },
+        line: p.line,
+        column: p.column
       }));
       const valueType2 = {
         type: "FunctionTypeNode",
@@ -873,12 +886,12 @@ var Parser = class {
         predicate: head.predicate,
         ...spanFrom(start, this.previous())
       };
-      return { type: "DeclareStatement", name: nameTok2.value, valueType: valueType2, ...spanFrom(start, this.previous()) };
+      return { type: "DeclareStatement", name: nameTok2.value, id: tokenIdentifier(nameTok2), valueType: valueType2, ...spanFrom(start, this.previous()) };
     }
     const nameTok = this.expectIdentifier();
     this.expectPunctuator(":");
     const valueType = this.parseType();
-    return { type: "DeclareStatement", name: nameTok.value, valueType, ...spanFrom(start, this.previous()) };
+    return { type: "DeclareStatement", name: nameTok.value, id: tokenIdentifier(nameTok), valueType, ...spanFrom(start, this.previous()) };
   }
   // `import { a, b as c } from '...'` / `import Default from '...'` /
   // `import Default, { a } from '...'`. Compiled away entirely by the
@@ -937,6 +950,21 @@ var Parser = class {
     }
     return { type: "ImportSpecifier", imported, local, ...spanFrom(imported, local) };
   }
+  /** `from "<path>"`: consumes `from` and the module string. */
+  parseModuleSource() {
+    this.advance();
+    const sourceTok = this.current();
+    if (sourceTok.type !== "Literal" || sourceTok.kind !== "string") {
+      this.error("Expected string literal module path after 'from'");
+    }
+    this.advance();
+    return {
+      type: "StringLiteral",
+      value: sourceTok.value,
+      raw: sourceTok.raw,
+      ...spanFrom(sourceTok, sourceTok)
+    };
+  }
   // `export const ...` / `export let ...` / `export const function ...` /
   // `export type ...` / `export default <expr>`
   parseExportStatement() {
@@ -955,7 +983,30 @@ var Parser = class {
       const declaration = this.parseVariableDeclaration();
       return { type: "ExportStatement", declaration, ...spanFrom(start, this.previous()) };
     }
-    this.error("Expected 'const', 'let', 'type', or 'default' after 'export'");
+    if (this.checkPunctuator("{")) {
+      this.advance();
+      const specifiers = [];
+      while (!this.checkPunctuator("}")) {
+        const local = this.parseIdentifier();
+        let exported = local;
+        if (this.checkKeyword("as")) {
+          this.advance();
+          exported = this.parseIdentifier();
+        }
+        specifiers.push({ type: "ExportSpecifier", local, exported, ...spanFrom(local, exported) });
+        if (!this.matchPunctuator(",")) break;
+      }
+      this.expectPunctuator("}");
+      const source = this.checkKeyword("from") ? this.parseModuleSource() : void 0;
+      return { type: "ExportNamedStatement", specifiers, source, ...spanFrom(start, this.previous()) };
+    }
+    if (this.checkOperator("*")) {
+      this.advance();
+      if (!this.checkKeyword("from")) this.error("Expected 'from' after 'export *'");
+      const source = this.parseModuleSource();
+      return { type: "ExportAllStatement", source, ...spanFrom(start, this.previous()) };
+    }
+    this.error("Expected 'const', 'let', 'type', 'default', '{' or '*' after 'export'");
   }
   // `const x = ...` / `let x, y = ...` / `const function f() ... end`.
   // luaut has no `local` — `const` bindings are immutable, `let` mutable.
@@ -1989,8 +2040,9 @@ var Parser = class {
     }
     if (this.checkIdentifierValue("infer") && this.peek(1).type === "Identifier") {
       this.advance();
-      const name = this.expectIdentifier().value;
-      return { type: "InferTypeNode", name, ...spanFrom(t, this.previous()) };
+      const nameTok = this.expectIdentifier();
+      const name = nameTok.value;
+      return { type: "InferTypeNode", name, id: tokenIdentifier(nameTok), ...spanFrom(t, this.previous()) };
     }
     if (t.type === "Operator" && t.value === "<") {
       const generics = this.parseGenericTypeParameterList();
@@ -2027,6 +2079,16 @@ var Parser = class {
       this.expectPunctuator(")");
       return { type: "TypeofTypeNode", expression, ...spanFrom(t, this.previous()) };
     }
+    if (t.type === "Identifier" && t.value === "typeof" && this.peek(1).type === "Identifier") {
+      this.advance();
+      let expression = this.parseIdentifier();
+      while (this.checkPunctuator(".") && this.peek(1).type === "Identifier") {
+        this.advance();
+        const property = this.parseIdentifier();
+        expression = { type: "MemberExpression", object: expression, property, ...spanFrom(expression, property) };
+      }
+      return { type: "TypeofTypeNode", expression, ...spanFrom(t, this.previous()) };
+    }
     if (t.type === "Literal" && t.kind === "string") {
       this.advance();
       return { type: "TypeLiteralString", value: t.value, ...spanFrom(t, t) };
@@ -2089,17 +2151,21 @@ var Parser = class {
         let name;
         let optional2 = false;
         const named = this.checkType("Identifier") && this.peek(1).type === "Punctuator" && (this.peek(1).value === ":" || this.peek(1).value === "?" && this.peek(2).type === "Punctuator" && this.peek(2).value === ":");
+        let nameTok;
         if (named) {
-          name = this.expectIdentifier().value;
+          const tok = this.expectIdentifier();
+          nameTok = tok;
+          name = tok.value;
           optional2 = this.matchPunctuator("?");
           this.advance();
         }
-        const paramStart = this.current();
+        const paramStart = nameTok ?? this.current();
         const typeAnnotation = this.parseType();
         params.push({
           type: "FunctionTypeParameter",
           name,
           typeAnnotation,
+          id: nameTok && tokenIdentifier(nameTok),
           optional: optional2 || void 0,
           ...spanFrom(paramStart, this.previous())
         });
@@ -2161,7 +2227,8 @@ var Parser = class {
       readonly = false;
     }
     this.expectPunctuator("[");
-    const parameter = this.expectIdentifier().value;
+    const parameterTok = this.expectIdentifier();
+    const parameter = parameterTok.value;
     this.advance();
     const constraint = this.parseType();
     let nameType;
@@ -2185,6 +2252,7 @@ var Parser = class {
     return {
       type: "MappedTypeNode",
       parameter,
+      parameterId: tokenIdentifier(parameterTok),
       constraint,
       nameType,
       template,
@@ -2211,30 +2279,43 @@ var Parser = class {
     this.expectPunctuator("{");
     const properties = [];
     while (!this.checkPunctuator("}")) {
+      const propStart = this.current();
       if (this.checkPunctuator("[")) {
         this.advance();
         const keyType = this.parseType();
         this.expectPunctuator("]");
         this.expectPunctuator(":");
         const valueType = this.parseType();
-        properties.push({ type: "TableTypeIndexer", keyType, valueType });
+        properties.push({ type: "TableTypeIndexer", keyType, valueType, ...spanFrom(propStart, this.previous()) });
       } else if (this.checkIdentifierValue("readonly") && this.peek(1).type === "Identifier") {
         this.advance();
-        const name = this.expectIdentifier().value;
+        const keyTok = this.expectIdentifier();
+        const name = keyTok.value;
         const optional2 = this.matchPunctuator("?");
         this.expectPunctuator(":");
         const valueType = this.parseType();
-        properties.push({ type: "TableTypeProperty", name, valueType, optional: optional2, readonly: true });
+        properties.push({
+          type: "TableTypeProperty",
+          name,
+          key: tokenIdentifier(keyTok),
+          valueType,
+          optional: optional2,
+          readonly: true,
+          ...spanFrom(propStart, this.previous())
+        });
       } else if (this.checkType("Identifier") && (this.peek(1).type === "Punctuator" && this.peek(1).value === ":" || this.peek(1).type === "Punctuator" && this.peek(1).value === "?" && this.peek(2).type === "Punctuator" && this.peek(2).value === ":")) {
-        const name = this.expectIdentifier().value;
+        const keyTok = this.expectIdentifier();
+        const name = keyTok.value;
         const optional2 = this.matchPunctuator("?");
         this.expectPunctuator(":");
         const valueType = this.parseType();
         properties.push({
           type: "TableTypeProperty",
           name,
+          key: tokenIdentifier(keyTok),
           valueType,
-          optional: optional2
+          optional: optional2,
+          ...spanFrom(propStart, this.previous())
         });
       } else {
         this.error("Expected object type property ('name: T' or '[K]: V'); use 'T[]' for arrays and '[T, U]' for tuples");
@@ -2296,6 +2377,7 @@ var Parser = class {
       list.push({
         type: "GenericTypeParameter",
         name: nameTok.value,
+        id: tokenIdentifier(nameTok),
         isPack,
         isConst: isConst || void 0,
         constraint,
@@ -2425,6 +2507,15 @@ var Analyzer = class {
     }
     return this.getOrCreateGlobalBinding(name);
   }
+  /** Like `resolve`, but never creates a global: `undefined` when no
+   *  enclosing scope declares the name. */
+  lookup(scope, name) {
+    for (let s = scope; s; s = s.parent) {
+      const id = s.declarations.get(name);
+      if (id !== void 0) return id;
+    }
+    return void 0;
+  }
   getOrCreateGlobalBinding(name) {
     const existing = this.globalScope.declarations.get(name);
     if (existing !== void 0) return existing;
@@ -2540,12 +2631,14 @@ var Analyzer = class {
     switch (stmt.type) {
       case "VariableDeclaration": {
         for (const init of stmt.init) this.visitExpression(init, scope);
+        for (const name of stmt.names) this.visitType(name.typeAnnotation, scope);
         const isConst = stmt.kind === "const";
         for (const name of stmt.names) this.declarePattern(scope, name, "local", scope, isConst);
         return;
       }
       case "FunctionDeclaration": {
         this.declare(scope, stmt.name.name, "local", stmt.name, stmt.kind === "const");
+        for (const signature of stmt.signatures ?? []) this.visitSignature(signature, scope);
         this.visitFunctionBody(stmt.func, scope);
         return;
       }
@@ -2555,6 +2648,7 @@ var Analyzer = class {
         } else {
           this.reference(scope, stmt.target.base);
         }
+        for (const signature of stmt.signatures ?? []) this.visitSignature(signature, scope);
         this.visitFunctionBody(stmt.func, scope, stmt.isMethod);
         return;
       }
@@ -2628,10 +2722,13 @@ var Analyzer = class {
       case "BreakStatement":
       case "ContinueStatement":
       case "ErrorStatement":
+        return;
       case "DeclareStatement":
+        this.visitType(stmt.valueType, scope);
         return;
       case "TypeAliasStatement":
       case "ExportTypeAliasStatement":
+        this.visitType(stmt.definition, scope);
         return;
       case "ImportStatement": {
         if (stmt.defaultImport) {
@@ -2648,6 +2745,18 @@ var Analyzer = class {
       case "ExportDefaultStatement":
         this.visitExpression(stmt.declaration, scope);
         return;
+      case "ExportNamedStatement":
+        if (!stmt.source) {
+          for (const specifier of stmt.specifiers) {
+            const id = this.lookup(scope, specifier.local.name);
+            if (id === void 0) continue;
+            this.bindingOf.set(specifier.local, id);
+            this.bindings.get(id).references.push(specifier.local);
+          }
+        }
+        return;
+      case "ExportAllStatement":
+        return;
     }
   }
   // ---------------- functions ----------------
@@ -2655,6 +2764,7 @@ var Analyzer = class {
     const fnScope = childScope(outerScope);
     func.params.forEach((param, i) => {
       const kind = isMethod && i === 0 ? "self" : "param";
+      this.visitType(param.typeAnnotation, fnScope);
       if (param.default) this.visitExpression(param.default, fnScope);
       if (param.pattern) {
         this.declarePattern(fnScope, param.pattern, kind, fnScope);
@@ -2662,8 +2772,37 @@ var Analyzer = class {
         this.declare(fnScope, param.name, kind, param);
       }
     });
+    this.visitType(func.varargTypeAnnotation, fnScope);
+    this.visitType(func.returnType, fnScope);
     this.visitBlock(func.body, fnScope);
   }
+  /** An overload signature: no body and no bindings, but its types can hold
+   *  a `typeof x`. */
+  visitSignature(signature, scope) {
+    for (const param of signature.params) this.visitType(param.typeAnnotation, scope);
+    this.visitType(signature.returnType, scope);
+  }
+  /** Resolve the value references inside a type. Only `typeof x` has any —
+   *  everything else in a type names types, which live in their own
+   *  namespace and are not this pass's business. */
+  visitType(node, scope) {
+    if (!node) return;
+    const walk = (value) => {
+      if (!value || typeof value !== "object") return;
+      if (Array.isArray(value)) {
+        for (const item of value) walk(item);
+        return;
+      }
+      if (value.type === "TypeofTypeNode") {
+        this.visitExpression(value.expression, scope);
+        return;
+      }
+      for (const key of Object.keys(value)) {
+        if (key !== "line" && key !== "column") walk(value[key]);
+      }
+    };
+    walk(node);
+  }
   // ---------------- expressions ----------------
   visitExpression(expr, scope) {
     switch (expr.type) {
@@ -2722,6 +2861,11 @@ var Analyzer = class {
         return;
       case "TypeAssertionExpression":
         this.visitExpression(expr.expression, scope);
+        this.visitType(expr.typeAnnotation, scope);
+        return;
+      case "SatisfiesExpression":
+        this.visitExpression(expr.expression, scope);
+        this.visitType(expr.typeAnnotation, scope);
         return;
       case "IfElseExpression":
         for (const clause of expr.clauses) {
@@ -3392,6 +3536,94 @@ function formatKey(k) {
 function analyzeTypes(program, scopes, options = {}) {
   return new TypeAnalyzer(program, scopes, options).run();
 }
+function moduleExports(program, scopes, types, resolveModule) {
+  const byDeclaration = /* @__PURE__ */ new Map();
+  for (const binding of scopes.bindings.values()) {
+    if (binding.declarationNode) byDeclaration.set(binding.declarationNode, binding.id);
+  }
+  const values = /* @__PURE__ */ new Map();
+  const exportedTypes = /* @__PURE__ */ new Map();
+  let defaultType;
+  const stars = [];
+  const setValue = (name, type) => {
+    if (name === "default") defaultType = type;
+    else values.set(name, type);
+  };
+  const reexport = (from, name, as) => {
+    if (!from || from.partial) {
+      setValue(as, anyType);
+      return;
+    }
+    if (name === "default") {
+      if (from.default) setValue(as, from.default);
+      return;
+    }
+    const value = from.values.get(name);
+    if (value) setValue(as, value);
+    const type = from.types.get(name);
+    if (type) exportedTypes.set(as, type);
+  };
+  const aliasParams = (name) => {
+    for (const s of program.body.statements) {
+      const alias = s.type === "TypeAliasStatement" ? s : s.type === "ExportTypeAliasStatement" ? s.alias : void 0;
+      if (alias?.name.name === name) return alias.generics.map((g) => g.name);
+    }
+    return [];
+  };
+  const exportName = (declaration, name) => {
+    const id = byDeclaration.get(declaration);
+    values.set(name, (id !== void 0 ? types.bindingType.get(id) : void 0) ?? anyType);
+  };
+  const exportPattern = (target) => {
+    switch (target.type) {
+      case "IdentifierPattern":
+        exportName(target, target.name);
+        return;
+      case "ObjectPattern":
+        for (const p of target.properties) exportPattern(p.value);
+        if (target.rest) exportPattern(target.rest);
+        return;
+      case "ArrayPattern":
+        for (const el of target.elements) if (el) exportPattern(el.value);
+        if (target.rest) exportPattern(target.rest);
+        return;
+    }
+  };
+  for (const stmt of program.body.statements) {
+    if (stmt.type === "ExportStatement") {
+      const declaration = stmt.declaration;
+      if (declaration.type === "FunctionDeclaration") exportName(declaration.name, declaration.name.name);
+      else for (const target of declaration.names) exportPattern(target);
+    } else if (stmt.type === "ExportTypeAliasStatement") {
+      const name = stmt.alias.name.name;
+      const type = types.aliases.get(name);
+      if (type) exportedTypes.set(name, { type, params: stmt.alias.generics.map((g) => g.name) });
+    } else if (stmt.type === "ExportDefaultStatement") {
+      defaultType = types.typeOf.get(stmt.declaration) ?? anyType;
+    } else if (stmt.type === "ExportNamedStatement") {
+      if (stmt.source) {
+        const from = resolveModule?.(stmt.source.value);
+        for (const s of stmt.specifiers) reexport(from, s.local.name, s.exported.name);
+      } else {
+        for (const s of stmt.specifiers) {
+          const id = scopes.bindingOf.get(s.local);
+          if (id !== void 0) setValue(s.exported.name, types.bindingType.get(id) ?? anyType);
+          const alias = types.aliases.get(s.local.name);
+          if (alias) exportedTypes.set(s.exported.name, { type: alias, params: aliasParams(s.local.name) });
+        }
+      }
+    } else if (stmt.type === "ExportAllStatement") {
+      stars.push(stmt.source.value);
+    }
+  }
+  for (const specifier of stars) {
+    const from = resolveModule?.(specifier);
+    if (!from || from.partial) continue;
+    for (const [name, type] of from.values) if (!values.has(name)) values.set(name, type);
+    for (const [name, type] of from.types) if (!exportedTypes.has(name)) exportedTypes.set(name, type);
+  }
+  return { values, types: exportedTypes, default: defaultType };
+}
 function bindKey(id) {
   return `$${id}`;
 }
@@ -3505,6 +3737,8 @@ var TypeAnalyzer = class {
   typeOf = /* @__PURE__ */ new Map();
   bindingType = /* @__PURE__ */ new Map();
   narrowedTypeOf = /* @__PURE__ */ new Map();
+  typeOfTypeNode = /* @__PURE__ */ new Map();
+  expectedTypeOf = /* @__PURE__ */ new Map();
   /** Public: each alias resolved once (generic aliases keep their params as
    *  `typeParam` nodes in the body). */
   aliases = /* @__PURE__ */ new Map();
@@ -3539,6 +3773,10 @@ var TypeAnalyzer = class {
    *  (`type Tree = { children: Tree[] }`); it resolves to a nominal ref. */
   resolvingAliases = /* @__PURE__ */ new Set();
   diagnostics = [];
+  /** `import`ed type names, from `resolveModule`. */
+  importedTypes = /* @__PURE__ */ new Map();
+  /** `resolveModule` results, one lookup per module path. */
+  resolvedModules = /* @__PURE__ */ new Map();
   emitDiagnostics;
   /** Recursion guard for `preVisitBody`. */
   preVisitDepth = 0;
@@ -3547,6 +3785,7 @@ var TypeAnalyzer = class {
     this.registerAliasDefs(this.program.body);
     for (const lib of this.options.libs ?? []) this.harvestDeclares(lib.body);
     this.harvestDeclares(this.program.body);
+    this.registerImportedTypes();
     this.resolveAllAliases();
     this.indexDeclarations();
     for (const [name, id] of this.scopes.globalsByName) {
@@ -3564,13 +3803,52 @@ var TypeAnalyzer = class {
       typeOf: this.typeOf,
       bindingType: this.bindingType,
       narrowedTypeOf: this.narrowedTypeOf,
-      aliases: this.aliases,
+      typeOfTypeNode: this.typeOfTypeNode,
+      expectedTypeOf: this.expectedTypeOf,
+      aliases: this.resolveDeferredAliases(),
       diagnostics: this.diagnostics
     };
   }
   // --------------------------------------------------------
   // Aliases
   // --------------------------------------------------------
+  moduleFor(specifier) {
+    if (!this.resolvedModules.has(specifier)) {
+      this.resolvedModules.set(specifier, this.options.resolveModule?.(specifier));
+    }
+    return this.resolvedModules.get(specifier);
+  }
+  /** `export ... from "./x"`: the module must exist, and so must each name. */
+  checkReexport(source, names) {
+    if (!this.options.resolveModule || !this.emitDiagnostics) return;
+    const exports = this.moduleFor(source.value);
+    if (!exports) {
+      this.diagnostics.push({ node: source, message: `Cannot find module '${source.value}'` });
+      return;
+    }
+    if (exports.partial) return;
+    for (const name of names) {
+      const found = name.name === "default" ? exports.default !== void 0 : exports.values.has(name.name) || exports.types.has(name.name);
+      if (!found) {
+        this.diagnostics.push({ node: name, message: `Module '${source.value}' has no exported member '${name.name}'` });
+      }
+    }
+  }
+  registerImportedTypes() {
+    if (!this.options.resolveModule) return;
+    for (const stmt of this.program.body.statements) {
+      if (stmt.type !== "ImportStatement") continue;
+      const exports = this.moduleFor(stmt.source.value);
+      if (!exports) continue;
+      for (const s of stmt.specifiers) {
+        const exported = exports.types.get(s.imported.name);
+        if (exported) {
+          this.importedTypes.set(s.local.name, exported);
+          this.aliases.set(s.local.name, exported.type);
+        }
+      }
+    }
+  }
   registerAliasDefs(block) {
     for (const stmt of block.statements) {
       const alias = stmt.type === "TypeAliasStatement" ? stmt : stmt.type === "ExportTypeAliasStatement" ? stmt.alias : void 0;
@@ -3590,11 +3868,23 @@ var TypeAnalyzer = class {
   }
   resolveAllAliases() {
     for (const [name, def] of this.aliasDefs) {
+      if (containsTypeQuery(def.node)) continue;
       this.withTypeParams(def.params, () => {
         this.aliases.set(name, this.resolveType(def.node));
       });
     }
   }
+  /** The aliases `resolveAllAliases` left for later, now that every binding
+   *  has its type. */
+  resolveDeferredAliases() {
+    for (const [name, def] of this.aliasDefs) {
+      if (this.aliases.has(name)) continue;
+      this.withTypeParams(def.params, () => {
+        this.aliases.set(name, this.resolveType(def.node));
+      });
+    }
+    return this.aliases;
+  }
   withTypeParams(params, fn2) {
     const start = this.typeParamScope.length;
     for (const p of params) this.typeParamScope.push({ name: p.name, isConst: p.isConst });
@@ -3634,6 +3924,11 @@ var TypeAnalyzer = class {
   // TypeNode -> Type
   // --------------------------------------------------------
   resolveType(node) {
+    const type = this.resolveTypeNode(node);
+    if (this.instantiationDepth === 0) this.typeOfTypeNode.set(node, type);
+    return type;
+  }
+  resolveTypeNode(node) {
     switch (node.type) {
       case "TypeReference": {
         const name = node.namespace ? `${node.namespace}.${node.base}` : node.base;
@@ -3674,6 +3969,16 @@ var TypeAnalyzer = class {
               typeArguments: node.typeArguments.map((a) => this.resolveType(a))
             });
           }
+          const imported = this.importedTypes.get(node.base);
+          if (imported) {
+            if (!imported.params.length) return imported.type;
+            const subst = /* @__PURE__ */ new Map();
+            imported.params.forEach((name2, i) => {
+              const arg = node.typeArguments[i];
+              subst.set(name2, arg ? this.resolveType(arg) : unknownType);
+            });
+            return this.reduceType(substitute(imported.type, subst));
+          }
           const lib = this.options.libTypes?.[node.base];
           if (lib) return lib;
         }
@@ -4226,11 +4531,49 @@ var TypeAnalyzer = class {
       case "ExportDefaultStatement":
         this.infer(stmt.declaration, env);
         return;
+      case "ExportNamedStatement": {
+        if (stmt.source) {
+          this.checkReexport(stmt.source, stmt.specifiers.map((s) => s.local));
+          return;
+        }
+        for (const s of stmt.specifiers) {
+          if (this.bindingIdOf(s.local) !== void 0) {
+            this.infer(s.local, env);
+          } else if (!this.aliasDefs.has(s.local.name) && !this.importedTypes.has(s.local.name)) {
+            if (this.emitDiagnostics) {
+              this.diagnostics.push({ node: s.local, message: `Cannot find name '${s.local.name}' to export` });
+            }
+          }
+        }
+        return;
+      }
+      case "ExportAllStatement":
+        this.checkReexport(stmt.source, []);
+        return;
       case "ImportStatement": {
-        const ids = [];
-        if (stmt.defaultImport) ids.push(this.bindingIdOf(stmt.defaultImport));
-        for (const s of stmt.specifiers) ids.push(this.bindingIdOf(s.local));
-        for (const id of ids) if (id !== void 0) this.bindingType.set(id, anyType);
+        const resolving = this.options.resolveModule !== void 0;
+        const exports = resolving ? this.moduleFor(stmt.source.value) : void 0;
+        const specifier = stmt.source.value;
+        const report = (node, message) => {
+          if (this.emitDiagnostics) this.diagnostics.push({ node, message });
+        };
+        if (resolving && !exports) report(stmt.source, `Cannot find module '${specifier}'`);
+        const usable = exports && !exports.partial ? exports : void 0;
+        if (stmt.defaultImport) {
+          if (usable && usable.default === void 0) {
+            report(stmt.defaultImport, `Module '${specifier}' has no default export`);
+          }
+          const id = this.bindingIdByName(stmt.defaultImport.name, stmt.defaultImport);
+          if (id !== void 0) this.bindingType.set(id, usable?.default ?? anyType);
+        }
+        for (const s of stmt.specifiers) {
+          const value = usable?.values.get(s.imported.name);
+          if (usable && !value && !usable.types.has(s.imported.name)) {
+            report(s.imported, `Module '${specifier}' has no exported member '${s.imported.name}'`);
+          }
+          const id = this.bindingIdByName(s.local.name, s.local);
+          if (id !== void 0) this.bindingType.set(id, value ?? anyType);
+        }
         return;
       }
       case "BreakStatement":
@@ -4443,16 +4786,76 @@ var TypeAnalyzer = class {
     return void 0;
   }
   /** Can this signature be called with these argument types? The signature's
-   *  own generic parameters act as wildcards — they are what the call would
-   *  infer, so they must not make the match fail. */
+   *  own type parameters stand for what the call would infer, so each is
+   *  checked only against its constraint — `<K extends keyof Services>`
+   *  accepts `"Players"` but not `""`. */
   overloadAccepts(f, argTypes) {
     if (!f.varargs && argTypes.length > f.params.length) return false;
-    const wildcards = new Map((f.typeParams ?? []).map((n) => [n, anyType]));
+    const params = this.boundParams(f);
     return f.params.every((p, i) => {
       if (argTypes[i] === void 0) return p.optional === true;
-      return isAssignable(argTypes[i], substitute(p.type, wildcards));
+      return isAssignable(argTypes[i], params[i]);
+    });
+  }
+  /** A signature's parameter types as a call site sees them before inference:
+   *  each type parameter replaced by its constraint, or by `any` when it has
+   *  none — or when the constraint mentions another type parameter, which a
+   *  lone argument cannot be checked against without false errors. */
+  boundParams(f) {
+    if (!f.typeParams?.length) return f.params.map((p) => p.type);
+    const bounds = new Map(f.typeParams.map((name) => [name, anyType]));
+    const seen = /* @__PURE__ */ new WeakSet();
+    const walk = (value) => {
+      if (!value || typeof value !== "object" || seen.has(value)) return;
+      seen.add(value);
+      if (value instanceof Map) {
+        value.forEach(walk);
+        return;
+      }
+      const t = value;
+      if (t.kind === "typeParam" && typeof t.name === "string" && bounds.has(t.name) && t.constraint && !containsTypeParam(t.constraint)) {
+        bounds.set(t.name, this.reduceType(t.constraint));
+      }
+      for (const child of Object.values(value)) walk(child);
+    };
+    for (const p of f.params) walk(p.type);
+    return f.params.map((p) => substitute(p.type, bounds));
+  }
+  /** Record what each written argument is expected to be — see
+   *  `TypeAnalysis.expectedTypeOf`. */
+  recordExpected(written, fns, selfOf) {
+    written.forEach((arg, j) => {
+      const candidates = [];
+      for (const f of fns) {
+        const i = j + selfOf(f);
+        const param = i < f.params.length ? this.boundParams(f)[i] : f.varargs;
+        if (param) candidates.push(param);
+      }
+      if (candidates.length) this.expectedTypeOf.set(arg, union(candidates));
     });
   }
+  /** No signature accepts the call, and the argument count is not the
+   *  problem: say which argument is wrong, the way TypeScript does. */
+  reportArguments(call, written, fns, argsFor, selfOf) {
+    if (!this.emitDiagnostics) return;
+    if (fns.length > 1) {
+      this.diagnostics.push({ node: call, message: "No overload matches this call" });
+      return;
+    }
+    const f = fns[0];
+    const args = argsFor(f);
+    const params = this.boundParams(f);
+    const self = selfOf(f);
+    for (let i = 0; i < f.params.length; i++) {
+      const arg = args[i];
+      if (arg === void 0 || isAssignable(arg, params[i])) continue;
+      this.diagnostics.push({
+        node: written[i - self] ?? call,
+        message: `Argument of type '${formatType(arg)}' is not assignable to parameter of type '${briefType(params[i])}'`
+      });
+      return;
+    }
+  }
   /** A required parameter may not follow an optional one — otherwise the
    *  optional one could never actually be omitted. Same rule as TypeScript,
    *  and it applies to a default (`a = 1`) as much as to a `?`. */
@@ -4482,22 +4885,25 @@ var TypeAnalyzer = class {
     return { min, max: f.varargs ? void 0 : f.params.length };
   }
   /** Report a call that passes too few or too many arguments. Only fires
-   *  when *no* overload accepts the call, so an overload set still reports
-   *  once, against its first signature. */
+   *  when *no* overload accepts the count, so an overload set still reports
+   *  once, against its first signature. Returns whether the count fits, so
+   *  an argument's type is only complained about when its count is right. */
   checkArity(node, fns, argCount, selfArgs) {
-    if (!this.emitDiagnostics || !fns.length) return;
+    if (!fns.length) return true;
     const fits = fns.some((f) => {
       const { min: min2, max: max2 } = this.arityOf(f);
       const n = argCount + selfArgs;
       return n >= min2 && (max2 === void 0 || n <= max2);
     });
-    if (fits) return;
+    if (fits) return true;
+    if (!this.emitDiagnostics) return false;
     const { min, max } = this.arityOf(fns[0]);
     const need = max === void 0 ? `at least ${min - selfArgs}` : min === max ? `${min - selfArgs}` : `${min - selfArgs}-${max - selfArgs}`;
     this.diagnostics.push({
       node,
       message: `Expected ${need} argument${need === "1" ? "" : "s"}, got ${argCount}`
     });
+    return false;
   }
   signatureToFnType(sig) {
     const names = sig.generics.map((g) => g.name);
@@ -4533,11 +4939,18 @@ var TypeAnalyzer = class {
   inferFunctionBody(func, env) {
     const names = func.generics.map((g) => g.name);
     return this.withTypeParams(func.generics, () => {
-      const params = func.params.map((p) => ({
-        name: p.pattern ? void 0 : p.name,
-        type: this.paramType(p, env),
-        optional: p.optional || p.default !== void 0
-      }));
+      const params = func.params.map((p) => {
+        const type = this.paramType(p, env);
+        if (!p.pattern) {
+          const id = this.bindingIdByName(p.name, p);
+          if (id !== void 0 && !this.bindingType.has(id)) this.bindingType.set(id, type);
+        }
+        return {
+          name: p.pattern ? void 0 : p.name,
+          type,
+          optional: p.optional || p.default !== void 0
+        };
+      });
       const bodyEnv = forkEnv(env);
       for (const p of func.params) {
         if (p.pattern) this.bindPattern(p.pattern, this.paramType(p, bodyEnv), bodyEnv, "widen");
@@ -4928,11 +5341,13 @@ var TypeAnalyzer = class {
         const argTypes = expr.arguments.map((a) => this.infer(a, env));
         const fns = this.overloadsOf(callee);
         if (fns.length) {
-          this.checkArity(expr, fns, argTypes.length, 0);
+          this.recordExpected(expr.arguments, fns, () => 0);
+          const arityFits = this.checkArity(expr, fns, argTypes.length, 0);
           const picked = this.pickOverload(fns, argTypes);
           if (picked) {
             return this.callReturn(picked, this.constArgs(picked, expr.arguments, argTypes, env));
           }
+          if (arityFits) this.reportArguments(expr, expr.arguments, fns, () => argTypes, () => 0);
           return union(fns.map((f) => this.callReturn(f, argTypes)));
         }
         return callee.kind === "any" ? anyType : unknownType;
@@ -4943,13 +5358,16 @@ var TypeAnalyzer = class {
         const fns = this.overloadsOf(this.propertyType(objType, expr.method.name));
         if (fns.length) {
           const withSelf = (f) => this.takesSelf(f) ? [objType, ...argTypes] : argTypes;
-          this.checkArity(expr, fns, argTypes.length, this.takesSelf(fns[0]) ? 1 : 0);
+          const selfOf = (f) => this.takesSelf(f) ? 1 : 0;
+          this.recordExpected(expr.arguments, fns, selfOf);
+          const arityFits = this.checkArity(expr, fns, argTypes.length, this.takesSelf(fns[0]) ? 1 : 0);
           const picked = this.pickOverload(fns, argTypes, withSelf);
           if (picked) {
             const self = this.takesSelf(picked) ? 1 : 0;
             const written = this.constArgs(picked, expr.arguments, argTypes, env, self);
             return this.callReturn(picked, this.takesSelf(picked) ? [objType, ...written] : written);
           }
+          if (arityFits) this.reportArguments(expr, expr.arguments, fns, withSelf, selfOf);
           return union(fns.map((f) => this.callReturn(f, withSelf(f))));
         }
         return objType.kind === "any" ? anyType : unknownType;
@@ -5391,6 +5809,19 @@ var TypeAnalyzer = class {
     return this.bindingByDecl.get(node) ?? this.bindingByPos.get(posKey(name, node.line.start, node.column.start));
   }
 };
+function containsTypeQuery(node) {
+  if (!node || typeof node !== "object") return false;
+  if (Array.isArray(node)) return node.some(containsTypeQuery);
+  if (node.type === "TypeofTypeNode") return true;
+  return Object.values(node).some(containsTypeQuery);
+}
+function briefType(t) {
+  if (t.kind === "union" && t.types.length > 8) {
+    const shown = t.types.slice(0, 6).map(formatType).join(" | ");
+    return `${shown} | ... ${t.types.length - 6} more`;
+  }
+  return formatType(t);
+}
 
 // src/lib/luau.ts
 import { readFileSync } from "fs";
@@ -5456,6 +5887,7 @@ export {
   luauLib,
   luautparser,
   matchInfer,
+  moduleExports,
   narrowExclude,
   narrowFalsy,
   narrowTo,