luaut-parser 2.1.0 → 3.0.0

package/README.md

@@ -71,10 +71,10 @@ npm i -D @luaut/roblox        # or just @luaut/luau
 - **Which config applies** — the nearest one in the file's folder or above.
   `luaut.config.json` and `luaut.config.jsonc` in the same folder is an error.
   Both forms accept comments and trailing commas.
-- **`types`** — `"luau"` is looked up as `@luaut/luau`, then as a package named
-  `luau`, in `node_modules` from the config upward. A full package name or a
-  relative path (`"./types"`, `"./defs.d.luaut"`) works too. A type library's
-  own type-library dependencies load first.
+- **`types`** — any name, looked up as the package `@luaut/<name>` in
+  `node_modules` from the config upward; one that is not installed is an
+  error. A relative path (`"./types"`, `"./defs.d.luaut"`) loads the project's
+  own definitions. A type library's own type-library dependencies load first.
 - **`paths`** — tsconfig rules: an exact pattern wins, then the `*` pattern
   with the longest prefix; targets resolve from `baseUrl` (default: the
   config's folder).
@@ -106,6 +106,22 @@ must.
 
 **Declarations** — `const` and `let` only; Lua's `local` is gone.
 
+**Functions** — `function name() ... end` declares `name` in the enclosing
+scope; like a TypeScript function declaration it cannot be reassigned.
+`const` and `let` do not apply to functions. `function T.name()` and
+`function T:name()` define a member.
+
+**Modules** — `import { a, b as c } from "./m"`, `import D from "./m"` and
+`import * as M from "./m"`; `export const`, `export function`, `export default`,
+`export { a as b }`, `export { a } from "./m"` and `export * from "./m"`.
+Imports are read-only: assigning to an imported name, or to a member of a
+namespace (`M.x = 1`), is an error.
+
+`import type { A } from "./m"` (also `import type D` and `import type * as M`)
+brings in names that are types and nothing else: unlike TypeScript, using one
+as a value is an error, and only type positions — `typeof A` included — may
+name it. Compiled code keeps no trace of it.
+
 **Optionality** — there is no `T?` shorthand. `?` in type position always
 belongs to a conditional type, and in expression position to a ternary.
 
@@ -150,6 +166,10 @@ operand and then the right one, as Luau does. So `Vector3 + Vector3` and
 (`declare class Enum.Material extends EnumItem {}`), and code writes it the
 same way.
 
+**Contextual typing** — an expression takes its type from where it is
+written, as in TypeScript: `let queue: thread[] = []` is a `thread[]`, and so
+is `[]` passed where one is expected, including inside an object literal.
+
 **Calls** — every argument is checked against its parameter, and a generic
 parameter against its constraint (`GetService<K extends keyof Services>`
 rejects `""`).

package/dist/index.cjs

@@ -889,23 +889,14 @@ var Parser = class {
     if (t.type === "Punctuator" && t.value === "@") {
       const { attributes, start } = this.parseAttributes();
       const next = this.current();
-      if (next.type === "Keyword" && (next.value === "const" || next.value === "let")) {
-        const stmt = this.parseVariableDeclaration();
-        if (stmt.type === "FunctionDeclaration") {
-          stmt.attributes = attributes;
-          stmt.line.start = start.line.start;
-          stmt.column.start = start.column.start;
-        }
-        return stmt;
-      }
       if (next.type === "Keyword" && next.value === "function") {
-        const stmt = this.parseFunctionDeclarationStatement();
+        const stmt = this.parseFunctionStatement();
         stmt.attributes = attributes;
         stmt.line.start = start.line.start;
         stmt.column.start = start.column.start;
         return stmt;
       }
-      throw new ParseError("Expected 'function', 'const', or 'let' after attribute", next.line.start, next.column.start);
+      throw new ParseError("Expected 'function' after an attribute", next.line.start, next.column.start);
     }
     if (t.type === "Keyword") {
       switch (t.value) {
@@ -923,7 +914,7 @@ var Parser = class {
         case "for":
           return this.parseForStatement();
         case "function":
-          return this.parseFunctionDeclarationStatement();
+          return this.parseFunctionStatement();
         case "return":
           return this.parseReturnStatement();
         case "import":
@@ -1025,20 +1016,30 @@ var Parser = class {
   parseImportStatement() {
     const start = this.current();
     this.advance();
+    const next = this.peek(1);
+    const isTypeOnly = this.checkIdentifierValue("type") && (next.type === "Punctuator" && next.value === "{" || next.type === "Operator" && next.value === "*" || next.type === "Identifier");
+    if (isTypeOnly) this.advance();
     let defaultImport;
     const specifiers = [];
-    if (this.checkType("Identifier")) {
-      const nameTok = this.expectIdentifier();
-      defaultImport = { type: "Identifier", name: nameTok.value, ...spanFrom(nameTok, nameTok) };
-      if (this.matchPunctuator(",")) {
-        this.expectPunctuator("{");
-        this.parseImportSpecifierList(specifiers);
-        this.expectPunctuator("}");
+    let namespaceImport;
+    const parseBindings = () => {
+      if (this.checkOperator("*")) {
+        this.advance();
+        if (!this.checkKeyword("as")) this.error("Expected 'as' after 'import *'");
+        this.advance();
+        namespaceImport = this.parseIdentifier();
+        return;
       }
-    } else {
       this.expectPunctuator("{");
       this.parseImportSpecifierList(specifiers);
       this.expectPunctuator("}");
+    };
+    if (this.checkType("Identifier")) {
+      const nameTok = this.expectIdentifier();
+      defaultImport = { type: "Identifier", name: nameTok.value, ...spanFrom(nameTok, nameTok) };
+      if (this.matchPunctuator(",")) parseBindings();
+    } else {
+      parseBindings();
     }
     if (!this.checkKeyword("from")) {
       this.error("Expected 'from' in import statement");
@@ -1055,7 +1056,15 @@ var Parser = class {
       raw: sourceTok.raw,
       ...spanFrom(sourceTok, sourceTok)
     };
-    return { type: "ImportStatement", defaultImport, specifiers, source, ...spanFrom(start, this.previous()) };
+    return {
+      type: "ImportStatement",
+      defaultImport,
+      namespaceImport,
+      specifiers,
+      source,
+      isTypeOnly: isTypeOnly || void 0,
+      ...spanFrom(start, this.previous())
+    };
   }
   parseImportSpecifierList(out) {
     if (this.checkPunctuator("}")) return;
@@ -1091,7 +1100,7 @@ var Parser = class {
       ...spanFrom(sourceTok, sourceTok)
     };
   }
-  // `export const ...` / `export let ...` / `export const function ...` /
+  // `export const ...` / `export let ...` / `export function ...` /
   // `export type ...` / `export default <expr>`
   parseExportStatement() {
     const start = this.current();
@@ -1109,6 +1118,11 @@ var Parser = class {
       const declaration = this.parseVariableDeclaration();
       return { type: "ExportStatement", declaration, ...spanFrom(start, this.previous()) };
     }
+    if (this.checkKeyword("function")) {
+      const declaration = this.parseFunctionStatement();
+      if (declaration.type !== "FunctionDeclaration") this.error("An exported function needs a plain name: 'export function name()'");
+      return { type: "ExportStatement", declaration, ...spanFrom(start, this.previous()) };
+    }
     if (this.checkPunctuator("{")) {
       this.advance();
       const specifiers = [];
@@ -1132,15 +1146,15 @@ var Parser = class {
       const source = this.parseModuleSource();
       return { type: "ExportAllStatement", source, ...spanFrom(start, this.previous()) };
     }
-    this.error("Expected 'const', 'let', 'type', 'default', '{' or '*' after 'export'");
+    this.error("Expected 'const', 'let', 'function', 'type', 'default', '{' or '*' after 'export'");
   }
-  // `const x = ...` / `let x, y = ...` / `const function f() ... end`.
+  // `const x = ...` / `let x, y = ...`.
   // luaut has no `local` — `const` bindings are immutable, `let` mutable.
   parseVariableDeclaration() {
     const start = this.current();
     const kind = this.advance().value;
-    if (this.matchKeyword("function")) {
-      return this.parseFunctionDeclarationRest(start, kind);
+    if (this.checkKeyword("function")) {
+      this.error(`A function is declared as 'function name()'; '${kind}' does not apply to functions`);
     }
     const names = [this.parseBindingTarget(true)];
     while (this.matchPunctuator(",")) {
@@ -1154,31 +1168,6 @@ var Parser = class {
     }
     return { type: "VariableDeclaration", kind, names, init, ...spanFrom(start, this.previous()) };
   }
-  /** `const/let function` — `function` already consumed. Collects TS-style
-   *  overload signatures. */
-  parseFunctionDeclarationRest(start, kind) {
-    const name = this.parseIdentifier();
-    const signatures = [];
-    while (true) {
-      const head = this.parseFunctionHead();
-      if (this.isOverloadContinuation(name.name, kind)) {
-        signatures.push(this.headToSignature(head));
-        this.advance();
-        this.expectKeyword("function");
-        this.parseIdentifier();
-        continue;
-      }
-      const func = this.headToBody(head);
-      return {
-        type: "FunctionDeclaration",
-        kind,
-        name,
-        func,
-        signatures: signatures.length ? signatures : void 0,
-        ...spanFrom(start, this.previous())
-      };
-    }
-  }
   parseIfStatement() {
     const start = this.current();
     this.expectKeyword("if");
@@ -1268,7 +1257,9 @@ var Parser = class {
       ...spanFrom(start, this.previous())
     };
   }
-  parseFunctionDeclarationStatement() {
+  /** `function name() end` declares `name`; `function a.b() end` and
+   *  `function T:m() end` define a member. */
+  parseFunctionStatement() {
     const start = this.current();
     this.expectKeyword("function");
     const target = this.parseFunctionName();
@@ -1284,6 +1275,15 @@ var Parser = class {
         continue;
       }
       const func = this.headToBody(head);
+      if (simpleName !== void 0) {
+        return {
+          type: "FunctionDeclaration",
+          name: target.base,
+          func,
+          signatures: signatures.length ? signatures : void 0,
+          ...spanFrom(start, this.previous())
+        };
+      }
       if (isMethod) {
         func.params.unshift({ type: "FunctionParameter", name: "self", ...spanFrom(target, target) });
         func.isMethod = true;
@@ -1300,12 +1300,8 @@ var Parser = class {
   }
   /** After a bodyless function head, is the next token the start of another
    *  declaration for the same simple `name` (making the head an overload
-   *  signature rather than an implementation)? `kind` is set for a
-   *  `const/let function` group, undefined for a bare `function` group. */
-  isOverloadContinuation(name, kind) {
-    if (kind) {
-      return this.checkKeyword(kind) && this.peek(1).type === "Keyword" && this.peek(1).value === "function" && this.peek(2).type === "Identifier" && this.peek(2).value === name;
-    }
+   *  signature rather than an implementation)? */
+  isOverloadContinuation(name) {
     return this.checkKeyword("function") && this.peek(1).type === "Identifier" && this.peek(1).value === name;
   }
   parseFunctionName() {
@@ -2612,7 +2608,7 @@ var Analyzer = class {
     };
   }
   // ---------------- declaration / resolution primitives ----------------
-  declare(scope, name, kind, node, isConst = false) {
+  declare(scope, name, kind, node, isConst = false, declaredBy) {
     if (scope.declarations.has(name) && scope !== this.globalScope) {
       this.diagnostics.push({
         node,
@@ -2621,7 +2617,7 @@ var Analyzer = class {
       });
     }
     const id = this.nextId++;
-    this.bindings.set(id, { id, name, kind, declarationNode: node, references: [], isConst });
+    this.bindings.set(id, { id, name, kind, declarationNode: node, references: [], isConst, declaredBy });
     scope.declarations.set(name, id);
     return id;
   }
@@ -2655,6 +2651,19 @@ var Analyzer = class {
     const id = this.resolve(scope, identifier.name);
     this.bindingOf.set(identifier, id);
     this.bindings.get(id).references.push(identifier);
+    if (this.typeQueryDepth === 0) this.checkTypeOnly(id, identifier);
+  }
+  /** Inside `typeof x` in a type, where a type-only import may be named. */
+  typeQueryDepth = 0;
+  /** A name from `import type` used as a value. */
+  checkTypeOnly(id, node) {
+    const b = this.bindings.get(id);
+    if (b.declaredBy !== "type") return;
+    this.diagnostics.push({
+      node,
+      message: `'${b.name}' is imported with 'import type' and can only be used as a type`,
+      kind: "type-only"
+    });
   }
   /** For assignment-like targets (`x = ...`, `function foo() end`): if
    *  this resolved to a global with no declaration site yet, treat this
@@ -2671,14 +2680,34 @@ var Analyzer = class {
     this.bindingOf.set(identifier, id);
     this.bindings.get(id).references.push(identifier);
     this.recordPossibleGlobalDefinition(id, identifier);
+    this.checkTypeOnly(id, identifier);
     this.checkConstAssign(id, identifier);
   }
+  /** `Module.x = 1` through `import * as Module`: a module's exports belong
+   *  to it and are read-only, as in ES modules. Deeper writes (`Module.x.y`)
+   *  change the value, not the module, and are fine. */
+  checkModuleWrite(target) {
+    if (target.type !== "MemberExpression" && target.type !== "IndexExpression") return;
+    if (target.object.type !== "Identifier") return;
+    const id = this.bindingOf.get(target.object);
+    if (id !== void 0 && this.bindings.get(id).declaredBy === "namespace") {
+      this.moduleWriteError(target.object.name, target);
+    }
+  }
+  moduleWriteError(name, node) {
+    this.diagnostics.push({
+      node,
+      message: `Cannot assign to a member of '${name}' \u2014 a module's exports are read-only`,
+      kind: "const-assign"
+    });
+  }
   checkConstAssign(id, node) {
     const b = this.bindings.get(id);
+    if (b.declaredBy === "type") return;
     if (b.isConst) {
       this.diagnostics.push({
         node,
-        message: `Cannot assign to '${b.name}' \u2014 it is a const`,
+        message: `Cannot assign to '${b.name}' \u2014 it is ${b.declaredBy === "import" || b.declaredBy === "namespace" ? "an import" : b.declaredBy === "function" ? "a function" : "a const"}`,
         kind: "const-assign"
       });
     }
@@ -2719,6 +2748,7 @@ var Analyzer = class {
           const id = this.resolve(scope, t.name);
           this.bindingOf.set(t, id);
           this.recordPossibleGlobalDefinition(id, t);
+          this.checkTypeOnly(id, t);
           this.checkConstAssign(id, t);
           return;
         }
@@ -2762,7 +2792,7 @@ var Analyzer = class {
         return;
       }
       case "FunctionDeclaration": {
-        this.declare(scope, stmt.name.name, "local", stmt.name, stmt.kind === "const");
+        this.declare(scope, stmt.name.name, "local", stmt.name, true, "function");
         for (const signature of stmt.signatures ?? []) this.visitSignature(signature, scope);
         this.visitFunctionBody(stmt.func, scope);
         return;
@@ -2772,6 +2802,11 @@ var Analyzer = class {
           this.referenceAsAssignmentTarget(scope, stmt.target.base);
         } else {
           this.reference(scope, stmt.target.base);
+          const id = this.bindingOf.get(stmt.target.base);
+          const depth = stmt.target.path.length + (stmt.target.method ? 1 : 0);
+          if (id !== void 0 && depth === 1 && this.bindings.get(id).declaredBy === "namespace") {
+            this.moduleWriteError(stmt.target.base.name, stmt.target);
+          }
         }
         for (const signature of stmt.signatures ?? []) this.visitSignature(signature, scope);
         this.visitFunctionBody(stmt.func, scope, stmt.isMethod);
@@ -2786,6 +2821,7 @@ var Analyzer = class {
             this.assignPattern(scope, target);
           } else {
             this.visitExpression(target, scope);
+            this.checkModuleWrite(target);
           }
         }
         return;
@@ -2798,6 +2834,7 @@ var Analyzer = class {
           if (id !== void 0) this.checkConstAssign(id, stmt.target);
         } else {
           this.visitExpression(stmt.target, scope);
+          this.checkModuleWrite(stmt.target);
         }
         return;
       }
@@ -2859,11 +2896,15 @@ var Analyzer = class {
         this.visitType(stmt.definition, scope);
         return;
       case "ImportStatement": {
+        const typeOnly = stmt.isTypeOnly ? "type" : void 0;
         if (stmt.defaultImport) {
-          this.declare(scope, stmt.defaultImport.name, "local", stmt.defaultImport);
+          this.declare(scope, stmt.defaultImport.name, "local", stmt.defaultImport, true, typeOnly ?? "import");
+        }
+        if (stmt.namespaceImport) {
+          this.declare(scope, stmt.namespaceImport.name, "local", stmt.namespaceImport, true, typeOnly ?? "namespace");
         }
         for (const spec of stmt.specifiers) {
-          this.declare(scope, spec.local.name, "local", spec.local);
+          this.declare(scope, spec.local.name, "local", spec.local, true, typeOnly ?? "import");
         }
         return;
       }
@@ -2922,7 +2963,12 @@ var Analyzer = class {
         return;
       }
       if (value.type === "TypeofTypeNode") {
-        this.visitExpression(value.expression, scope);
+        this.typeQueryDepth++;
+        try {
+          this.visitExpression(value.expression, scope);
+        } finally {
+          this.typeQueryDepth--;
+        }
         return;
       }
       for (const key of Object.keys(value)) {
@@ -4081,6 +4127,13 @@ var TypeAnalyzer = class {
       if (stmt.type !== "ImportStatement") continue;
       const exports2 = this.moduleFor(stmt.source.value);
       if (!exports2) continue;
+      if (stmt.namespaceImport) {
+        for (const [name, exported] of exports2.types) {
+          const qualified = `${stmt.namespaceImport.name}.${name}`;
+          this.importedTypes.set(qualified, exported);
+          this.aliases.set(qualified, exported.type);
+        }
+      }
       for (const s of stmt.specifiers) {
         const exported = exports2.types.get(s.imported.name);
         if (exported) {
@@ -4275,6 +4328,16 @@ var TypeAnalyzer = class {
     });
     return subst;
   }
+  /** An imported type, with its type arguments applied. */
+  importedType(imported, typeArguments) {
+    if (!imported.params.length) return imported.type;
+    const subst = /* @__PURE__ */ new Map();
+    imported.params.forEach((name, i) => {
+      const arg = typeArguments[i];
+      subst.set(name, arg ? this.resolveType(arg) : unknownType);
+    });
+    return this.reduceType(substitute(imported.type, subst));
+  }
   // --------------------------------------------------------
   // TypeNode -> Type
   // --------------------------------------------------------
@@ -4325,17 +4388,11 @@ var TypeAnalyzer = class {
             });
           }
           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));
-          }
+          if (imported) return this.importedType(imported, node.typeArguments);
           const lib = this.options.libTypes?.[node.base];
           if (lib) return lib;
+        } else if (this.importedTypes.has(name)) {
+          return this.importedType(this.importedTypes.get(name), node.typeArguments);
         } else if (this.aliasDefs.has(name)) {
           return this.expand({
             kind: "genericRef",
@@ -4939,6 +4996,14 @@ var TypeAnalyzer = class {
         };
         if (resolving && !exports2) report(stmt.source, `Cannot find module '${specifier}'`);
         const usable = exports2 && !exports2.partial ? exports2 : void 0;
+        if (stmt.namespaceImport) {
+          const id = this.bindingIdByName(stmt.namespaceImport.name, stmt.namespaceImport);
+          if (id !== void 0) {
+            const members = [...usable?.values ?? []].map(([name, type]) => [name, { type, optional: false, readonly: true }]);
+            if (usable?.default) members.push(["default", { type: usable.default, optional: false, readonly: true }]);
+            this.bindingType.set(id, usable ? objectType(members) : anyType);
+          }
+        }
         if (stmt.defaultImport) {
           if (usable && usable.default === void 0) {
             report(stmt.defaultImport, `Module '${specifier}' has no default export`);
@@ -5096,7 +5161,10 @@ var TypeAnalyzer = class {
   applyContext(expr, expected) {
     let e = expr;
     while (e.type === "ParenthesizedExpression") e = e.expression;
-    if (e.type !== "FunctionExpression" || !expected) return;
+    if (!expected) return;
+    if (e.type === "ArrayExpression") return this.applyArrayContext(e, expected);
+    if (e.type === "TableExpression") return this.applyTableContext(e, expected);
+    if (e.type !== "FunctionExpression") return;
     const members = expected.kind === "union" ? expected.types : [expected];
     const signatures = members.flatMap((m) => this.overloadsOf(this.expand(m)));
     if (!signatures.length) return;
@@ -5112,6 +5180,46 @@ var TypeAnalyzer = class {
       this.contextualParams.set(p, containsTypeParam(t) ? anyType : t);
     });
   }
+  /** What an array literal is expected to be: an empty one takes that type
+   *  outright — `let queue: thread[] = []` is a `thread[]`, as in TypeScript
+   *  — and the elements of any other get the element type as their own
+   *  context. */
+  contextualArrays = /* @__PURE__ */ new WeakMap();
+  applyArrayContext(e, expected) {
+    const target = this.expectedMembers(expected).find((m) => m.kind === "array" || m.kind === "tuple");
+    if (!target) return;
+    if (!e.elements.length) {
+      if (!containsTypeParam(target)) this.contextualArrays.set(e, target);
+      return;
+    }
+    e.elements.forEach((element, i) => {
+      if (element.type === "SpreadElement") return;
+      const elementType = target.kind === "array" ? target.element : target.elements[i];
+      this.applyContext(element, elementType);
+    });
+  }
+  /** `{ list: [] }` where `{ list: thread[] }` is expected: each field's
+   *  value gets its property's type as context. */
+  applyTableContext(e, expected) {
+    const objects = this.expectedMembers(expected).filter((m) => m.kind === "object");
+    if (!objects.length) return;
+    for (const field of e.fields) {
+      if (field.type !== "TableFieldNamed") continue;
+      const key = field.key.type === "Identifier" ? field.key.name : field.key.value;
+      const types = objects.flatMap((o) => {
+        const property = o.properties.get(key);
+        return property ? [property.type] : o.indexer ? [o.indexer.value] : [];
+      });
+      if (types.length) this.applyContext(field.value, union(types));
+    }
+  }
+  /** The members of an expected type worth matching a literal against:
+   *  aliases seen through, `nil` left out. */
+  expectedMembers(expected) {
+    const t = this.expand(expected);
+    const members = t.kind === "union" ? t.types : [t];
+    return members.map((m) => this.expand(m)).filter((m) => !(m.kind === "primitive" && m.name === "nil"));
+  }
   /** The parameter type each written argument lands on, across `fns`. */
   expectedArguments(written, fns, selfOf) {
     return written.map((_, j) => {
@@ -5686,8 +5794,9 @@ var TypeAnalyzer = class {
         return this.resolveType(expr.typeAnnotation);
       }
       case "SatisfiesExpression": {
-        const actual = this.infer(expr.expression, env);
         const declared = this.resolveType(expr.typeAnnotation);
+        this.applyContext(expr.expression, declared);
+        const actual = this.infer(expr.expression, env);
         if (this.emitDiagnostics && declared.kind !== "any" && !this.fitsAnnotation(expr.expression, declared, actual, env)) {
           this.diagnostics.push({
             node: expr,
@@ -5815,6 +5924,8 @@ var TypeAnalyzer = class {
     }
   }
   inferArray(expr, env, asConst) {
+    const contextual = this.contextualArrays.get(expr);
+    if (contextual && !asConst) return contextual;
     const elems = [];
     let hadSpread = false;
     for (const el of expr.elements) {
@@ -6468,13 +6579,13 @@ function resolveTypeLibraries(config, host = nodeHost) {
       else problems.push({ file: config.path, message: `'${entry}' has no ${ENTRY_FILE} (or 'luaut.types' in its package.json)`, ...entryPosition(config, entry) });
       continue;
     }
-    const names = entry.startsWith("@") || entry.includes("/") ? [entry] : [`@luaut/${entry}`, entry];
-    const found = names.map((name) => findPackage(name, config.directory, host)).find(Boolean);
+    const name = entry.startsWith("@luaut/") ? entry : `@luaut/${entry}`;
+    const found = findPackage(name, config.directory, host);
     if (found) addPackage(found.directory, found.file, /* @__PURE__ */ new Set());
     else {
       problems.push({
         file: config.path,
-        message: `Cannot find type library '${entry}'. Install it with: npm i -D ${names[0]}`,
+        message: `Cannot find type library '${name}'. Install it with: npm i -D ${name}`,
         ...entryPosition(config, entry)
       });
     }

package/dist/index.d.cts

@@ -99,11 +99,17 @@ interface ImportStatement extends BaseNode {
     type: "ImportStatement";
     /** `import Default from '...'` */
     defaultImport?: Identifier;
+    /** `import * as Module from '...'` — the module's exports as one value. */
+    namespaceImport?: Identifier;
+    /** `import type { A } from '...'`: every name it brings in is a type and
+     *  may only be used as one — never as a value. It exists for the type
+     *  checker alone, and leaves nothing in compiled code. */
+    isTypeOnly?: boolean;
     /** `import { a, b as c } from '...'` */
     specifiers: ImportSpecifier[];
     source: StringLiteral;
 }
-/** `export const x = 1`, `export let y = 2`, `export const function f() end` */
+/** `export const x = 1`, `export let y = 2`, `export function f() end` */
 interface ExportStatement extends BaseNode {
     type: "ExportStatement";
     declaration: VariableDeclaration | FunctionDeclaration;
@@ -214,17 +220,19 @@ interface ArrayPatternElement extends BaseNode {
     value: BindingTarget;
     default?: Expression;
 }
-/** `const function f() ... end` / `let function f() ... end` — a named,
- *  self-referential (recursive) function binding. */
+/** `function f() ... end` — declares `f` in the enclosing scope, visible to
+ *  its own body (so it can recurse). Like TypeScript's function declaration,
+ *  the name cannot be reassigned. `function a.b() end` and `function T:m() end`
+ *  assign to a member instead: see `FunctionDeclarationStatement`. */
 interface FunctionDeclaration extends BaseNode {
     type: "FunctionDeclaration";
-    kind: "const" | "let";
     name: Identifier;
     func: FunctionBody;
     attributes?: string[];
     /** TS-style overload signatures preceding the implementation (`func`). */
     signatures?: FunctionSignature[];
 }
+/** `function a.b() end` / `function T:m() end` — defines a member. */
 interface FunctionDeclarationStatement extends BaseNode {
     type: "FunctionDeclarationStatement";
     target: FunctionName;
@@ -758,8 +766,12 @@ interface Binding {
      *  bindings are never given a `declarationNode` from assignment
      *  inference, since they're not really "defined" in this file. */
     isBuiltin?: boolean;
-    /** True for a `const` binding — reassigning it is an error. */
+    /** True for a binding that cannot be reassigned: a `const`, an import, or
+     *  a function declaration. */
     isConst?: boolean;
+    /** Set when the binding comes from something other than `const` / `let`,
+     *  which is also what an error about reassigning it names. */
+    declaredBy?: "import" | "namespace" | "function" | "type";
 }
 interface ScopeDiagnostic {
     /** the offending node (redeclaration site, or assignment target) */
@@ -774,7 +786,7 @@ interface ScopeDiagnostic {
         };
     };
     message: string;
-    kind: "redeclare" | "const-assign";
+    kind: "redeclare" | "const-assign" | "type-only";
 }
 interface ScopeAnalysis {
     /** Every Identifier that appears in a variable *usage* position (i.e.
@@ -1132,7 +1144,7 @@ interface ExportedType {
 }
 /** What a module makes available to `import`. See `moduleExports`. */
 interface ModuleExports {
-    /** `export const` / `export let` / `export const function` names. */
+    /** `export const` / `export let` / `export function` names. */
     readonly values: ReadonlyMap<string, Type>;
     /** `export type` names. */
     readonly types: ReadonlyMap<string, ExportedType>;

package/dist/index.d.ts

@@ -99,11 +99,17 @@ interface ImportStatement extends BaseNode {
     type: "ImportStatement";
     /** `import Default from '...'` */
     defaultImport?: Identifier;
+    /** `import * as Module from '...'` — the module's exports as one value. */
+    namespaceImport?: Identifier;
+    /** `import type { A } from '...'`: every name it brings in is a type and
+     *  may only be used as one — never as a value. It exists for the type
+     *  checker alone, and leaves nothing in compiled code. */
+    isTypeOnly?: boolean;
     /** `import { a, b as c } from '...'` */
     specifiers: ImportSpecifier[];
     source: StringLiteral;
 }
-/** `export const x = 1`, `export let y = 2`, `export const function f() end` */
+/** `export const x = 1`, `export let y = 2`, `export function f() end` */
 interface ExportStatement extends BaseNode {
     type: "ExportStatement";
     declaration: VariableDeclaration | FunctionDeclaration;
@@ -214,17 +220,19 @@ interface ArrayPatternElement extends BaseNode {
     value: BindingTarget;
     default?: Expression;
 }
-/** `const function f() ... end` / `let function f() ... end` — a named,
- *  self-referential (recursive) function binding. */
+/** `function f() ... end` — declares `f` in the enclosing scope, visible to
+ *  its own body (so it can recurse). Like TypeScript's function declaration,
+ *  the name cannot be reassigned. `function a.b() end` and `function T:m() end`
+ *  assign to a member instead: see `FunctionDeclarationStatement`. */
 interface FunctionDeclaration extends BaseNode {
     type: "FunctionDeclaration";
-    kind: "const" | "let";
     name: Identifier;
     func: FunctionBody;
     attributes?: string[];
     /** TS-style overload signatures preceding the implementation (`func`). */
     signatures?: FunctionSignature[];
 }
+/** `function a.b() end` / `function T:m() end` — defines a member. */
 interface FunctionDeclarationStatement extends BaseNode {
     type: "FunctionDeclarationStatement";
     target: FunctionName;
@@ -758,8 +766,12 @@ interface Binding {
      *  bindings are never given a `declarationNode` from assignment
      *  inference, since they're not really "defined" in this file. */
     isBuiltin?: boolean;
-    /** True for a `const` binding — reassigning it is an error. */
+    /** True for a binding that cannot be reassigned: a `const`, an import, or
+     *  a function declaration. */
     isConst?: boolean;
+    /** Set when the binding comes from something other than `const` / `let`,
+     *  which is also what an error about reassigning it names. */
+    declaredBy?: "import" | "namespace" | "function" | "type";
 }
 interface ScopeDiagnostic {
     /** the offending node (redeclaration site, or assignment target) */
@@ -774,7 +786,7 @@ interface ScopeDiagnostic {
         };
     };
     message: string;
-    kind: "redeclare" | "const-assign";
+    kind: "redeclare" | "const-assign" | "type-only";
 }
 interface ScopeAnalysis {
     /** Every Identifier that appears in a variable *usage* position (i.e.
@@ -1132,7 +1144,7 @@ interface ExportedType {
 }
 /** What a module makes available to `import`. See `moduleExports`. */
 interface ModuleExports {
-    /** `export const` / `export let` / `export const function` names. */
+    /** `export const` / `export let` / `export function` names. */
     readonly values: ReadonlyMap<string, Type>;
     /** `export type` names. */
     readonly types: ReadonlyMap<string, ExportedType>;

package/dist/index.js

@@ -796,23 +796,14 @@ var Parser = class {
     if (t.type === "Punctuator" && t.value === "@") {
       const { attributes, start } = this.parseAttributes();
       const next = this.current();
-      if (next.type === "Keyword" && (next.value === "const" || next.value === "let")) {
-        const stmt = this.parseVariableDeclaration();
-        if (stmt.type === "FunctionDeclaration") {
-          stmt.attributes = attributes;
-          stmt.line.start = start.line.start;
-          stmt.column.start = start.column.start;
-        }
-        return stmt;
-      }
       if (next.type === "Keyword" && next.value === "function") {
-        const stmt = this.parseFunctionDeclarationStatement();
+        const stmt = this.parseFunctionStatement();
         stmt.attributes = attributes;
         stmt.line.start = start.line.start;
         stmt.column.start = start.column.start;
         return stmt;
       }
-      throw new ParseError("Expected 'function', 'const', or 'let' after attribute", next.line.start, next.column.start);
+      throw new ParseError("Expected 'function' after an attribute", next.line.start, next.column.start);
     }
     if (t.type === "Keyword") {
       switch (t.value) {
@@ -830,7 +821,7 @@ var Parser = class {
         case "for":
           return this.parseForStatement();
         case "function":
-          return this.parseFunctionDeclarationStatement();
+          return this.parseFunctionStatement();
         case "return":
           return this.parseReturnStatement();
         case "import":
@@ -932,20 +923,30 @@ var Parser = class {
   parseImportStatement() {
     const start = this.current();
     this.advance();
+    const next = this.peek(1);
+    const isTypeOnly = this.checkIdentifierValue("type") && (next.type === "Punctuator" && next.value === "{" || next.type === "Operator" && next.value === "*" || next.type === "Identifier");
+    if (isTypeOnly) this.advance();
     let defaultImport;
     const specifiers = [];
-    if (this.checkType("Identifier")) {
-      const nameTok = this.expectIdentifier();
-      defaultImport = { type: "Identifier", name: nameTok.value, ...spanFrom(nameTok, nameTok) };
-      if (this.matchPunctuator(",")) {
-        this.expectPunctuator("{");
-        this.parseImportSpecifierList(specifiers);
-        this.expectPunctuator("}");
+    let namespaceImport;
+    const parseBindings = () => {
+      if (this.checkOperator("*")) {
+        this.advance();
+        if (!this.checkKeyword("as")) this.error("Expected 'as' after 'import *'");
+        this.advance();
+        namespaceImport = this.parseIdentifier();
+        return;
       }
-    } else {
       this.expectPunctuator("{");
       this.parseImportSpecifierList(specifiers);
       this.expectPunctuator("}");
+    };
+    if (this.checkType("Identifier")) {
+      const nameTok = this.expectIdentifier();
+      defaultImport = { type: "Identifier", name: nameTok.value, ...spanFrom(nameTok, nameTok) };
+      if (this.matchPunctuator(",")) parseBindings();
+    } else {
+      parseBindings();
     }
     if (!this.checkKeyword("from")) {
       this.error("Expected 'from' in import statement");
@@ -962,7 +963,15 @@ var Parser = class {
       raw: sourceTok.raw,
       ...spanFrom(sourceTok, sourceTok)
     };
-    return { type: "ImportStatement", defaultImport, specifiers, source, ...spanFrom(start, this.previous()) };
+    return {
+      type: "ImportStatement",
+      defaultImport,
+      namespaceImport,
+      specifiers,
+      source,
+      isTypeOnly: isTypeOnly || void 0,
+      ...spanFrom(start, this.previous())
+    };
   }
   parseImportSpecifierList(out) {
     if (this.checkPunctuator("}")) return;
@@ -998,7 +1007,7 @@ var Parser = class {
       ...spanFrom(sourceTok, sourceTok)
     };
   }
-  // `export const ...` / `export let ...` / `export const function ...` /
+  // `export const ...` / `export let ...` / `export function ...` /
   // `export type ...` / `export default <expr>`
   parseExportStatement() {
     const start = this.current();
@@ -1016,6 +1025,11 @@ var Parser = class {
       const declaration = this.parseVariableDeclaration();
       return { type: "ExportStatement", declaration, ...spanFrom(start, this.previous()) };
     }
+    if (this.checkKeyword("function")) {
+      const declaration = this.parseFunctionStatement();
+      if (declaration.type !== "FunctionDeclaration") this.error("An exported function needs a plain name: 'export function name()'");
+      return { type: "ExportStatement", declaration, ...spanFrom(start, this.previous()) };
+    }
     if (this.checkPunctuator("{")) {
       this.advance();
       const specifiers = [];
@@ -1039,15 +1053,15 @@ var Parser = class {
       const source = this.parseModuleSource();
       return { type: "ExportAllStatement", source, ...spanFrom(start, this.previous()) };
     }
-    this.error("Expected 'const', 'let', 'type', 'default', '{' or '*' after 'export'");
+    this.error("Expected 'const', 'let', 'function', 'type', 'default', '{' or '*' after 'export'");
   }
-  // `const x = ...` / `let x, y = ...` / `const function f() ... end`.
+  // `const x = ...` / `let x, y = ...`.
   // luaut has no `local` — `const` bindings are immutable, `let` mutable.
   parseVariableDeclaration() {
     const start = this.current();
     const kind = this.advance().value;
-    if (this.matchKeyword("function")) {
-      return this.parseFunctionDeclarationRest(start, kind);
+    if (this.checkKeyword("function")) {
+      this.error(`A function is declared as 'function name()'; '${kind}' does not apply to functions`);
     }
     const names = [this.parseBindingTarget(true)];
     while (this.matchPunctuator(",")) {
@@ -1061,31 +1075,6 @@ var Parser = class {
     }
     return { type: "VariableDeclaration", kind, names, init, ...spanFrom(start, this.previous()) };
   }
-  /** `const/let function` — `function` already consumed. Collects TS-style
-   *  overload signatures. */
-  parseFunctionDeclarationRest(start, kind) {
-    const name = this.parseIdentifier();
-    const signatures = [];
-    while (true) {
-      const head = this.parseFunctionHead();
-      if (this.isOverloadContinuation(name.name, kind)) {
-        signatures.push(this.headToSignature(head));
-        this.advance();
-        this.expectKeyword("function");
-        this.parseIdentifier();
-        continue;
-      }
-      const func = this.headToBody(head);
-      return {
-        type: "FunctionDeclaration",
-        kind,
-        name,
-        func,
-        signatures: signatures.length ? signatures : void 0,
-        ...spanFrom(start, this.previous())
-      };
-    }
-  }
   parseIfStatement() {
     const start = this.current();
     this.expectKeyword("if");
@@ -1175,7 +1164,9 @@ var Parser = class {
       ...spanFrom(start, this.previous())
     };
   }
-  parseFunctionDeclarationStatement() {
+  /** `function name() end` declares `name`; `function a.b() end` and
+   *  `function T:m() end` define a member. */
+  parseFunctionStatement() {
     const start = this.current();
     this.expectKeyword("function");
     const target = this.parseFunctionName();
@@ -1191,6 +1182,15 @@ var Parser = class {
         continue;
       }
       const func = this.headToBody(head);
+      if (simpleName !== void 0) {
+        return {
+          type: "FunctionDeclaration",
+          name: target.base,
+          func,
+          signatures: signatures.length ? signatures : void 0,
+          ...spanFrom(start, this.previous())
+        };
+      }
       if (isMethod) {
         func.params.unshift({ type: "FunctionParameter", name: "self", ...spanFrom(target, target) });
         func.isMethod = true;
@@ -1207,12 +1207,8 @@ var Parser = class {
   }
   /** After a bodyless function head, is the next token the start of another
    *  declaration for the same simple `name` (making the head an overload
-   *  signature rather than an implementation)? `kind` is set for a
-   *  `const/let function` group, undefined for a bare `function` group. */
-  isOverloadContinuation(name, kind) {
-    if (kind) {
-      return this.checkKeyword(kind) && this.peek(1).type === "Keyword" && this.peek(1).value === "function" && this.peek(2).type === "Identifier" && this.peek(2).value === name;
-    }
+   *  signature rather than an implementation)? */
+  isOverloadContinuation(name) {
     return this.checkKeyword("function") && this.peek(1).type === "Identifier" && this.peek(1).value === name;
   }
   parseFunctionName() {
@@ -2519,7 +2515,7 @@ var Analyzer = class {
     };
   }
   // ---------------- declaration / resolution primitives ----------------
-  declare(scope, name, kind, node, isConst = false) {
+  declare(scope, name, kind, node, isConst = false, declaredBy) {
     if (scope.declarations.has(name) && scope !== this.globalScope) {
       this.diagnostics.push({
         node,
@@ -2528,7 +2524,7 @@ var Analyzer = class {
       });
     }
     const id = this.nextId++;
-    this.bindings.set(id, { id, name, kind, declarationNode: node, references: [], isConst });
+    this.bindings.set(id, { id, name, kind, declarationNode: node, references: [], isConst, declaredBy });
     scope.declarations.set(name, id);
     return id;
   }
@@ -2562,6 +2558,19 @@ var Analyzer = class {
     const id = this.resolve(scope, identifier.name);
     this.bindingOf.set(identifier, id);
     this.bindings.get(id).references.push(identifier);
+    if (this.typeQueryDepth === 0) this.checkTypeOnly(id, identifier);
+  }
+  /** Inside `typeof x` in a type, where a type-only import may be named. */
+  typeQueryDepth = 0;
+  /** A name from `import type` used as a value. */
+  checkTypeOnly(id, node) {
+    const b = this.bindings.get(id);
+    if (b.declaredBy !== "type") return;
+    this.diagnostics.push({
+      node,
+      message: `'${b.name}' is imported with 'import type' and can only be used as a type`,
+      kind: "type-only"
+    });
   }
   /** For assignment-like targets (`x = ...`, `function foo() end`): if
    *  this resolved to a global with no declaration site yet, treat this
@@ -2578,14 +2587,34 @@ var Analyzer = class {
     this.bindingOf.set(identifier, id);
     this.bindings.get(id).references.push(identifier);
     this.recordPossibleGlobalDefinition(id, identifier);
+    this.checkTypeOnly(id, identifier);
     this.checkConstAssign(id, identifier);
   }
+  /** `Module.x = 1` through `import * as Module`: a module's exports belong
+   *  to it and are read-only, as in ES modules. Deeper writes (`Module.x.y`)
+   *  change the value, not the module, and are fine. */
+  checkModuleWrite(target) {
+    if (target.type !== "MemberExpression" && target.type !== "IndexExpression") return;
+    if (target.object.type !== "Identifier") return;
+    const id = this.bindingOf.get(target.object);
+    if (id !== void 0 && this.bindings.get(id).declaredBy === "namespace") {
+      this.moduleWriteError(target.object.name, target);
+    }
+  }
+  moduleWriteError(name, node) {
+    this.diagnostics.push({
+      node,
+      message: `Cannot assign to a member of '${name}' \u2014 a module's exports are read-only`,
+      kind: "const-assign"
+    });
+  }
   checkConstAssign(id, node) {
     const b = this.bindings.get(id);
+    if (b.declaredBy === "type") return;
     if (b.isConst) {
       this.diagnostics.push({
         node,
-        message: `Cannot assign to '${b.name}' \u2014 it is a const`,
+        message: `Cannot assign to '${b.name}' \u2014 it is ${b.declaredBy === "import" || b.declaredBy === "namespace" ? "an import" : b.declaredBy === "function" ? "a function" : "a const"}`,
         kind: "const-assign"
       });
     }
@@ -2626,6 +2655,7 @@ var Analyzer = class {
           const id = this.resolve(scope, t.name);
           this.bindingOf.set(t, id);
           this.recordPossibleGlobalDefinition(id, t);
+          this.checkTypeOnly(id, t);
           this.checkConstAssign(id, t);
           return;
         }
@@ -2669,7 +2699,7 @@ var Analyzer = class {
         return;
       }
       case "FunctionDeclaration": {
-        this.declare(scope, stmt.name.name, "local", stmt.name, stmt.kind === "const");
+        this.declare(scope, stmt.name.name, "local", stmt.name, true, "function");
         for (const signature of stmt.signatures ?? []) this.visitSignature(signature, scope);
         this.visitFunctionBody(stmt.func, scope);
         return;
@@ -2679,6 +2709,11 @@ var Analyzer = class {
           this.referenceAsAssignmentTarget(scope, stmt.target.base);
         } else {
           this.reference(scope, stmt.target.base);
+          const id = this.bindingOf.get(stmt.target.base);
+          const depth = stmt.target.path.length + (stmt.target.method ? 1 : 0);
+          if (id !== void 0 && depth === 1 && this.bindings.get(id).declaredBy === "namespace") {
+            this.moduleWriteError(stmt.target.base.name, stmt.target);
+          }
         }
         for (const signature of stmt.signatures ?? []) this.visitSignature(signature, scope);
         this.visitFunctionBody(stmt.func, scope, stmt.isMethod);
@@ -2693,6 +2728,7 @@ var Analyzer = class {
             this.assignPattern(scope, target);
           } else {
             this.visitExpression(target, scope);
+            this.checkModuleWrite(target);
           }
         }
         return;
@@ -2705,6 +2741,7 @@ var Analyzer = class {
           if (id !== void 0) this.checkConstAssign(id, stmt.target);
         } else {
           this.visitExpression(stmt.target, scope);
+          this.checkModuleWrite(stmt.target);
         }
         return;
       }
@@ -2766,11 +2803,15 @@ var Analyzer = class {
         this.visitType(stmt.definition, scope);
         return;
       case "ImportStatement": {
+        const typeOnly = stmt.isTypeOnly ? "type" : void 0;
         if (stmt.defaultImport) {
-          this.declare(scope, stmt.defaultImport.name, "local", stmt.defaultImport);
+          this.declare(scope, stmt.defaultImport.name, "local", stmt.defaultImport, true, typeOnly ?? "import");
+        }
+        if (stmt.namespaceImport) {
+          this.declare(scope, stmt.namespaceImport.name, "local", stmt.namespaceImport, true, typeOnly ?? "namespace");
         }
         for (const spec of stmt.specifiers) {
-          this.declare(scope, spec.local.name, "local", spec.local);
+          this.declare(scope, spec.local.name, "local", spec.local, true, typeOnly ?? "import");
         }
         return;
       }
@@ -2829,7 +2870,12 @@ var Analyzer = class {
         return;
       }
       if (value.type === "TypeofTypeNode") {
-        this.visitExpression(value.expression, scope);
+        this.typeQueryDepth++;
+        try {
+          this.visitExpression(value.expression, scope);
+        } finally {
+          this.typeQueryDepth--;
+        }
         return;
       }
       for (const key of Object.keys(value)) {
@@ -3988,6 +4034,13 @@ var TypeAnalyzer = class {
       if (stmt.type !== "ImportStatement") continue;
       const exports = this.moduleFor(stmt.source.value);
       if (!exports) continue;
+      if (stmt.namespaceImport) {
+        for (const [name, exported] of exports.types) {
+          const qualified = `${stmt.namespaceImport.name}.${name}`;
+          this.importedTypes.set(qualified, exported);
+          this.aliases.set(qualified, exported.type);
+        }
+      }
       for (const s of stmt.specifiers) {
         const exported = exports.types.get(s.imported.name);
         if (exported) {
@@ -4182,6 +4235,16 @@ var TypeAnalyzer = class {
     });
     return subst;
   }
+  /** An imported type, with its type arguments applied. */
+  importedType(imported, typeArguments) {
+    if (!imported.params.length) return imported.type;
+    const subst = /* @__PURE__ */ new Map();
+    imported.params.forEach((name, i) => {
+      const arg = typeArguments[i];
+      subst.set(name, arg ? this.resolveType(arg) : unknownType);
+    });
+    return this.reduceType(substitute(imported.type, subst));
+  }
   // --------------------------------------------------------
   // TypeNode -> Type
   // --------------------------------------------------------
@@ -4232,17 +4295,11 @@ var TypeAnalyzer = class {
             });
           }
           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));
-          }
+          if (imported) return this.importedType(imported, node.typeArguments);
           const lib = this.options.libTypes?.[node.base];
           if (lib) return lib;
+        } else if (this.importedTypes.has(name)) {
+          return this.importedType(this.importedTypes.get(name), node.typeArguments);
         } else if (this.aliasDefs.has(name)) {
           return this.expand({
             kind: "genericRef",
@@ -4846,6 +4903,14 @@ var TypeAnalyzer = class {
         };
         if (resolving && !exports) report(stmt.source, `Cannot find module '${specifier}'`);
         const usable = exports && !exports.partial ? exports : void 0;
+        if (stmt.namespaceImport) {
+          const id = this.bindingIdByName(stmt.namespaceImport.name, stmt.namespaceImport);
+          if (id !== void 0) {
+            const members = [...usable?.values ?? []].map(([name, type]) => [name, { type, optional: false, readonly: true }]);
+            if (usable?.default) members.push(["default", { type: usable.default, optional: false, readonly: true }]);
+            this.bindingType.set(id, usable ? objectType(members) : anyType);
+          }
+        }
         if (stmt.defaultImport) {
           if (usable && usable.default === void 0) {
             report(stmt.defaultImport, `Module '${specifier}' has no default export`);
@@ -5003,7 +5068,10 @@ var TypeAnalyzer = class {
   applyContext(expr, expected) {
     let e = expr;
     while (e.type === "ParenthesizedExpression") e = e.expression;
-    if (e.type !== "FunctionExpression" || !expected) return;
+    if (!expected) return;
+    if (e.type === "ArrayExpression") return this.applyArrayContext(e, expected);
+    if (e.type === "TableExpression") return this.applyTableContext(e, expected);
+    if (e.type !== "FunctionExpression") return;
     const members = expected.kind === "union" ? expected.types : [expected];
     const signatures = members.flatMap((m) => this.overloadsOf(this.expand(m)));
     if (!signatures.length) return;
@@ -5019,6 +5087,46 @@ var TypeAnalyzer = class {
       this.contextualParams.set(p, containsTypeParam(t) ? anyType : t);
     });
   }
+  /** What an array literal is expected to be: an empty one takes that type
+   *  outright — `let queue: thread[] = []` is a `thread[]`, as in TypeScript
+   *  — and the elements of any other get the element type as their own
+   *  context. */
+  contextualArrays = /* @__PURE__ */ new WeakMap();
+  applyArrayContext(e, expected) {
+    const target = this.expectedMembers(expected).find((m) => m.kind === "array" || m.kind === "tuple");
+    if (!target) return;
+    if (!e.elements.length) {
+      if (!containsTypeParam(target)) this.contextualArrays.set(e, target);
+      return;
+    }
+    e.elements.forEach((element, i) => {
+      if (element.type === "SpreadElement") return;
+      const elementType = target.kind === "array" ? target.element : target.elements[i];
+      this.applyContext(element, elementType);
+    });
+  }
+  /** `{ list: [] }` where `{ list: thread[] }` is expected: each field's
+   *  value gets its property's type as context. */
+  applyTableContext(e, expected) {
+    const objects = this.expectedMembers(expected).filter((m) => m.kind === "object");
+    if (!objects.length) return;
+    for (const field of e.fields) {
+      if (field.type !== "TableFieldNamed") continue;
+      const key = field.key.type === "Identifier" ? field.key.name : field.key.value;
+      const types = objects.flatMap((o) => {
+        const property = o.properties.get(key);
+        return property ? [property.type] : o.indexer ? [o.indexer.value] : [];
+      });
+      if (types.length) this.applyContext(field.value, union(types));
+    }
+  }
+  /** The members of an expected type worth matching a literal against:
+   *  aliases seen through, `nil` left out. */
+  expectedMembers(expected) {
+    const t = this.expand(expected);
+    const members = t.kind === "union" ? t.types : [t];
+    return members.map((m) => this.expand(m)).filter((m) => !(m.kind === "primitive" && m.name === "nil"));
+  }
   /** The parameter type each written argument lands on, across `fns`. */
   expectedArguments(written, fns, selfOf) {
     return written.map((_, j) => {
@@ -5593,8 +5701,9 @@ var TypeAnalyzer = class {
         return this.resolveType(expr.typeAnnotation);
       }
       case "SatisfiesExpression": {
-        const actual = this.infer(expr.expression, env);
         const declared = this.resolveType(expr.typeAnnotation);
+        this.applyContext(expr.expression, declared);
+        const actual = this.infer(expr.expression, env);
         if (this.emitDiagnostics && declared.kind !== "any" && !this.fitsAnnotation(expr.expression, declared, actual, env)) {
           this.diagnostics.push({
             node: expr,
@@ -5722,6 +5831,8 @@ var TypeAnalyzer = class {
     }
   }
   inferArray(expr, env, asConst) {
+    const contextual = this.contextualArrays.get(expr);
+    if (contextual && !asConst) return contextual;
     const elems = [];
     let hadSpread = false;
     for (const el of expr.elements) {
@@ -6375,13 +6486,13 @@ function resolveTypeLibraries(config, host = nodeHost) {
       else problems.push({ file: config.path, message: `'${entry}' has no ${ENTRY_FILE} (or 'luaut.types' in its package.json)`, ...entryPosition(config, entry) });
       continue;
     }
-    const names = entry.startsWith("@") || entry.includes("/") ? [entry] : [`@luaut/${entry}`, entry];
-    const found = names.map((name) => findPackage(name, config.directory, host)).find(Boolean);
+    const name = entry.startsWith("@luaut/") ? entry : `@luaut/${entry}`;
+    const found = findPackage(name, config.directory, host);
     if (found) addPackage(found.directory, found.file, /* @__PURE__ */ new Set());
     else {
       problems.push({
         file: config.path,
-        message: `Cannot find type library '${entry}'. Install it with: npm i -D ${names[0]}`,
+        message: `Cannot find type library '${name}'. Install it with: npm i -D ${name}`,
         ...entryPosition(config, entry)
       });
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "luaut-parser",
-  "version": "2.1.0",
+  "version": "3.0.0",
   "description": "luaut parser for roblox",
   "main": "./dist/index.js",
   "module": "./dist/index.js",