@tilua/parser 1.1.0 → 2.0.0

package/dist/index.js

@@ -595,6 +595,9 @@ function applyDirectives(directives, diagnostics, lineOf) {
 var UNUSED_EXPECT_ERROR = "Unused '@tilua-expect-error' directive";
 
 // src/ast/builders.ts
+var NO_DOTS = "tilua has no bare '...': take a rest parameter, '...args: T[]', or 'scriptArgs' for the script's own";
+var ACCESSIBILITIES = /* @__PURE__ */ new Set(["public", "private", "protected"]);
+var CLASS_MODIFIERS = /* @__PURE__ */ new Set([...ACCESSIBILITIES, "static", "abstract", "override", "readonly"]);
 function bindThis(func, at) {
   bindThisParam(func.params, at);
   func.isMethod = true;
@@ -862,11 +865,16 @@ var Parser = class {
     return this.attempt(() => this.parseExpression(), stop, (start, from) => this.errorExpression(start, from));
   }
   /** A comma-separated list of values: a `return`'s, a declaration's, an
-   *  assignment's. `...xs` spreads an array into it, as in a call's
-   *  arguments; bare `...` is the vararg pack, as it always was. */
+   *  assignment's. Each is one value; a spread belongs in a call's
+   *  arguments or an array, and is reported here — then read as one, so
+   *  the rest still means something. */
   expressionListOr(stop) {
     const until = () => stop() || this.checkPunctuator(",");
-    const item = () => this.checkOperator("...") && this.startsSpread() ? this.parseSpreadArgument(until) : this.expressionOr(until);
+    const item = () => {
+      if (!(this.checkOperator("...") && this.startsSpread())) return this.expressionOr(until);
+      this.problem("A spread goes in a call's arguments or an array: take values out of an array with a destructuring, 'const [a, b] = xs'");
+      return this.parseSpreadArgument(until);
+    };
     const list = [item()];
     while (this.matchPunctuator(",")) list.push(item());
     return list;
@@ -1231,7 +1239,7 @@ var Parser = class {
     if (t.type === "Identifier" && t.value === "type" && this.peek(1).type === "Identifier") {
       return this.parseTypeAliasStatement();
     }
-    if (t.type === "Identifier" && t.value === "class" && this.peek(1).type === "Identifier") {
+    if (this.startsClassDeclaration()) {
       return this.parseClassDeclaration();
     }
     if (t.type === "Identifier" && t.value === "declare") {
@@ -1268,8 +1276,6 @@ var Parser = class {
         type: "FunctionTypeNode",
         generics: head.generics,
         params,
-        hasVarargs: head.hasVarargs,
-        varargType: head.varargTypeAnnotation,
         returnType: head.returnType ?? { type: "TypeReference", base: head.predicate ? "boolean" : "unknown", typeArguments: [], ...spanFrom(start, start) },
         predicate: head.predicate,
         ...spanFrom(start, this.previous())
@@ -1408,7 +1414,7 @@ var Parser = class {
     this.advance();
     if (this.checkIdentifierValue("default")) {
       this.advance();
-      const declaration = this.checkIdentifierValue("class") && this.peek(1).type === "Identifier" && !this.punctuatorAt(2, ":") && !this.operatorAt(2, "=") && !this.punctuatorAt(2, "(") ? this.parseClassDeclaration() : this.parseExpression(0);
+      const declaration = this.startsClassDeclaration() ? this.parseClassDeclaration() : this.parseExpression(0);
       return { type: "ExportDefaultStatement", declaration, ...spanFrom(start, this.previous()) };
     }
     if (this.checkIdentifierValue("type") && this.peek(1).type === "Identifier") {
@@ -1419,7 +1425,7 @@ var Parser = class {
       const declaration = this.parseVariableDeclaration();
       return { type: "ExportStatement", declaration, ...spanFrom(start, this.previous()) };
     }
-    if (this.checkIdentifierValue("class") && this.peek(1).type === "Identifier") {
+    if (this.startsClassDeclaration()) {
       const declaration = this.parseClassDeclaration();
       return { type: "ExportStatement", declaration, ...spanFrom(start, this.previous()) };
     }
@@ -1534,9 +1540,11 @@ var Parser = class {
     const start = this.current();
     this.expectKeyword("for");
     this.expectPunctuator("(");
+    const declared = this.checkKeyword("const") || this.checkKeyword("let") ? this.advance().value : void 0;
     const first = this.parseBindingTarget(true);
     const untilDo = () => this.checkPunctuator(")");
     if (first.type === "IdentifierPattern" && this.matchOperator("=")) {
+      if (declared) this.problemAt(start, `A counting loop names its variable without '${declared}': 'for (i = 1, 10)'`);
       const from = this.expressionOr(() => untilDo() || this.checkPunctuator(","));
       this.expectPunctuator(",");
       const to = this.expressionOr(() => untilDo() || this.checkPunctuator(","));
@@ -1555,17 +1563,24 @@ var Parser = class {
         ...spanFrom(start, this.previous())
       };
     }
-    const variables = [first];
-    while (this.matchPunctuator(",")) {
-      variables.push(this.parseBindingTarget(true));
+    if (this.checkPunctuator(",")) {
+      this.problemAt(this.current(), "A loop takes one value each time: take its parts with a destructuring, 'for (const [k, v] in pairs(t))'");
+      while (this.matchPunctuator(",")) this.parseBindingTarget(true);
+    } else if (!declared) {
+      this.problemAt(start, "A loop over a source names its value with 'const' or 'let': 'for (const item in source)'");
     }
     this.expectKeyword("in");
-    const iterators = this.expressionListOr(untilDo);
+    const iterator = this.expressionOr(() => untilDo() || this.checkPunctuator(","));
+    if (this.checkPunctuator(",")) {
+      this.problemAt(this.current(), "A loop has one source: an array, a table, an iterator function or an iteration '[step, state, first]'");
+      while (this.matchPunctuator(",")) this.expressionOr(() => untilDo() || this.checkPunctuator(","));
+    }
     const body = this.parseForBody();
     return {
       type: "GenericForStatement",
-      variables,
-      iterators,
+      kind: declared ?? "const",
+      variable: first,
+      iterator,
       body,
       ...spanFrom(start, this.previous())
     };
@@ -1635,7 +1650,10 @@ var Parser = class {
    *  the compiler must not accept it, and recorded inside. The message says
    *  what is wrong on its own — no token is appended. */
   problem(message) {
-    const t = this.current();
+    this.problemAt(this.current(), message);
+  }
+  /** `problem`, pointed at `t` rather than at where parsing has got to. */
+  problemAt(t, message) {
     const error = new ParseError(message, t.line.start, t.column.start);
     if (!this.recover) throw error;
     this.record(error);
@@ -1648,10 +1666,13 @@ var Parser = class {
    *  like a function (`function m() ... end`). */
   parseClassDeclaration() {
     const start = this.current();
+    const isAbstract = this.checkIdentifierValue("abstract");
+    if (isAbstract) this.advance();
     this.advance();
     const name = this.parseIdentifier();
     const typeParams = this.checkOperator("<") ? this.parseGenericTypeParameterList() : [];
     const { superclass, superArguments } = this.parseExtends();
+    const shapes = this.parseImplements();
     const members = this.parseClassBody(start);
     return {
       type: "ClassDeclaration",
@@ -1659,10 +1680,21 @@ var Parser = class {
       typeParams,
       superclass,
       superArguments,
+      ...shapes ? { implements: shapes } : {},
+      ...isAbstract ? { isAbstract } : {},
       members,
       ...spanFrom(start, this.previous())
     };
   }
+  /** `class Name` or `abstract class Name` — all three words soft, so a name
+   *  has to follow for either to be a declaration: `class: T`, `class = 1`
+   *  and `abstract(x)` are names. */
+  startsClassDeclaration() {
+    const offset = this.checkIdentifierValue("abstract") ? 1 : 0;
+    const word = this.peek(offset);
+    if (word.type !== "Identifier" || word.value !== "class") return false;
+    return this.peek(offset + 1).type === "Identifier" && !this.punctuatorAt(offset + 2, ":") && !this.operatorAt(offset + 2, "=") && !this.punctuatorAt(offset + 2, "(");
+  }
   /** `class ... end` as a value. It may be named — the name is for the class
    *  itself, not for the scope around it — and takes no type parameters,
    *  since nothing could write the arguments. */
@@ -1674,8 +1706,25 @@ var Parser = class {
       this.error("A class written as a value takes no type parameters: nothing could write the arguments");
     }
     const { superclass, superArguments } = this.parseExtends();
+    const shapes = this.parseImplements();
     const members = this.parseClassBody(start);
-    return { type: "ClassExpression", name, superclass, superArguments, members, ...spanFrom(start, this.previous()) };
+    return {
+      type: "ClassExpression",
+      name,
+      superclass,
+      superArguments,
+      ...shapes ? { implements: shapes } : {},
+      members,
+      ...spanFrom(start, this.previous())
+    };
+  }
+  /** `implements Shape, Named` — each a type, checked against the instance. */
+  parseImplements() {
+    if (!this.checkIdentifierValue("implements")) return void 0;
+    this.advance();
+    const shapes = [this.parseType()];
+    while (this.matchPunctuator(",")) shapes.push(this.parseType());
+    return shapes;
   }
   /** `extends Base` / `extends Box<number>`. */
   parseExtends() {
@@ -1728,23 +1777,66 @@ var Parser = class {
   parseClassMember() {
     const start = this.current();
     let accessibility;
-    if ((this.checkIdentifierValue("public") || this.checkIdentifierValue("private")) && !this.punctuatorAt(1, ":") && !this.operatorAt(1, "=") && !this.punctuatorAt(1, "(")) {
-      accessibility = this.advance().value;
+    const modifiers = /* @__PURE__ */ new Set();
+    while (this.startsClassModifier()) {
+      const token = this.advance();
+      const word = token.value;
+      if (ACCESSIBILITIES.has(word)) {
+        if (accessibility) this.problemAt(token, `A member has one accessibility: '${accessibility}' is already written`);
+        accessibility = word;
+      } else {
+        if (modifiers.has(word)) this.problemAt(token, `'${word}' is written twice`);
+        modifiers.add(word);
+      }
     }
-    const member = this.parseClassMemberAfterAccessibility(start);
-    if (!accessibility || !member) return member;
+    const member = this.parseClassMemberAfterModifiers(start, modifiers);
+    if (!member) return member;
+    const misplaced = (message) => this.problemAt(start, message);
     if (member.type === "ClassConstructor") {
-      this.problem(`A constructor cannot be '${accessibility}'`);
+      const written = [...accessibility ? [accessibility] : [], ...modifiers];
+      if (written.length) misplaced(`A constructor cannot be '${written[0]}'`);
       return member;
     }
-    return { ...member, accessibility };
+    if (modifiers.has("readonly") && member.type !== "ClassField") misplaced("Only a field can be 'readonly'");
+    if (modifiers.has("abstract") && member.type !== "ClassMethod") misplaced("Only a method can be 'abstract'");
+    if (modifiers.has("abstract") && member.isStatic) misplaced("A static method cannot be 'abstract'");
+    if (modifiers.has("override") && member.isStatic) misplaced("A static member cannot be 'override'");
+    return {
+      ...member,
+      ...accessibility ? { accessibility } : {},
+      ...modifiers.has("readonly") && member.type === "ClassField" ? { isReadonly: true } : {},
+      ...modifiers.has("override") ? { isOverride: true } : {}
+    };
   }
-  parseClassMemberAfterAccessibility(start) {
-    const isStatic = this.checkIdentifierValue("static") && !this.punctuatorAt(1, ":") && !this.operatorAt(1, "=");
-    if (isStatic) this.advance();
+  /** Is the word here a member modifier, rather than a member's name? */
+  startsClassModifier() {
+    const t = this.current();
+    if (t.type !== "Identifier" || !CLASS_MODIFIERS.has(t.value)) return false;
+    const next = this.peek(1);
+    return next.type === "Identifier" || next.type === "Keyword" && next.value === "function";
+  }
+  parseClassMemberAfterModifiers(start, modifiers) {
+    const isStatic = modifiers.has("static");
     if (this.checkKeyword("function")) {
       this.advance();
       const memberName = this.parseIdentifier();
+      if (modifiers.has("abstract")) {
+        const head = this.parseFunctionHead();
+        const func = {
+          type: "FunctionBody",
+          generics: head.generics,
+          params: head.params,
+          hasVarargs: head.hasVarargs,
+          returnType: head.returnType,
+          predicate: head.predicate,
+          body: { type: "Block", statements: [], ...spanFrom(head.start, this.previous()) },
+          ...spanFrom(head.start, this.previous())
+        };
+        if (!isStatic) bindThis(func, start);
+        if (!head.returnType) this.problem("An abstract method has no body to infer from: write its return type");
+        if (this.checkPunctuator("{")) this.problem("An abstract method has no body");
+        return { type: "ClassMethod", name: memberName, isStatic, func, isAbstract: true, ...spanFrom(start, this.previous()) };
+      }
       const signatures = [];
       let written = memberName;
       while (true) {
@@ -1862,12 +1954,17 @@ var Parser = class {
   parseReturnStatement(stopAtNewline = false) {
     const start = this.current();
     this.expectKeyword("return");
-    let args = [];
+    let argument;
     const pastLine = () => stopAtNewline && this.current().line.start > start.line.start;
     if (!pastLine() && this.isExpressionStart()) {
-      args = this.expressionListOr(pastLine);
+      const values = this.expressionListOr(pastLine);
+      argument = values[0];
+      if (values.length > 1) {
+        this.problemAt(start, "A function returns one value: return several as an array, 'return [a, b]'");
+        argument = { type: "ArrayExpression", elements: values, ...spanFrom(values[0], values[values.length - 1]) };
+      }
     }
-    return { type: "ReturnStatement", arguments: args, ...spanFrom(start, this.previous()) };
+    return { type: "ReturnStatement", argument, ...spanFrom(start, this.previous()) };
   }
   parseTypeAliasStatement() {
     const start = this.current();
@@ -1926,7 +2023,7 @@ var Parser = class {
         ...spanFrom(start, this.previous())
       };
     }
-    if (first.type === "CallExpression" || first.type === "MethodCallExpression" || first.type === "NewExpression") {
+    if (first.type === "CallExpression" || first.type === "MethodCallExpression") {
       return { type: "CallStatement", expression: first, ...spanFrom(start, this.previous()) };
     }
     let expression = first;
@@ -1979,6 +2076,15 @@ var Parser = class {
     }
     return false;
   }
+  /** A string written straight before a method call — `"a":upper()`, or
+   *  `` `{n}`:rep(2) ``. Luau only takes `("a"):upper()`; the compiler adds
+   *  the parentheses. Anything else after a string (`"a".x`, `"a"(1)`) is
+   *  not a prefix expression here either. */
+  startsStringMethodCall() {
+    const t = this.current();
+    const isString = t.type === "InterpolatedString" || t.type === "Literal" && t.kind === "string";
+    return isString && this.punctuatorAt(1, ":") && this.startsMethodCall(1);
+  }
   /** Does the next token start right where the current one ends? */
   touchesNext() {
     const current = this.current();
@@ -2165,6 +2271,7 @@ var Parser = class {
   }
   parseAtom() {
     const t = this.current();
+    if (this.startsStringMethodCall()) return this.parsePrefixExpression();
     if (t.type === "Literal") {
       this.advance();
       const lit = t;
@@ -2184,8 +2291,9 @@ var Parser = class {
       return this.buildInterpolatedString(t);
     }
     if (t.type === "Operator" && t.value === "...") {
+      this.problem(NO_DOTS);
       this.advance();
-      return { type: "VarargExpression", ...spanFrom(t, t) };
+      return { type: "ErrorExpression", ...spanFrom(t, t) };
     }
     if (t.type === "Keyword" && t.value === "function") {
       this.advance();
@@ -2261,12 +2369,17 @@ var Parser = class {
     const start = this.current();
     let base;
     if (this.startsNew()) {
-      base = this.parseNewExpression();
-    } else if (this.classDepth > 0 && this.checkIdentifierValue("super") && this.startsSuperUse()) {
+      this.problem("tilua has no 'new' operator: construct with 'Name.new(...)'");
+      this.advance();
+    }
+    if (this.classDepth > 0 && this.checkIdentifierValue("super") && this.startsSuperUse()) {
       this.advance();
       base = { type: "SuperExpression", ...spanFrom(start, start) };
     } else if (this.checkType("Identifier")) {
       base = this.parseIdentifier();
+    } else if (this.startsStringMethodCall()) {
+      const t = this.advance();
+      base = t.type === "InterpolatedString" ? this.buildInterpolatedString(t) : { type: "StringLiteral", value: t.value, raw: t.raw, ...spanFrom(t, t) };
     } else if (this.matchPunctuator("(")) {
       const inner = this.inBrackets(() => this.parseExpression());
       this.expectPunctuator(")");
@@ -2377,9 +2490,9 @@ var Parser = class {
     }
     return base;
   }
-  /** `new` is a soft keyword: it starts a construction only when a name
-   *  follows it, so a function or field called `new` — `Instance.new(x)`,
-   *  and `Vec.new(1)` itself — is untouched. */
+  /** `new Name(...)`, the way other languages build an instance — only to
+   *  say so. A function or field called `new` — `Instance.new(x)`, and
+   *  `Vec.new(1)` itself — is untouched. */
   startsNew() {
     return this.checkIdentifierValue("new") && this.peek(1).type === "Identifier";
   }
@@ -2389,25 +2502,6 @@ var Parser = class {
   startsSuperUse() {
     return this.punctuatorAt(1, "(") || this.punctuatorAt(1, ".") && this.peek(2).type === "Identifier";
   }
-  /** `new Name(args)` / `new Module.Name(args)`. The callee is a name, or a
-   *  name reached through a module — never an arbitrary expression, so the
-   *  arguments are unambiguously the constructor's. */
-  parseNewExpression() {
-    const start = this.current();
-    this.advance();
-    let callee = this.parseIdentifier();
-    while (this.checkPunctuator(".") && this.peek(1).type === "Identifier") {
-      this.advance();
-      const property = this.parseIdentifier();
-      callee = { type: "MemberExpression", object: callee, property, ...spanFrom(start, property) };
-    }
-    const typeArguments = this.tryCallTypeArguments();
-    if (!this.checkPunctuator("(")) {
-      this.error("Expected '(' after the class being constructed: 'new Name(...)'");
-    }
-    const args = this.parseCallArguments();
-    return { type: "NewExpression", callee, arguments: args, typeArguments, ...spanFrom(start, this.previous()) };
-  }
   /** After `...`, is there something to spread? Nothing following it means
    *  the vararg pack, which is what `f(...)` has always passed on. */
   startsSpread() {
@@ -2449,8 +2543,8 @@ var Parser = class {
     const errors = this.errors.length;
     try {
       this.advance();
-      const list = [this.parseTypeArgument()];
-      while (this.matchPunctuator(",") && !this.checkOperator(">")) list.push(this.parseTypeArgument());
+      const list = [this.parseType()];
+      while (this.matchPunctuator(",") && !this.checkOperator(">")) list.push(this.parseType());
       this.expectOperator(">");
       if (!this.startsCallArguments()) throw new ParseRecover("not a call");
       return list;
@@ -2582,7 +2676,7 @@ var Parser = class {
       if (this.checkOperator("...")) {
         const dots = this.advance();
         if (this.checkPunctuator("]") || this.checkPunctuator(",")) {
-          elements.push({ type: "VarargExpression", ...spanFrom(dots, dots) });
+          this.problemAt(dots, NO_DOTS);
         } else {
           const argument = this.expressionOr(stop);
           elements.push({ type: "SpreadElement", argument, ...spanFrom(dots, argument) });
@@ -2736,35 +2830,16 @@ var Parser = class {
       column: p.column
     };
   }
-  parseTypeOrTypePackReference() {
+  /** `T...` written where a type goes: a pack, which tilua does not have. */
+  rejectPackReference() {
     if (this.checkType("Identifier") && this.peek(1).type === "Operator" && this.peek(1).value === "...") {
-      const start = this.current();
-      const base = this.expectIdentifier().value;
+      this.problemAt(
+        this.peek(1),
+        "tilua has no type packs: several values are a tuple, '[A, B]', and a varying number an array, 'T[]'"
+      );
+      this.advance();
       this.advance();
-      const packRef = { type: "TypeReference", base, typeArguments: [], ...spanFrom(start, start) };
-      return {
-        type: "TypePackNode",
-        types: [],
-        hasVarargs: true,
-        // Wrap in `VariadicTypeNode`, matching the convention used by
-        // `parseFunctionTypeAfterParen`'s identifier-pack-reference
-        // branch, so the printer can tell `A...` (name-first, this
-        // case) apart from `...T` (dots-first) and append rather
-        // than prepend the `...`.
-        varargType: { type: "VariadicTypeNode", typeAnnotation: packRef, ...spanFrom(start, this.previous()) },
-        ...spanFrom(start, this.previous())
-      };
-    }
-    return this.parseType();
-  }
-  parseTypeArgument() {
-    if (this.checkOperator("...")) {
-      return this.parseTypePack();
-    }
-    if (this.checkType("Identifier") && this.peek(1).type === "Operator" && this.peek(1).value === "...") {
-      return this.parseTypeOrTypePackReference();
     }
-    return this.parseType();
   }
   /** The part shared by a real function body and an overload signature:
    *  `<generics>(params): ReturnType`, up to (but not including) the block. */
@@ -2777,7 +2852,6 @@ var Parser = class {
     this.expectPunctuator("(");
     const params = [];
     let hasVarargs = false;
-    let varargTypeAnnotation;
     if (!this.checkPunctuator(")")) {
       while (true) {
         if (this.checkOperator("...")) {
@@ -2785,14 +2859,14 @@ var Parser = class {
           hasVarargs = true;
           if (this.checkType("Identifier")) {
             const nameTok = this.expectIdentifier();
-            let typeAnnotation2;
+            let typeAnnotation3;
             if (this.matchPunctuator(":")) {
-              typeAnnotation2 = this.typeOr(() => this.checkPunctuator(")"));
+              typeAnnotation3 = this.typeOr(() => this.checkPunctuator(")"));
             }
             params.push({
               type: "FunctionParameter",
               name: nameTok.value,
-              typeAnnotation: typeAnnotation2,
+              typeAnnotation: typeAnnotation3,
               rest: true,
               ...spanFrom(dots, this.previous())
             });
@@ -2801,9 +2875,20 @@ var Parser = class {
             }
             break;
           }
+          this.problemAt(dots, NO_DOTS);
+          let typeAnnotation2;
           if (this.matchPunctuator(":")) {
-            varargTypeAnnotation = this.parseTypeOrTypePackReference();
+            this.rejectPackReference();
+            const element = this.parseType();
+            typeAnnotation2 = { type: "ArrayTypeNode", element, ...spanFrom(element, element) };
           }
+          params.push({
+            type: "FunctionParameter",
+            name: "args",
+            typeAnnotation: typeAnnotation2,
+            rest: true,
+            ...spanFrom(dots, this.previous())
+          });
           break;
         }
         const paramStart = this.current();
@@ -2845,10 +2930,16 @@ var Parser = class {
     if (this.matchPunctuator(":")) {
       predicate = this.tryParseTypePredicate();
       if (!predicate) {
-        returnType = this.attempt(() => this.parseTypeOrTypePackReference(), () => false, () => void 0);
+        returnType = this.attempt(() => this.parseReturnType(), () => false, () => void 0);
       }
     }
-    return { start, generics, params, hasVarargs, varargTypeAnnotation, returnType, predicate };
+    return { start, generics, params, hasVarargs, returnType, predicate };
+  }
+  /** What a function returns: one type. `T...` is reported as the pack it
+   *  is, and the type after it read. */
+  parseReturnType() {
+    this.rejectPackReference();
+    return this.parseType();
   }
   /** TypeScript-style type-guard return annotations, in return position only:
    *
@@ -2918,7 +3009,6 @@ var Parser = class {
         generics: [],
         params: [{ type: "FunctionParameter", name: name.value, ...spanFrom(name, name) }],
         hasVarargs: false,
-        varargTypeAnnotation: void 0,
         returnType: void 0,
         predicate: void 0
       };
@@ -2930,7 +3020,6 @@ var Parser = class {
       generics: head.generics,
       params: head.params,
       hasVarargs: head.hasVarargs,
-      varargTypeAnnotation: head.varargTypeAnnotation,
       returnType: head.returnType,
       predicate: head.predicate,
       body,
@@ -2942,7 +3031,7 @@ var Parser = class {
   returnOf(expression) {
     const statement = {
       type: "ReturnStatement",
-      arguments: [expression],
+      argument: expression,
       ...spanFrom(expression, expression)
     };
     return { type: "Block", statements: [statement], ...spanFrom(expression, expression) };
@@ -2955,7 +3044,6 @@ var Parser = class {
       generics: head.generics,
       params: head.params,
       hasVarargs: head.hasVarargs,
-      varargTypeAnnotation: head.varargTypeAnnotation,
       returnType: head.returnType,
       predicate: head.predicate,
       body,
@@ -2968,7 +3056,6 @@ var Parser = class {
       generics: head.generics,
       params: head.params,
       hasVarargs: head.hasVarargs,
-      varargTypeAnnotation: head.varargTypeAnnotation,
       returnType: head.returnType,
       predicate: head.predicate,
       ...spanFrom(head.start, this.previous())
@@ -2986,7 +3073,6 @@ var Parser = class {
       generics: head.generics,
       params: head.params,
       hasVarargs: head.hasVarargs,
-      varargTypeAnnotation: head.varargTypeAnnotation,
       returnType: head.returnType,
       predicate: head.predicate,
       body,
@@ -3127,9 +3213,10 @@ var Parser = class {
       return this.parseFunctionTypeAfterParen(t, []);
     }
     if (t.type === "Operator" && t.value === "...") {
+      this.problem("'...' in a type goes before a rest parameter, '...args: T[]', or at the end of a tuple, '[A, ...B[]]'");
       this.advance();
-      const inner = this.parseType();
-      return { type: "VariadicTypeNode", typeAnnotation: inner, ...spanFrom(t, this.previous()) };
+      const element = this.parseType();
+      return { type: "ArrayTypeNode", element, ...spanFrom(t, this.previous()) };
     }
     if (t.type === "Punctuator" && t.value === "{") {
       return this.parseTableType();
@@ -3137,13 +3224,22 @@ var Parser = class {
     if (t.type === "Punctuator" && t.value === "[") {
       this.advance();
       const elements = [];
+      let rest;
       while (!this.checkPunctuator("]")) {
+        if (this.matchOperator("...")) {
+          rest = this.parseType();
+          if (rest.type !== "ArrayTypeNode" && !(rest.type === "TypeReference" && rest.base !== "nil")) {
+            this.problem("The rest of a tuple is an array type: '...T[]'");
+          }
+          this.matchPunctuator(",");
+          break;
+        }
         elements.push(this.parseType());
         if (this.matchPunctuator(",")) continue;
         break;
       }
       this.expectPunctuator("]");
-      return { type: "TupleTypeNode", elements, ...spanFrom(t, this.previous()) };
+      return { type: "TupleTypeNode", elements, ...rest ? { rest } : {}, ...spanFrom(t, this.previous()) };
     }
     if (t.type === "Identifier" && t.value === "typeof" && this.peek(1).type === "Punctuator" && this.peek(1).value === "(") {
       this.advance();
@@ -3190,9 +3286,9 @@ var Parser = class {
       if (this.checkOperator("<")) {
         this.advance();
         if (!this.checkOperator(">")) {
-          typeArguments.push(this.parseTypeArgument());
+          typeArguments.push(this.parseType());
           while (this.matchPunctuator(",") && !this.checkOperator(">")) {
-            typeArguments.push(this.parseTypeArgument());
+            typeArguments.push(this.parseType());
           }
         }
         this.expectOperator(">");
@@ -3203,13 +3299,12 @@ var Parser = class {
   }
   parseFunctionTypeAfterParen(start, generics) {
     const params = [];
-    let hasVarargs = false;
-    let varargType;
+    let rested = false;
     if (!this.checkPunctuator(")")) {
       while (true) {
         if (this.checkOperator("...")) {
           const dots = this.advance();
-          hasVarargs = true;
+          rested = true;
           if (this.checkType("Identifier") && this.punctuatorAt(1, ":")) {
             const nameTok2 = this.expectIdentifier();
             this.advance();
@@ -3223,16 +3318,21 @@ var Parser = class {
             });
             break;
           }
-          varargType = this.parseType();
+          this.problemAt(dots, "A function type takes the rest of its arguments as an array: '(...args: T[]) => R'");
+          this.rejectPackReference();
+          const element = this.parseType();
+          params.push({
+            type: "FunctionTypeParameter",
+            name: "args",
+            rest: true,
+            typeAnnotation: { type: "ArrayTypeNode", element, ...spanFrom(element, element) },
+            ...spanFrom(dots, this.previous())
+          });
           break;
         }
         if (this.checkType("Identifier") && this.peek(1).type === "Operator" && this.peek(1).value === "...") {
-          const packStart = this.current();
-          const packRef = this.parseType();
-          this.advance();
-          hasVarargs = true;
-          varargType = { type: "VariadicTypeNode", typeAnnotation: packRef, ...spanFrom(packStart, this.previous()) };
-          break;
+          this.rejectPackReference();
+          continue;
         }
         let name;
         let optional2 = false;
@@ -3262,19 +3362,17 @@ var Parser = class {
     this.expectPunctuator(")");
     if (this.matchPunctuator("=>") || this.mistypedArrow()) {
       const predicate = this.tryParseTypePredicate();
-      const returnType = predicate ? { type: "TypeReference", base: "boolean", typeArguments: [], ...spanFrom(start, this.previous()) } : this.parseTypeOrTypePackReference();
+      const returnType = predicate ? { type: "TypeReference", base: "boolean", typeArguments: [], ...spanFrom(start, this.previous()) } : this.parseReturnType();
       return {
         type: "FunctionTypeNode",
         generics,
         params,
-        hasVarargs,
-        varargType,
         returnType,
         predicate,
         ...spanFrom(start, this.previous())
       };
     }
-    if (params.length === 1 && !params[0].name && !hasVarargs) {
+    if (params.length === 1 && !params[0].name && !rested) {
       return {
         type: "ParenthesizedTypeNode",
         typeAnnotation: params[0].typeAnnotation,
@@ -3284,11 +3382,14 @@ var Parser = class {
     if (params.some((p) => p.name !== void 0)) {
       this.error("Expected '=>' for function type");
     }
+    if (!params.length) {
+      this.problemAt(start, "'()' is not a type: a function that returns nothing returns 'nil'");
+      return { type: "TypeReference", base: "nil", typeArguments: [], ...spanFrom(start, this.previous()) };
+    }
+    this.problemAt(start, "Several types in parentheses are a pack, which tilua does not have: write a tuple, '[A, B]'");
     return {
-      type: "TypePackNode",
-      types: params.map((p) => p.typeAnnotation),
-      hasVarargs,
-      varargType,
+      type: "TupleTypeNode",
+      elements: params.map((p) => p.typeAnnotation),
       ...spanFrom(start, this.previous())
     };
   }
@@ -3426,40 +3527,15 @@ var Parser = class {
     this.expectPunctuator("}");
     return { type: "TableTypeNode", properties, ...spanFrom(start, this.previous()) };
   }
-  parseTypePack() {
-    const start = this.current();
-    if (this.matchOperator("...")) {
-      const varargType2 = this.parseType();
-      return { type: "TypePackNode", types: [], hasVarargs: true, varargType: varargType2, ...spanFrom(start, this.previous()) };
-    }
-    this.expectPunctuator("(");
-    const types = [];
-    let hasVarargs = false;
-    let varargType;
-    if (!(this.current().type === "Punctuator" && this.current().value === ")")) {
-      while (true) {
-        if (this.matchOperator("...")) {
-          hasVarargs = true;
-          varargType = this.parseType();
-          break;
-        }
-        types.push(this.parseType());
-        if (this.matchPunctuator(",")) continue;
-        break;
-      }
-    }
-    this.expectPunctuator(")");
-    return { type: "TypePackNode", types, hasVarargs, varargType, ...spanFrom(start, this.previous()) };
-  }
   parseGenericTypeParameterList() {
     const list = [];
     this.expectOperator("<");
     while (true) {
       const isConst = this.matchKeyword("const");
       const nameTok = this.expectIdentifier();
-      let isPack = false;
-      if (this.matchOperator("...")) {
-        isPack = true;
+      const dots = this.checkOperator("...") ? this.advance() : void 0;
+      if (dots) {
+        this.problemAt(dots, "tilua has no pack parameters: write '<T extends unknown[]>', and take it as '...args: T'");
       }
       let constraint;
       if (this.checkIdentifierValue("extends")) {
@@ -3468,17 +3544,13 @@ var Parser = class {
       }
       let def;
       if (this.matchOperator("=")) {
-        if (isPack) {
-          def = this.parseTypePack();
-        } else {
-          def = this.parseType();
-        }
+        this.rejectPackReference();
+        def = this.parseType();
       }
       list.push({
         type: "GenericTypeParameter",
         name: nameTok.value,
         id: tokenIdentifier(nameTok),
-        isPack,
         isConst: isConst || void 0,
         constraint,
         default: def,
@@ -3569,7 +3641,7 @@ function childScope(parent) {
 var Analyzer = class {
   constructor(options) {
     this.options = options;
-    for (const name of options.builtinGlobals ?? []) {
+    for (const name of [...LANGUAGE_GLOBALS, ...options.builtinGlobals ?? []]) {
       const id = this.getOrCreateGlobalBinding(name);
       this.bindings.get(id).isBuiltin = true;
     }
@@ -3971,14 +4043,14 @@ var Analyzer = class {
         return;
       }
       case "GenericForStatement": {
-        for (const it of stmt.iterators) this.visitExpression(it, scope);
+        this.visitExpression(stmt.iterator, scope);
         const bodyScope = childScope(scope);
-        for (const v of stmt.variables) this.declarePattern(bodyScope, v, "for-generic", scope);
+        this.declarePattern(bodyScope, stmt.variable, "for-generic", scope, stmt.kind === "const");
         this.visitBlock(stmt.body, bodyScope);
         return;
       }
       case "ReturnStatement":
-        for (const arg of stmt.arguments) this.visitExpression(arg, scope);
+        if (stmt.argument) this.visitExpression(stmt.argument, scope);
         return;
       case "BreakStatement":
       case "ContinueStatement":
@@ -4046,7 +4118,6 @@ var Analyzer = class {
         this.declare(fnScope, param.name, kind, param);
       }
     });
-    this.visitType(func.varargTypeAnnotation, fnScope);
     this.visitType(func.returnType, fnScope);
     this.functionDepth++;
     try {
@@ -4074,6 +4145,7 @@ var Analyzer = class {
     this.visitGenerics(node.typeParams, scope);
     if (node.superclass) this.reference(outer, node.superclass);
     for (const argument of node.superArguments ?? []) this.visitType(argument, scope);
+    for (const shape of node.implements ?? []) this.visitType(shape, scope);
     for (const member of node.members) {
       switch (member.type) {
         case "ClassField":
@@ -4133,7 +4205,6 @@ var Analyzer = class {
       case "BooleanLiteral":
       case "NumberLiteral":
       case "StringLiteral":
-      case "VarargExpression":
       case "ErrorExpression":
         return;
       case "InterpolatedStringExpression":
@@ -4173,11 +4244,6 @@ var Analyzer = class {
         this.visitExpression(expr.callee, scope);
         for (const arg of expr.arguments) this.visitExpression(arg, scope);
         return;
-      case "NewExpression":
-        this.visitExpression(expr.callee, scope);
-        for (const argument of expr.arguments) this.visitExpression(argument, scope);
-        for (const argument of expr.typeArguments ?? []) this.visitType(argument, scope);
-        return;
       case "SuperExpression":
         return;
       case "SpreadElement":
@@ -4231,6 +4297,7 @@ var Analyzer = class {
     }
   }
 };
+var LANGUAGE_GLOBALS = ["scriptArgs"];
 function analyzeScopes(program, options = {}) {
   return new Analyzer(options).run(program);
 }
@@ -4249,8 +4316,8 @@ type Exclude<T, U> = T - U
 type Extract<T, U> = T extends U ? T : never
 type NonNullable<T> = T - nil
 
-type ReturnType<T> = T extends (...unknown) => infer R ? R : never
-type Parameters<T> = T extends (...infer P) => unknown ? P : never
+type ReturnType<T> = T extends (...args: unknown[]) => infer R ? R : never
+type Parameters<T> = T extends (...args: infer P) => unknown ? P : never
 
 type Partial<T> = { [K in keyof T]?: T[K] }
 type Required<T> = { [K in keyof T]-?: T[K] }
@@ -4335,8 +4402,11 @@ function literal(value) {
 function arrayOf(element) {
   return { kind: "array", element };
 }
-function tuple(elements, isPack) {
-  return { kind: "tuple", elements, isPack };
+function tuple(elements, rest) {
+  return rest ? { kind: "tuple", elements, rest } : { kind: "tuple", elements };
+}
+function tupleMembers(t) {
+  return t.rest ? [...t.elements, t.rest] : t.elements;
 }
 function objectType(entries, indexer, frozen) {
   return { kind: "object", properties: new Map(entries), indexer, frozen };
@@ -4360,7 +4430,7 @@ function substitute(t, subst) {
     case "array":
       return arrayOf(substitute(t.element, subst));
     case "tuple":
-      return tuple(t.elements.map((e) => substitute(e, subst)), t.isPack);
+      return tuple(t.elements.map((e) => substitute(e, subst)), t.rest && substitute(t.rest, subst));
     case "object": {
       const entries = [];
       for (const [k, v] of t.properties) entries.push([k, { ...v, type: substitute(v.type, subst) }]);
@@ -4384,14 +4454,20 @@ function substitute(t, subst) {
       const inner = t.typeParams ? new Map([...subst].filter(([k]) => !t.typeParams.includes(k))) : subst;
       let params = t.params.map((p) => ({ ...p, type: substitute(p.type, inner) }));
       let varargs = t.varargs && substitute(t.varargs, inner);
-      if (varargs?.kind === "tuple" && varargs.isPack) {
+      let restIsWhole = t.restIsWhole;
+      if (restIsWhole && varargs?.kind === "tuple") {
         params = [...params, ...varargs.elements.map((type) => ({ type }))];
-        varargs = void 0;
+        varargs = varargs.rest;
+        restIsWhole = void 0;
+      } else if (restIsWhole && varargs?.kind === "array") {
+        varargs = varargs.element;
+        restIsWhole = void 0;
       }
       return {
         kind: "function",
         params,
         varargs,
+        ...restIsWhole ? { restIsWhole } : {},
         returns: substitute(t.returns, inner),
         typeParams: t.typeParams,
         typeParamDefaults: t.typeParamDefaults,
@@ -4474,11 +4550,19 @@ function unify(param, arg, vars, out) {
   switch (param.kind) {
     case "array":
       if (arg.kind === "array") unify(param.element, arg.element, vars, out);
-      else if (arg.kind === "tuple") for (const e of arg.elements) unify(param.element, e, vars, out);
+      else if (arg.kind === "tuple") for (const e of tupleMembers(arg)) unify(param.element, e, vars, out);
       return;
     case "tuple":
-      if (arg.kind === "tuple") param.elements.forEach((p, i) => arg.elements[i] && unify(p, arg.elements[i], vars, out));
-      else if (arg.kind === "array") for (const p of param.elements) unify(p, arg.element, vars, out);
+      if (arg.kind === "tuple") {
+        param.elements.forEach((p, i) => {
+          const a = arg.elements[i] ?? arg.rest;
+          if (a) unify(p, a, vars, out);
+        });
+        if (param.rest) for (const a of arg.elements.slice(param.elements.length)) unify(param.rest, a, vars, out);
+        if (param.rest && arg.rest) unify(param.rest, arg.rest, vars, out);
+      } else if (arg.kind === "array") {
+        for (const p of tupleMembers(param)) unify(p, arg.element, vars, out);
+      }
       return;
     case "function":
       if (arg.kind === "function") {
@@ -4580,7 +4664,7 @@ function widen(t) {
     case "array":
       return arrayOf(widen(t.element));
     case "tuple":
-      return tuple(t.elements.map(widen), t.isPack);
+      return tuple(t.elements.map(widen), t.rest && widen(t.rest));
     case "object": {
       if (t.frozen || t.class) return t;
       const entries = [];
@@ -4680,13 +4764,18 @@ function isAssignableInner(a, b) {
   if (a.kind === "primitive") return b.kind === "primitive" && b.name === a.name;
   if (a.kind === "array") {
     if (b.kind === "array") return isAssignable(a.element, b.element);
+    if (b.kind === "tuple") return b.elements.length === 0 && !!b.rest && isAssignable(a.element, b.rest);
     return false;
   }
   if (a.kind === "tuple") {
     if (b.kind === "tuple") {
-      return a.elements.length === b.elements.length && a.elements.every((t, i) => isAssignable(t, b.elements[i]));
+      if (a.elements.length < b.elements.length) return false;
+      if (!b.elements.every((t, i) => isAssignable(a.elements[i], t))) return false;
+      const extra = [...a.elements.slice(b.elements.length), ...a.rest ? [a.rest] : []];
+      if (!b.rest) return extra.length === 0;
+      return extra.every((t) => isAssignable(t, b.rest));
     }
-    if (b.kind === "array") return a.elements.every((t) => isAssignable(t, b.element));
+    if (b.kind === "array") return tupleMembers(a).every((t) => isAssignable(t, b.element));
     return false;
   }
   if (a.kind === "object") {
@@ -4735,7 +4824,7 @@ function sameRefTarget(a, b) {
   return a.name === b.name && (!a.origin || !b.origin || a.origin === b.origin);
 }
 function isNoValue(t) {
-  return t.kind === "tuple" && t.elements.length === 0;
+  return t.kind === "tuple" && t.elements.length === 0 && !t.rest;
 }
 function equalTypes(a, b) {
   return formatType(a) === formatType(b);
@@ -4842,7 +4931,7 @@ function containsFreeTypeParam(t, seen, bound) {
     case "array":
       return containsTypeParam(t.element, seen, bound);
     case "tuple":
-      return t.elements.some((e) => containsTypeParam(e, seen, bound));
+      return tupleMembers(t).some((e) => containsTypeParam(e, seen, bound));
     case "union":
     case "intersection":
       return t.types.some((m) => containsTypeParam(m, seen, bound));
@@ -4887,15 +4976,19 @@ function matchInfer(arg, pattern, out) {
   switch (pattern.kind) {
     case "array":
       if (arg.kind === "array") return matchInfer(arg.element, pattern.element, out);
-      if (arg.kind === "tuple") return matchInfer(union(arg.elements), pattern.element, out);
+      if (arg.kind === "tuple") return matchInfer(union(tupleMembers(arg)), pattern.element, out);
       return false;
     case "tuple":
       if (arg.kind !== "tuple" || arg.elements.length !== pattern.elements.length) return false;
+      if (pattern.rest && !matchInfer(arg.rest ?? neverType, pattern.rest, out)) return false;
       return pattern.elements.every((pt, i) => matchInfer(arg.elements[i], pt, out));
     case "function": {
       if (arg.kind !== "function") return false;
       if (pattern.varargs?.kind === "infer" && !pattern.params.length) {
-        out.set(pattern.varargs.name, tuple(arg.params.map((p) => p.type)));
+        out.set(pattern.varargs.name, tuple(
+          arg.params.map((p) => p.type),
+          arg.varargs && !arg.restIsWhole ? arg.varargs : void 0
+        ));
       } else {
         for (let i = 0; i < pattern.params.length; i++) {
           if (!arg.params[i]) return false;
@@ -4969,7 +5062,7 @@ function collectTypeParams(t, out, seen = /* @__PURE__ */ new Set()) {
       collectTypeParams(t.element, out, seen);
       return;
     case "tuple":
-      for (const e of t.elements) collectTypeParams(e, out, seen);
+      for (const e of tupleMembers(t)) collectTypeParams(e, out, seen);
       return;
     case "union":
     case "intersection":
@@ -5016,9 +5109,8 @@ function formatTypeUncached(t) {
     case "array":
       return `${formatAtom(t.element)}[]`;
     case "tuple": {
-      if (!t.elements.length) return "()";
-      const inner = t.elements.map(formatType).join(", ");
-      return t.isPack ? `(${inner})` : `[${inner}]`;
+      const inner = [...t.elements.map(formatType), ...t.rest ? [`...${formatAtom(t.rest)}[]`] : []];
+      return `[${inner.join(", ")}]`;
     }
     case "object": {
       if (t.name) {
@@ -5042,7 +5134,7 @@ function formatTypeUncached(t) {
         return `${consts.has(n) ? "const " : ""}${n}${constraint ? ` extends ${briefConstraint(constraint)}` : ""}`;
       }).join(", ")}>` : "";
       const ps = t.params.map((p) => `${p.name ? p.name + ": " : ""}${formatType(p.type)}`);
-      if (t.varargs) ps.push(`...${formatType(t.varargs)}`);
+      if (t.varargs) ps.push(t.restIsWhole ? `...args: ${formatType(t.varargs)}` : `...args: ${formatAtom(t.varargs)}[]`);
       return `${gen}(${ps.join(", ")}) => ${formatPredicate(t) ?? formatType(t.returns)}`;
     }
     case "typeParam":
@@ -5246,6 +5338,11 @@ function moduleExports(program, scopes, types, resolveModule) {
   }
   return { values, types: exportedTypes, default: defaultType };
 }
+function isBelow(k, key) {
+  if (!k.startsWith(key) || k.length === key.length) return false;
+  const next = k[key.length];
+  return next === "." || next === "#" || next === "[";
+}
 function bindKey(id) {
   return `$${id}`;
 }
@@ -5263,9 +5360,6 @@ function mergeEnv(a, b, base) {
 function mergeIndexer(a, b) {
   return a ? { key: union([a.key, b.key]), value: union([a.value, b.value]) } : b;
 }
-function producesMultipleValues(e) {
-  return e.type === "CallExpression" || e.type === "MethodCallExpression" || e.type === "VarargExpression";
-}
 function isFreshLiteralExpr(e) {
   if (!e) return false;
   switch (e.type) {
@@ -5302,11 +5396,11 @@ function collectInferNames(node) {
         walk(n.element);
         return;
       case "ParenthesizedTypeNode":
-      case "VariadicTypeNode":
         walk(n.typeAnnotation);
         return;
       case "TupleTypeNode":
         n.elements.forEach(walk);
+        walk(n.rest);
         return;
       case "UnionTypeNode":
       case "IntersectionTypeNode":
@@ -5324,7 +5418,6 @@ function collectInferNames(node) {
         return;
       case "FunctionTypeNode":
         n.params.forEach((pp) => walk(pp.typeAnnotation));
-        walk(n.varargType);
         walk(n.returnType);
         return;
       case "TableTypeNode":
@@ -5369,6 +5462,75 @@ function callsSuper(block) {
   });
   return found;
 }
+var ALL_FIELDS = /* @__PURE__ */ new Set();
+function definitelyAssigned(block) {
+  const names = /* @__PURE__ */ new Set();
+  for (const statement of block.statements) {
+    switch (statement.type) {
+      case "AssignmentStatement":
+      case "CompoundAssignmentStatement":
+        for (const name of assignedFields({ ...block, statements: [statement] })) names.add(name);
+        break;
+      case "DoStatement": {
+        const inner = definitelyAssigned(statement.body);
+        if (!inner) return void 0;
+        for (const name of inner) names.add(name);
+        break;
+      }
+      case "IfStatement": {
+        if (!statement.alternate) break;
+        const arms = [...statement.clauses.map((c) => c.body), statement.alternate].map(definitelyAssigned);
+        const finishing = arms.filter((arm) => arm !== void 0);
+        if (!finishing.length) return void 0;
+        for (const name of finishing[0]) {
+          if (finishing.every((arm) => arm.has(name))) names.add(name);
+        }
+        break;
+      }
+      case "ReturnStatement":
+        return void 0;
+      case "CallStatement": {
+        const call = statement.expression;
+        if (call.type === "CallExpression" && call.callee.type === "Identifier" && call.callee.name === "error") {
+          return void 0;
+        }
+        break;
+      }
+    }
+  }
+  return names;
+}
+function withoutReceiver(t) {
+  if (t.kind === "intersection") return intersection(t.types.map(withoutReceiver));
+  if (t.kind !== "function") return t;
+  const first = t.params[0]?.name;
+  if (first !== "this" && first !== "self") return t;
+  return { ...t, params: t.params.slice(1) };
+}
+var METAMETHOD_OPERANDS = {
+  __add: 1,
+  __sub: 1,
+  __mul: 1,
+  __div: 1,
+  __idiv: 1,
+  __mod: 1,
+  __pow: 1,
+  __concat: 1,
+  __eq: 1,
+  __lt: 1,
+  __le: 1,
+  __unm: 0,
+  __len: 0,
+  __tostring: 0,
+  __iter: 0,
+  __call: void 0
+};
+var METAMETHOD_RETURNS = {
+  __tostring: stringType,
+  __eq: booleanType,
+  __lt: booleanType,
+  __le: booleanType
+};
 function assignedFields(block) {
   const names = /* @__PURE__ */ new Set();
   walkNodes(block, (node) => {
@@ -5394,7 +5556,7 @@ function walkNodes(root, visit) {
     if (key !== "line" && key !== "column" && value && typeof value === "object") walkNodes(value, visit);
   }
 }
-var AliasMap = class extends Map {
+var LazyMap = class extends Map {
   pending = /* @__PURE__ */ new Map();
   defer(name, resolve5) {
     super.delete(name);
@@ -5509,14 +5671,14 @@ var TypeAnalyzer = class {
   scopes;
   options;
   typeOf = /* @__PURE__ */ new Map();
-  bindingType = /* @__PURE__ */ new Map();
+  bindingType = new LazyMap();
   narrowedTypeOf = /* @__PURE__ */ new Map();
   typeOfTypeNode = /* @__PURE__ */ new Map();
   expectedTypeOf = /* @__PURE__ */ new Map();
-  iteratesValues = /* @__PURE__ */ new Set();
+  loops = /* @__PURE__ */ new Map();
   /** Public: each alias resolved once (generic aliases keep their params as
    *  `typeParam` nodes in the body). */
-  aliases = new AliasMap();
+  aliases = new LazyMap();
   /** Uninstantiated alias definitions, for `Name<Args>` instantiation. */
   aliasDefs = /* @__PURE__ */ new Map();
   /** Put on every ref to one of `aliasDefs`, so a module that imports the
@@ -5530,8 +5692,12 @@ var TypeAnalyzer = class {
   /** Generic parameters currently in lexical scope (alias body / generic fn),
    *  with their `extends` constraints resolved. */
   typeParamScope = [];
-  /** Global types contributed by `declare` statements (libs, then this program). */
-  libGlobalTypes = /* @__PURE__ */ new Map();
+  /** Global types contributed by `declare` statements (libs, then this program).
+   *  A library's are resolved when the name is first used: an engine's
+   *  definitions declare hundreds of globals, and a script uses a few. */
+  libGlobalTypes = new LazyMap();
+  /** Each library `declare` of a name, in order, until it is resolved. */
+  libDeclares = /* @__PURE__ */ new Map();
   /** Declaration node -> binding, built once so `bindingIdByName` is O(1)
    *  instead of a scan of every binding per declaration site. */
   bindingByDecl = /* @__PURE__ */ new Map();
@@ -5576,8 +5742,11 @@ var TypeAnalyzer = class {
     this.indexDeclarations();
     for (const [name, id] of this.scopes.globalsByName) {
       if (this.deferredDeclares.has(name) && !this.options.globalTypes?.[name]) continue;
-      const t = this.options.globalTypes?.[name] ?? this.libGlobalTypes.get(name) ?? anyType;
-      this.bindingType.set(id, t);
+      const given = this.options.globalTypes?.[name];
+      if (given) this.bindingType.set(id, given);
+      else if (this.libGlobalTypes.has(name)) this.bindingType.defer(id, () => this.libGlobalTypes.get(name) ?? anyType);
+      else if (LANGUAGE_GLOBALS.includes(name)) this.bindingType.set(id, arrayOf(unknownType));
+      else this.bindingType.set(id, anyType);
     }
     setAliasExpander((t) => this.expand(t));
     setDeferredBound((t) => this.deferredBound(t));
@@ -5597,7 +5766,7 @@ var TypeAnalyzer = class {
       typeOfTypeNode: this.typeOfTypeNode,
       expectedTypeOf: this.expectedTypeOf,
       aliases: this.resolveDeferredAliases(),
-      iteratesValues: this.iteratesValues,
+      loops: this.loops,
       diagnostics: this.diagnostics
     };
   }
@@ -5949,28 +6118,55 @@ var TypeAnalyzer = class {
     type.name = `typeof ${this.className(stmt)}`;
     const shape = this.shapeOf(stmt);
     const local = this.superDecl(stmt);
-    const parent = local ? this.classValueType(local) : stmt.superclass ? this.classStaticsByNameType(stmt.superclass.name) : void 0;
+    const parent = local ? this.classValueType(local) : stmt.superclass ? this.classStaticsOf(stmt.superclass) : void 0;
     if (parent?.kind === "object") {
       for (const [key, property] of parent.properties) {
         if (!CLASS_LINKS.has(key)) type.properties.set(key, property);
       }
     }
     for (const [key, property] of shape.statics) type.properties.set(key, property);
-    const constructor = this.constructorType(stmt);
+    if (shape.filling) {
+      (shape.filled ??= []).push(() => {
+        for (const [key, property] of shape.statics) type.properties.set(key, property);
+      });
+    }
     const params = this.classTypeParams(stmt);
-    type.properties.set("new", {
-      type: fn(
-        constructor?.params.filter((p) => p.name !== "this") ?? [],
-        this.selfTypeOf(stmt),
-        constructor?.varargs,
-        params.map((p) => p.name)
-      ),
+    let settled;
+    const construct = {
       optional: false,
-      readonly: true
+      readonly: true,
+      // Kept, so a class extending it can read what it takes; reaching
+      // it from outside is the error.
+      ...stmt.isAbstract ? { abstract: true } : {}
+    };
+    Object.defineProperty(construct, "type", {
+      enumerable: true,
+      get: () => {
+        if (settled) return settled;
+        const constructor = this.constructorType(stmt);
+        const made = fn(
+          constructor?.params.filter((p) => p.name !== "this") ?? [],
+          this.selfTypeOf(stmt),
+          constructor?.varargs,
+          params.map((p) => p.name)
+        );
+        if (!this.shapeOf(stmt).filling) settled = made;
+        return made;
+      }
     });
+    type.properties.set("new", construct);
     type.properties.set("ParentClass", { type: parent ?? nilType, optional: false, readonly: true });
     return type;
   }
+  /** The value side of the class `superclass` names when it is not
+   *  declared in this file: what the name it refers to holds — an import
+   *  brings the class table with it — or else a class of that name. */
+  classStaticsOf(superclass) {
+    const id = this.bindingIdOf(superclass);
+    const bound = id !== void 0 ? this.expand(this.bindingType.get(id) ?? unknownType) : void 0;
+    if (bound?.kind === "object") return bound;
+    return this.classStaticsByNameType(superclass.name);
+  }
   /** The value side of a class named by a binding rather than by a
    *  declaration in this file — an imported one. */
   classStaticsByNameType(name) {
@@ -6031,20 +6227,26 @@ var TypeAnalyzer = class {
     } finally {
       this.emitDiagnostics = wasEmitting;
       shape.filling = false;
+      for (const then of shape.filled ?? []) then();
+      shape.filled = void 0;
     }
     return shape;
   }
   fillShape(stmt, shape) {
     const className = this.className(stmt);
     const put = (isStatic, name, property) => {
-      const member = stmt.members.find((m) => m.type !== "ClassConstructor" && m.isStatic === isStatic && m.name.name === name && m.accessibility === "private");
-      const marked = member ? { ...property, private: { owner: stmt, className } } : property;
+      const member = stmt.members.find((m) => m.type !== "ClassConstructor" && m.isStatic === isStatic && m.name.name === name && (m.accessibility === "private" || m.accessibility === "protected"));
+      const marked = member ? { ...property, private: { owner: stmt, className, ...member.accessibility === "protected" ? { protected: true } : {} } } : property;
       (isStatic ? shape.statics : shape.instance).set(name, marked);
     };
     for (const member of stmt.members) {
       if (member.type !== "ClassField") continue;
       const type = member.typeAnnotation ? this.resolveType(member.typeAnnotation) : member.init ? widen(this.infer(member.init, /* @__PURE__ */ new Map())) : anyType;
-      put(member.isStatic, member.name.name, { type, optional: false });
+      put(member.isStatic, member.name.name, {
+        type,
+        optional: false,
+        ...member.isReadonly ? { readonly: true } : {}
+      });
     }
     for (const member of stmt.members) {
       switch (member.type) {
@@ -6053,7 +6255,11 @@ var TypeAnalyzer = class {
         case "ClassMethod": {
           this.paramsFromSignatures(member.func, member.signatures);
           const type = member.signatures?.length ? intersection(member.signatures.map((sig) => this.signatureToFnType(sig))) : this.inferFunctionBody(member.func, /* @__PURE__ */ new Map());
-          put(member.isStatic, member.name.name, { type, optional: false });
+          put(member.isStatic, member.name.name, {
+            type,
+            optional: false,
+            ...member.isAbstract ? { abstract: true } : {}
+          });
           break;
         }
         case "ClassAccessor": {
@@ -6109,7 +6315,14 @@ var TypeAnalyzer = class {
           for (const signature of member.signatures ?? []) {
             this.checkParamOrder(signature.params, member);
           }
-          this.visitFunctionBody(member.func, env);
+          if (member.type === "ClassMethod" && member.isAbstract) continue;
+          const constructing = this.constructing;
+          if (member.type === "ClassConstructor") this.constructing = stmt;
+          try {
+            this.visitFunctionBody(member.func, env);
+          } finally {
+            this.constructing = constructing;
+          }
         }
       });
     }));
@@ -6156,13 +6369,148 @@ var TypeAnalyzer = class {
     if (stmt.superclass && this.baseInstance(stmt) && constructor && !callsSuper(constructor.func.body)) {
       report(constructor, `'${name}' extends '${stmt.superclass.name}', so its constructor must call 'super(...)'`);
     }
-    const assigned = constructor ? assignedFields(constructor.func.body) : /* @__PURE__ */ new Set();
+    this.checkAbstractMembers(stmt);
+    this.checkOverrides(stmt);
+    this.checkImplements(stmt);
+    this.checkMetamethods(stmt);
+    const assigned = constructor ? definitelyAssigned(constructor.func.body) ?? ALL_FIELDS : /* @__PURE__ */ new Set();
     for (const member of stmt.members) {
       if (member.type !== "ClassField" || member.isStatic || member.init) continue;
-      if (assigned.has(member.name.name)) continue;
+      if (assigned === ALL_FIELDS || assigned.has(member.name.name)) continue;
       const type = member.typeAnnotation ? this.withTypeParams(this.classTypeParams(stmt), () => this.resolveType(member.typeAnnotation)) : anyType;
       if (isAssignable(nilType, type)) continue;
-      report(member.name, `'${member.name.name}' has no value: give it one, assign it in the constructor, or let its type admit nil`);
+      report(member.name, `'${member.name.name}' has no value: give it one, assign it in the constructor on every path, or let its type admit nil`);
+    }
+  }
+  /** The class whose constructor is being checked: it, and only it, may
+   *  assign the `readonly` fields it declares. */
+  constructing;
+  /** A class that is not abstract has a `new`, so everything its instances
+   *  promise has to be there: no abstract member of its own, and every one
+   *  it inherits written. */
+  checkAbstractMembers(stmt) {
+    if (stmt.isAbstract) return;
+    const name = this.className(stmt);
+    for (const member of stmt.members) {
+      if (member.type === "ClassMethod" && member.isAbstract) {
+        this.diagnostics.push({
+          node: member.name,
+          message: `'${member.name.name}' is abstract, so '${name}' has to be an 'abstract class'`
+        });
+      }
+    }
+    const own = this.shapeOf(stmt).instance;
+    const missing = [...this.instanceType(stmt).properties].filter(([key, property]) => property.abstract && !own.has(key)).map(([key]) => `'${key}'`);
+    if (missing.length) {
+      this.diagnostics.push({
+        node: stmt.name ?? stmt,
+        message: `'${name}' does not write the abstract ${missing.length === 1 ? "member" : "members"} ${missing.join(", ")} of the class it extends; write ${missing.length === 1 ? "it" : "them"}, or make '${name}' abstract too`
+      });
+    }
+  }
+  /** A member written again in a class that extends another has to fit
+   *  where the base's stood — anything reading an instance as the base
+   *  would otherwise be told wrong. `override` says a member is such a one,
+   *  and is wrong on a member that is not. */
+  checkOverrides(stmt) {
+    const base = this.baseInstance(stmt);
+    const name = this.className(stmt);
+    const own = this.shapeOf(stmt).instance;
+    for (const member of stmt.members) {
+      if (member.type === "ClassConstructor" || member.isStatic) continue;
+      const key = member.name.name;
+      const inherited = CLASS_LINKS.has(key) ? void 0 : base?.properties.get(key);
+      if (member.isOverride && !inherited) {
+        this.diagnostics.push({
+          node: member.name,
+          message: base ? `'${key}' is marked 'override', but '${stmt.superclass.name}' has no member of that name` : `'${key}' is marked 'override', but '${name}' does not extend another class`
+        });
+        continue;
+      }
+      const mine = own.get(key);
+      if (!inherited || !mine || inherited.private && !inherited.private.protected) continue;
+      const written = withoutReceiver(mine.type);
+      const expected = withoutReceiver(inherited.type);
+      if (isAssignable(written, expected)) continue;
+      this.diagnostics.push({
+        node: member.name,
+        message: `'${key}' in '${name}' does not fit the '${key}' of '${stmt.superclass.name}' it replaces: '${briefType(written)}' is not assignable to '${briefType(expected)}'`
+      });
+    }
+  }
+  /** `implements Shape`: every member the shape names, of a type that fits.
+   *  A method's own `this` is left out of the comparison on both sides. */
+  checkImplements(stmt) {
+    if (!stmt.implements?.length) return;
+    const name = this.className(stmt);
+    const instance = this.instanceType(stmt).properties;
+    for (const node of stmt.implements) {
+      const shown = node.type === "TypeReference" ? node.namespace ? `${node.namespace}.${node.base}` : node.base : void 0;
+      const target = this.expand(this.withTypeParams(this.classTypeParams(stmt), () => this.resolveType(node)));
+      if (target.kind === "any") continue;
+      if (target.kind !== "object") {
+        this.diagnostics.push({
+          node,
+          message: `A class can only implement an object type or a class, not '${briefType(target)}'`
+        });
+        continue;
+      }
+      const label = shown ?? briefType(target);
+      const missing = [];
+      for (const [key, wanted] of target.properties) {
+        const have = instance.get(key);
+        if (!have) {
+          if (!wanted.optional) missing.push(`'${key}'`);
+          continue;
+        }
+        const written = withoutReceiver(have.type);
+        const expected = withoutReceiver(wanted.optional ? optional(wanted.type) : wanted.type);
+        if (isAssignable(written, expected)) continue;
+        this.diagnostics.push({
+          node,
+          message: `'${name}' does not implement '${label}': its '${key}' is '${briefType(written)}', not '${briefType(expected)}'`
+        });
+      }
+      if (missing.length) {
+        this.diagnostics.push({
+          node,
+          message: `'${name}' does not implement '${label}': ${missing.join(", ")} ${missing.length === 1 ? "is" : "are"} missing`
+        });
+      }
+    }
+  }
+  /** A method named for a metamethod *is* one — the class table is its
+   *  instances' metatable — so it has to take what Luau hands it and give
+   *  back what Luau expects. */
+  checkMetamethods(stmt) {
+    const instance = this.shapeOf(stmt).instance;
+    for (const member of stmt.members) {
+      if (member.type !== "ClassMethod" || !(member.name.name in METAMETHOD_OPERANDS)) continue;
+      const key = member.name.name;
+      if (member.isStatic) {
+        this.diagnostics.push({
+          node: member.name,
+          message: `'${key}' is a metamethod of the instances; it cannot be static`
+        });
+        continue;
+      }
+      const operands = METAMETHOD_OPERANDS[key];
+      const written = member.func.params.filter((p) => p.name !== "this").length;
+      if (operands !== void 0 && (written !== operands || member.func.hasVarargs)) {
+        this.diagnostics.push({
+          node: member.name,
+          message: operands === 0 ? `'${key}' takes nothing besides 'this'` : `'${key}' takes one operand besides 'this'`
+        });
+        continue;
+      }
+      const required = METAMETHOD_RETURNS[key];
+      const returns = this.overloadsOf(instance.get(key)?.type ?? anyType)[0]?.returns;
+      if (required && returns && !isAssignable(returns, required)) {
+        this.diagnostics.push({
+          node: member.name,
+          message: `'${key}' has to return ${briefType(required)}, not '${briefType(returns)}'`
+        });
+      }
     }
   }
   /** `extends` must name a class, and the chain must end. */
@@ -6220,19 +6568,42 @@ var TypeAnalyzer = class {
   harvestDeclares(block, own = false) {
     for (const stmt of block.statements) {
       if (stmt.type !== "DeclareStatement") continue;
-      if (own && (containsTypeQuery(stmt.valueType) || referencedTypeNames(stmt.valueType).some((name) => this.dependsOnTypeQuery(name)))) {
+      if (!own) {
+        const declares = this.libDeclares.get(stmt.name);
+        if (declares) declares.push(stmt);
+        else {
+          this.libDeclares.set(stmt.name, [stmt]);
+          this.libGlobalTypes.defer(stmt.name, () => this.resolveLibDeclares(stmt.name));
+        }
+        continue;
+      }
+      if (containsTypeQuery(stmt.valueType) || referencedTypeNames(stmt.valueType).some((name) => this.dependsOnTypeQuery(name))) {
         this.deferredDeclares.set(stmt.name, stmt);
         continue;
       }
-      const t = this.resolveType(stmt.valueType);
-      const prev = this.libGlobalTypes.get(stmt.name);
-      const overload = prev && stmt.valueType.type === "FunctionTypeNode" && (prev.kind === "function" || prev.kind === "intersection");
-      this.libGlobalTypes.set(
-        stmt.name,
-        overload ? intersection([prev, t]) : this.mergeDeclared(prev, t)
-      );
+      this.libGlobalTypes.set(stmt.name, this.declaredOver(this.libGlobalTypes.get(stmt.name), stmt));
     }
   }
+  /** Every library `declare` of `name`, in order. They are written at the
+   *  top level of their files, so they are read as if there — outside any
+   *  generic the use that asked for them happens to sit in. */
+  resolveLibDeclares(name) {
+    const scope = this.typeParamScope.splice(0);
+    try {
+      let type;
+      for (const stmt of this.libDeclares.get(name) ?? []) type = this.declaredOver(type, stmt);
+      return type ?? anyType;
+    } finally {
+      this.typeParamScope.push(...scope);
+    }
+  }
+  /** A `declare` on top of what earlier ones said about the same name: a
+   *  function adds an overload, a table adds members. */
+  declaredOver(prev, stmt) {
+    const t = this.resolveType(stmt.valueType);
+    const overload = prev && stmt.valueType.type === "FunctionTypeNode" && (prev.kind === "function" || prev.kind === "intersection");
+    return overload ? intersection([prev, t]) : this.mergeDeclared(prev, t);
+  }
   resolveAllAliases() {
     for (const [name, def] of this.aliasDefs) {
       if (def.class && !this.program.body.statements.includes(def.class)) {
@@ -6278,11 +6649,10 @@ var TypeAnalyzer = class {
   }
   imported;
   /** What a `return` gives, against what the function declared. */
-  checkReturn(stmt, declared, types, sources, env) {
+  checkReturn(stmt, declared, actual, env) {
     if (!declared || !this.emitDiagnostics) return;
     if (declared.kind === "any" || declared.kind === "unknown" || this.namesNothing(declared)) return;
-    const actual = stmt.arguments.length === 0 ? nilType : types.length === 1 ? types[0] : tuple([...types], true);
-    const source = stmt.arguments.length === 1 ? sources[0] : void 0;
+    const source = stmt.argument;
     const fits = source ? this.fitsAnnotation(source, declared, actual, env) : isAssignable(actual, declared) || isAssignable(widen(actual), declared);
     if (fits) return;
     this.diagnostics.push({
@@ -6430,21 +6800,12 @@ var TypeAnalyzer = class {
       this.instantiationDepth--;
     }
   }
-  /** Pair written type arguments with the parameters they instantiate. A
-   *  pack parameter (`T...`) takes every argument from its position on, as
-   *  one pack: `Signal<Instance, string>` binds `T` to `(Instance, string)`,
-   *  and `Signal<()>` to the empty pack. Left out, a parameter takes its
-   *  default (`T... = ...any` is `any`), or `unknown`. */
+  /** Pair written type arguments with the parameters they instantiate.
+   *  Left out, a parameter takes its default, or `unknown`. */
   bindTypeArguments(params, args) {
     const subst = /* @__PURE__ */ new Map();
     params.forEach((p, i) => {
-      let arg = args[i];
-      if (p.isPack && i < args.length) {
-        const rest = args.slice(i);
-        const single = rest.length === 1 ? rest[0] : void 0;
-        arg = single && (single.kind === "tuple" && single.isPack || single.kind === "typeParam" || single.kind === "any") ? single : tuple([...rest], true);
-      }
-      subst.set(p.name, arg ?? (p.default ? this.resolveType(p.default) : unknownType));
+      subst.set(p.name, args[i] ?? (p.default ? this.resolveType(p.default) : unknownType));
     });
     return subst;
   }
@@ -6536,8 +6897,13 @@ var TypeAnalyzer = class {
         return literal(node.value);
       case "ArrayTypeNode":
         return arrayOf(this.resolveType(node.element));
-      case "TupleTypeNode":
-        return tuple(node.elements.map((e) => this.resolveType(e)));
+      case "TupleTypeNode": {
+        const rest = node.rest && this.expand(this.resolveType(node.rest));
+        return tuple(
+          node.elements.map((e) => this.resolveType(e)),
+          rest ? rest.kind === "array" ? rest.element : rest.kind === "any" ? anyType : unknownType : void 0
+        );
+      }
       case "UnionTypeNode":
         return union(node.types.map((t) => this.resolveType(t)));
       case "IntersectionTypeNode":
@@ -6573,15 +6939,13 @@ var TypeAnalyzer = class {
             type: p.optional ? optional(this.resolveType(p.typeAnnotation)) : this.resolveType(p.typeAnnotation),
             optional: p.optional
           }));
-          const restParam = node.params.find((p) => p.rest);
-          const restElement = restParam ? this.resolveType(restParam.typeAnnotation) : void 0;
-          return this.withTypeParamDefaults(fn(
+          return this.withTypeParamDefaults(this.withRest(fn(
             params,
             this.resolveType(node.returnType),
-            restParam ? restElement?.kind === "array" ? restElement.element : unknownType : node.hasVarargs ? node.varargType ? this.resolveType(node.varargType) : anyType : void 0,
+            void 0,
             names,
             this.resolvePredicate(node.predicate, params)
-          ), node.generics);
+          ), node.params), node.generics);
         });
       }
       case "TypeofTypeNode": {
@@ -6645,13 +7009,6 @@ var TypeAnalyzer = class {
           })
         );
       }
-      case "VariadicTypeNode":
-        return this.resolveType(node.typeAnnotation);
-      case "TypePackNode": {
-        if (node.types.length === 1 && !node.hasVarargs) return this.resolveType(node.types[0]);
-        if (!node.types.length && node.varargType) return this.resolveType(node.varargType);
-        return tuple(node.types.map((t) => this.resolveType(t)), true);
-      }
     }
   }
   // --------------------------------------------------------
@@ -6717,15 +7074,18 @@ var TypeAnalyzer = class {
         case "array":
           return arrayOf(this.reduceType(t.element));
         case "tuple":
-          return tuple(t.elements.map((e) => this.reduceType(e)), t.isPack);
+          return tuple(t.elements.map((e) => this.reduceType(e)), t.rest && this.reduceType(t.rest));
         case "function":
-          return fn(
-            t.params.map((p) => ({ ...p, type: this.reduceType(p.type) })),
-            this.reduceType(t.returns),
-            t.varargs && this.reduceType(t.varargs),
-            t.typeParams,
-            t.predicate
-          );
+          return {
+            ...fn(
+              t.params.map((p) => ({ ...p, type: this.reduceType(p.type) })),
+              this.reduceType(t.returns),
+              t.varargs && this.reduceType(t.varargs),
+              t.typeParams,
+              t.predicate
+            ),
+            ...t.restIsWhole ? { restIsWhole: true } : {}
+          };
         case "object": {
           if (t.class) return t;
           const entries = [];
@@ -6940,7 +7300,8 @@ var TypeAnalyzer = class {
             this.applyContext(stmt.init[i], this.resolveType(target.typeAnnotation));
           }
         });
-        const { types: valueTypes, sources } = this.valueList(stmt.init, env, stmt.names.length);
+        const { types: valueTypes, sources } = this.valueList(stmt.init, env);
+        this.checkValueCount(stmt, stmt.names.length, stmt.init, valueTypes);
         stmt.names.forEach((target, i) => {
           const inferred = valueTypes[i] ?? (stmt.init.length ? unknownType : nilType);
           const source = sources[i];
@@ -7029,7 +7390,8 @@ var TypeAnalyzer = class {
             if (id !== void 0 && this.annotated.has(id)) this.applyContext(value, this.bindingType.get(id));
           }
         });
-        const { types: valueTypes, sources } = this.valueList(stmt.values, env, stmt.targets.length);
+        const { types: valueTypes, sources } = this.valueList(stmt.values, env);
+        this.checkValueCount(stmt, stmt.targets.length, stmt.values, valueTypes);
         stmt.targets.forEach((target, i) => {
           const vt = valueTypes[i] ?? unknownType;
           const source = sources[i];
@@ -7116,23 +7478,26 @@ var TypeAnalyzer = class {
         return;
       }
       case "GenericForStatement": {
-        const iterTypes = stmt.iterators.map((it) => this.infer(it, env));
+        const sourceType = this.infer(stmt.iterator, env);
         const bodyEnv = forkEnv(env);
-        const rows = stmt.variables.length >= 2 ? this.iterationRows(stmt.iterators[0], iterTypes[0]) : void 0;
+        const rows = this.iterationRows(stmt.iterator, sourceType);
         if (rows) {
-          const [key, value] = stmt.variables;
-          this.bindPattern(key, union(rows.map((r) => r[0])), bodyEnv, "keep");
-          this.bindPattern(value, union(rows.map((r) => r[1])), bodyEnv, "keep");
-          stmt.variables.slice(2).forEach((v) => this.bindPattern(v, unknownType, bodyEnv, "widen"));
-          const keyId = key.type === "IdentifierPattern" ? this.bindingIdByName(key.name, key) : void 0;
-          const valueId = value.type === "IdentifierPattern" ? this.bindingIdByName(value.name, value) : void 0;
-          if (keyId !== void 0 && valueId !== void 0) this.correlateBindings(bodyEnv, [keyId, valueId], rows);
+          this.bindPattern(
+            stmt.variable,
+            union(rows.map((row) => tuple(row))),
+            bodyEnv,
+            stmt.kind === "const" ? "keep" : "widen"
+          );
+          const parts = stmt.variable.type === "ArrayPattern" && !stmt.variable.rest ? stmt.variable.elements.slice(0, 2).map((el) => el?.value) : [];
+          const ids = parts.map((p) => p?.type === "IdentifierPattern" ? this.bindingIdByName(p.name, p) : void 0);
+          if (ids.length === 2 && ids.every((id) => id !== void 0)) {
+            this.correlateBindings(bodyEnv, ids, rows);
+          }
+          this.loops.set(stmt, { walks: "iteration", viaIter: false });
         } else {
-          const [keyT, valT, iteratesValues] = this.iterationTypes(stmt.iterators[0], iterTypes[0], stmt.variables.length);
-          stmt.variables.forEach((v, i) => {
-            this.bindPattern(v, i === 0 ? keyT : i === 1 ? valT : unknownType, bodyEnv, "widen");
-          });
-          if (iteratesValues && stmt.iterators.length === 1) this.iteratesValues.add(stmt);
+          const [item, form] = this.iterationOf(stmt.iterator, sourceType);
+          this.bindPattern(stmt.variable, item, bodyEnv, "widen");
+          this.loops.set(stmt, form);
         }
         this.visitBlock(stmt.body, bodyEnv);
         return;
@@ -7140,19 +7505,10 @@ var TypeAnalyzer = class {
       case "ReturnStatement": {
         const declared = this.declaredReturns[this.declaredReturns.length - 1];
         const wanted = declared ?? this.contextualReturns[this.contextualReturns.length - 1];
-        if (wanted) {
-          if (stmt.arguments.length === 1) {
-            this.applyContext(stmt.arguments[0], wanted);
-          } else if (wanted.kind === "tuple" && wanted.isPack) {
-            stmt.arguments.forEach((a, i) => this.applyContext(a, wanted.elements[i]));
-          }
-        }
-        const want = declared?.kind === "tuple" && declared.isPack ? declared.elements.length : 0;
-        const { types, sources } = this.valueList(stmt.arguments, env, want);
-        this.checkReturn(stmt, declared, types, sources, env);
-        if (this.returnTypes) {
-          this.returnTypes.push(stmt.arguments.length === 0 ? nilType : types.length === 1 ? types[0] : tuple([...types], true));
-        }
+        if (wanted && stmt.argument) this.applyContext(stmt.argument, wanted);
+        const actual = stmt.argument ? this.infer(stmt.argument, env) : nilType;
+        this.checkReturn(stmt, declared, actual, env);
+        if (this.returnTypes) this.returnTypes.push(actual);
         return;
       }
       case "ExportStatement":
@@ -7239,7 +7595,7 @@ var TypeAnalyzer = class {
    *  `sources` maps each produced value back to the expression it came from
    *  (undefined for the 2nd and later values of a multi-value call), so the
    *  caller can still do contextual typing against the written expression. */
-  valueList(exprs, env, want = 0) {
+  valueList(exprs, env) {
     const types = [];
     const sources = [];
     exprs.forEach((e, i) => {
@@ -7255,31 +7611,29 @@ var TypeAnalyzer = class {
           }
           return;
         }
-        do {
-          types.push(t);
-          sources.push(e);
-        } while (last && types.length < want);
-        return;
-      }
-      if (last && e.type === "VarargExpression") {
-        do {
-          types.push(t);
-          sources.push(types.length - 1 === i ? e : void 0);
-        } while (types.length < want);
+        types.push(t);
+        sources.push(e);
         return;
       }
-      if (last && t.kind === "tuple" && t.isPack && producesMultipleValues(e)) {
-        t.elements.forEach((el, j) => {
-          types.push(el);
-          sources.push(j === 0 ? e : void 0);
-        });
-        return;
-      }
-      types.push(t.kind === "tuple" && t.isPack && producesMultipleValues(e) ? t.elements[0] ?? nilType : t);
+      void last;
+      types.push(t);
       sources.push(e);
     });
     return { types, sources };
   }
+  /** `const a, b = x, y` pairs names with values, one each. A call is one
+   *  value — several come back as an array — so `const a, b = f()` is a
+   *  name short of a value, and says how to take them apart. */
+  checkValueCount(node, names, values, types) {
+    if (!this.emitDiagnostics || !values.length || types.length >= names) return;
+    const last = values[values.length - 1];
+    const lastType = types[types.length - 1] && this.expand(types[types.length - 1]);
+    const call = last.type === "CallExpression" || last.type === "MethodCallExpression";
+    this.diagnostics.push({
+      node,
+      message: call && (lastType?.kind === "tuple" || lastType?.kind === "array") ? `A call is one value, here an array: take its parts with '[${Array.from({ length: names }, (_, i) => String.fromCharCode(97 + i)).join(", ")}] = ...'` : `${names} names, but ${types.length} ${types.length === 1 ? "value" : "values"}: each name needs one`
+    });
+  }
   /** Run `visit` with a fresh place to collect `break` states, and return
    *  what it collected. */
   withBreakScope(visit) {
@@ -7428,18 +7782,29 @@ var TypeAnalyzer = class {
    *  context. */
   contextualArrays = /* @__PURE__ */ new WeakMap();
   applyArrayContext(e, expected) {
-    const target = this.expectedMembers(expected).find((m) => m.kind === "array" || m.kind === "tuple");
+    const members = this.expectedMembers(expected);
+    const tuples = members.filter((m) => m.kind === "tuple");
+    const spread = e.elements.some((el) => el.type === "SpreadElement");
+    const length = e.elements.length;
+    const fitting = tuples.find((t) => !spread && !t.rest && t.elements.length === length) ?? tuples.find((t) => t.rest !== void 0 && (spread || length >= t.elements.length));
+    const target = fitting ?? members.find((m) => m.kind === "array") ?? tuples[0];
     if (!target) return;
+    if (target.kind === "tuple" && e.elements.length) this.tupleArrays.set(e, target);
     if (!e.elements.length) {
       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];
+      const tupleTarget = target;
+      const elementType = target.kind === "array" ? target.element : tupleTarget.elements[i] ?? tupleTarget.rest;
       this.applyContext(element, elementType);
     });
   }
+  /** Array literals written where a tuple is wanted — a `return` of a
+   *  function that returns one, an argument, an annotated `const` — and
+   *  the tuple each is to be. */
+  tupleArrays = /* @__PURE__ */ new WeakMap();
   /** `{ list: [] }` where `{ list: thread[] }` is expected: each field's
    *  value gets its property's type as context. */
   applyTableContext(e, expected) {
@@ -7495,32 +7860,33 @@ var TypeAnalyzer = class {
     }
     return tuple(target.elements.map((el) => el ? leaf(el.value, el.default) : anyType));
   }
-  /** What a vararg function's `...` holds, one value at a time.
-   *
-   *  Written three ways, and they mean the same call: `...` says nothing,
-   *  `...: T` says each value is a `T`, and `...rest: T[]` collects them
-   *  into an array the body reads by name. Only the last changes what the
-   *  body sees — the signature is the same either way. */
-  varargElement(func) {
-    if (!func.hasVarargs) return void 0;
-    const rest = func.params.find((p) => p.rest);
-    if (!rest) return func.varargTypeAnnotation ? this.resolveType(func.varargTypeAnnotation) : anyType;
-    const declared = rest.typeAnnotation ? this.resolveType(rest.typeAnnotation) : void 0;
-    return declared?.kind === "array" ? declared.element : unknownType;
-  }
-  /** The type of `...` in each function body being walked. */
-  varargs = [];
+  /** A function type with the rest parameter among `params` written in:
+   *  `...args: T[]` collects `T`s, and `...args: A` — `A` a tuple, or a
+   *  type parameter standing for one — is exactly `A`'s elements. */
+  withRest(f, params) {
+    const rest = params.find((p) => p.rest);
+    if (!rest) return f;
+    if (!rest.typeAnnotation) return { ...f, varargs: unknownType };
+    const declared = this.resolveType(rest.typeAnnotation);
+    const t = this.expand(declared);
+    if (t.kind === "array") return { ...f, varargs: t.element };
+    if (t.kind === "any") return { ...f, varargs: anyType };
+    if (declared.kind === "infer") return { ...f, varargs: declared, restIsWhole: true };
+    if (t.kind === "tuple") {
+      return { ...f, params: [...f.params, ...t.elements.map((type) => ({ type }))], varargs: t.rest };
+    }
+    if (declared.kind === "typeParam") return { ...f, varargs: declared, restIsWhole: true };
+    return { ...f, varargs: unknownType };
+  }
   /** What each function body being walked declared it returns. */
   declaredReturns = [];
-  /** Run `body` with `...` and `return` as `func` declares them. */
+  /** Run `body` with `return` as `func` declares it. */
   withVarargs(func, body) {
-    this.varargs.push(this.varargElement(func));
     this.declaredReturns.push(func.predicate ? booleanType : func.returnType ? this.resolveType(func.returnType) : void 0);
     this.contextualReturns.push(this.contextualReturnOf.get(func));
     try {
       return body();
     } finally {
-      this.varargs.pop();
       this.declaredReturns.pop();
       this.contextualReturns.pop();
     }
@@ -7579,7 +7945,7 @@ var TypeAnalyzer = class {
     if (type.kind !== "function") return type;
     const defaults = {};
     for (const generic of generics) {
-      if (generic.default && !generic.isPack) defaults[generic.name] = this.resolveType(generic.default);
+      if (generic.default) defaults[generic.name] = this.resolveType(generic.default);
     }
     return Object.keys(defaults).length ? { ...type, typeParamDefaults: defaults } : type;
   }
@@ -7598,7 +7964,10 @@ var TypeAnalyzer = class {
       const preserve = keepsLiterals(param) || param.kind !== "typeParam" && containsTypeParam(param);
       unify(p.type, preserve ? arg : widen(arg), vars, subst);
     });
-    if (f.varargs) {
+    if (f.varargs && f.restIsWhole) {
+      const rest = argTypes.slice(f.params.length).map((a) => a === void 0 ? unknownType : widen(a));
+      unify(f.varargs, tuple(rest), vars, subst);
+    } else if (f.varargs) {
       const keeps = keepsLiterals(f.varargs);
       for (let i = f.params.length; i < argTypes.length; i++) {
         const arg = argTypes[i];
@@ -7767,7 +8136,12 @@ var TypeAnalyzer = class {
       const arg = argTypes[i];
       const declared = declaredAt(i);
       if (arg === void 0 || declared === void 0 || !containsTypeParam(declared)) continue;
-      const expected = this.reduceType(substitute(declared, subst));
+      let expected = this.reduceType(substitute(declared, subst));
+      if (f.restIsWhole && i >= f.params.length) {
+        const whole = this.expand(expected);
+        expected = whole.kind === "tuple" ? whole.elements[i - f.params.length] ?? whole.rest : whole.kind === "array" ? whole.element : void 0;
+        if (!expected) continue;
+      }
       if (containsTypeParam(expected) || expected.kind === "any" || expected.kind === "unknown") continue;
       if (isAssignable(arg, expected) || isAssignable(widen(arg), expected)) continue;
       this.diagnostics.push({
@@ -7895,13 +8269,13 @@ var TypeAnalyzer = class {
         type: this.paramType(p, /* @__PURE__ */ new Map()),
         optional: p.optional || p.default !== void 0
       }));
-      return fn(
+      return this.withRest(fn(
         params,
         sig.returnType ? this.resolveType(sig.returnType) : sig.predicate ? booleanType : anyType,
-        this.varargElement(sig),
+        void 0,
         names,
         this.resolvePredicate(sig.predicate, params)
-      );
+      ), sig.params);
     }));
   }
   /** `...rest: T[]` holds every argument from its position on, so its type
@@ -7909,7 +8283,7 @@ var TypeAnalyzer = class {
   checkRestType(p, node) {
     if (!this.emitDiagnostics || !p.typeAnnotation) return;
     const declared = this.resolveType(p.typeAnnotation);
-    if (declared.kind === "array" || declared.kind === "any" || declared.kind === "typeParam") return;
+    if (declared.kind === "array" || declared.kind === "tuple" || declared.kind === "any" || declared.kind === "typeParam") return;
     this.diagnostics.push({
       node,
       message: `A rest parameter holds every argument from its position on, so '${p.name ?? "..."}' is an array: '${formatType(declared)}[]', not '${formatType(declared)}'`
@@ -7965,13 +8339,13 @@ var TypeAnalyzer = class {
           return collected.length ? union(collected) : this.inferReturnType(func.body, bodyEnv);
         }));
       }
-      return fn(
+      return this.withRest(fn(
         params,
         returns,
-        this.varargElement(func),
+        void 0,
         names,
         this.resolvePredicate(func.predicate, params)
-      );
+      ), func.params);
     });
   }
   /** Where the return types of the function being walked are collected, so
@@ -8013,17 +8387,16 @@ var TypeAnalyzer = class {
       this.preVisitDepth--;
     }
   }
-  /** The `[key, value]` pairs iterating a record yields, one per property —
-   *  for `pairs(t)`, `next, t` and `for k, v in t` over an object type with
-   *  no indexer. `undefined` for anything else (an array, a dictionary, an
-   *  iterator function), whose keys have no names to list. */
+  /** The `[key, value]` items `pairs(record)` hands out, one per property.
+   *  `undefined` for anything else (an array, a dictionary, an iterator
+   *  function), whose keys have no names to list. */
   iterationRows(iterNode, iterType) {
     let source;
     if (iterNode?.type === "CallExpression" && iterNode.callee.type === "Identifier" && iterNode.arguments[0]) {
-      if (iterNode.callee.name !== "pairs" && iterNode.callee.name !== "next") return void 0;
+      if (iterNode.callee.name !== "pairs") return void 0;
       source = this.typeOf.get(iterNode.arguments[0]);
     } else {
-      source = iterType;
+      return void 0;
     }
     const t = source && this.expand(source);
     if (!t || t.kind !== "object" || t.class || t.indexer || !t.properties.size) return void 0;
@@ -8164,54 +8537,69 @@ var TypeAnalyzer = class {
     if (ids.length < 2) return;
     this.correlateBindings(env, ids, objects.map((member) => names.map((name) => this.propertyType(member, name))));
   }
-  /** `(keyType, valueType, iteratesValues)` yielded by a generic-for
-   *  iterator. Handles `ipairs`/`pairs`/`next(t)` and Luau generalized
-   *  iteration (`for … in t`). `varCount` is how many loop variables were
-   *  written. `iteratesValues` reports the one case where the first variable
-   *  is bound to the value rather than the key, which is what lowering has
-   *  to know to emit the loop; see `TypeAnalysis.iteratesValues`. */
-  iterationTypes(iterNode, iterType, varCount) {
-    if (iterNode?.type === "CallExpression" && iterNode.callee.type === "Identifier" && iterNode.arguments[0]) {
-      const name = iterNode.callee.name;
-      const src = this.expand(this.typeOf.get(iterNode.arguments[0]) ?? unknownType);
-      if (name === "ipairs") return [numberType, this.elementType(src, 0), false];
-      if (name === "pairs" || name === "next") {
+  /** `[step, state, first]` — what a call such as `pairs(t)` answers — as
+   *  the `step` function, or `undefined` for an array that is just an
+   *  array. Three places exactly, the first a function. */
+  iterationTriple(t) {
+    if (t.kind !== "tuple" || t.rest || t.elements.length !== 3) return void 0;
+    const step = this.expand(t.elements[0]);
+    return step.kind === "function" ? step : void 0;
+  }
+  /** What one `for (const item in source)` hands over each time, and how it
+   *  walks the source. `pairs`/`ipairs` are read from the table they are
+   *  given, so a record's keys stay the literals they are. */
+  iterationOf(source, sourceType) {
+    if (source.type === "CallExpression" && source.callee.type === "Identifier" && source.arguments[0]) {
+      const name = source.callee.name;
+      const src = this.expand(this.typeOf.get(source.arguments[0]) ?? unknownType);
+      const iteration = { walks: "iteration", viaIter: false };
+      if (name === "ipairs") return [tuple([numberType, this.elementType(src, 0)]), iteration];
+      if (name === "pairs") {
         if (src.kind === "object") {
-          return [
+          return [tuple([
             src.indexer?.key ?? stringType,
-            src.indexer?.value ?? union([...src.properties.values()].map((p) => p.type)),
-            false
-          ];
+            src.indexer?.value ?? union([...src.properties.values()].map((p) => p.type))
+          ]), iteration];
         }
-        if (src.kind === "array") return [numberType, src.element, false];
+        if (src.kind === "array") return [tuple([numberType, src.element]), iteration];
       }
     }
-    const iterator = this.expand(iterType);
-    if (iterator.kind === "function") {
-      const returns = this.expand(iterator.returns);
-      const parts = returns.kind === "tuple" ? returns.elements.map((m) => this.expand(m)) : [returns];
-      const at = (i) => parts[i] ?? (parts.length === 1 ? parts[0] : unknownType);
-      return [at(0), at(1), false];
-    }
-    const t = this.expand(iterType);
-    if (t.kind === "array") {
-      return varCount >= 2 ? [numberType, t.element, false] : [t.element, unknownType, true];
-    }
+    const handsOut = (t2, viaIter) => {
+      const x = this.expand(t2);
+      if (x.kind === "function") return [withoutNil(this.expand(x.returns)), { walks: "function", viaIter }];
+      const step = this.iterationTriple(x);
+      if (step) return [withoutNil(this.expand(step.returns)), { walks: "iteration", viaIter }];
+      return void 0;
+    };
+    const direct = handsOut(sourceType, false);
+    if (direct) return direct;
+    const values = { walks: "values", viaIter: false };
+    const t = this.expand(sourceType);
+    if (t.kind === "any") return [anyType, values];
+    const iter = t.kind === "object" ? t.properties.get("__iter") : void 0;
+    if (iter) {
+      const made = this.overloadsOf(iter.type)[0]?.returns ?? unknownType;
+      return handsOut(made, true) ?? [unknownType, { walks: "values", viaIter: true }];
+    }
+    if (t.kind === "array") return [t.element, values];
+    if (t.kind === "tuple") return [union([...t.elements, ...t.rest ? [t.rest] : []]), values];
     if (t.kind === "object") {
-      const k = t.indexer?.key ?? stringType;
-      const v = t.indexer?.value ?? union([...t.properties.values()].map((p) => p.type));
-      return varCount >= 2 ? [k, v, false] : [v, unknownType, true];
+      return [t.indexer?.value ?? union([...t.properties.values()].map((p) => p.type)), values];
     }
-    return [unknownType, unknownType, false];
+    if (t.kind !== "never" && this.emitDiagnostics) {
+      this.diagnostics.push({
+        node: source,
+        message: `Cannot loop over '${formatType(sourceType)}': a loop walks an array, a table, an iterator function or an iteration such as 'pairs(t)'`
+      });
+    }
+    return [unknownType, values];
   }
   inferReturnType(body, env) {
     const returns = [];
     const walk = (block) => {
       for (const s of block.statements) {
         if (s.type === "ReturnStatement") {
-          if (s.arguments.length === 0) returns.push(nilType);
-          else if (s.arguments.length === 1) returns.push(this.infer(s.arguments[0], env));
-          else returns.push(tuple(s.arguments.map((a) => this.infer(a, env)), true));
+          returns.push(s.argument ? this.infer(s.argument, env) : nilType);
         } else if (s.type === "IfStatement") {
           for (const c of s.clauses) walk(c.body);
           if (s.alternate) walk(s.alternate);
@@ -8233,8 +8621,9 @@ var TypeAnalyzer = class {
    *  `infer` would have widened it to an array type). */
   fitsAnnotation(init, declared, inferred, env) {
     if (declared.kind === "tuple" && init.type === "ArrayExpression" && !init.elements.some((e) => e.type === "SpreadElement")) {
-      if (init.elements.length !== declared.elements.length) return false;
-      return init.elements.every((el, i) => isAssignable(widen(this.infer(el, env)), declared.elements[i]));
+      const fits = declared.rest ? init.elements.length >= declared.elements.length : init.elements.length === declared.elements.length;
+      if (!fits) return false;
+      return init.elements.every((el, i) => isAssignable(widen(this.infer(el, env)), declared.elements[i] ?? declared.rest));
     }
     if (isAssignable(inferred, declared) || isAssignable(widen(inferred), declared)) return true;
     if (init.type === "TableExpression") return isAssignable(this.inferObject(init, env, true), declared);
@@ -8291,7 +8680,7 @@ var TypeAnalyzer = class {
         target.elements.forEach((el, i) => {
           if (el) this.reassignPattern(el.value, this.withDefault(this.elementType(valueType, i), el.default, env), env);
         });
-        if (target.rest) this.reassignPattern(target.rest, arrayOf(this.elementType(valueType, 0)), env);
+        if (target.rest) this.reassignPattern(target.rest, this.restAfter(valueType, target.elements.length), env);
         return;
       }
     }
@@ -8327,7 +8716,7 @@ var TypeAnalyzer = class {
           if (!el) return;
           this.bindPattern(el.value, this.withDefault(this.elementType(valueType, i), el.default, env), env, mode);
         });
-        if (target.rest) this.bindPattern(target.rest, arrayOf(this.elementType(valueType, 0)), env, mode);
+        if (target.rest) this.bindPattern(target.rest, this.restAfter(valueType, target.elements.length), env, mode);
         return;
       }
     }
@@ -8484,7 +8873,7 @@ var TypeAnalyzer = class {
    *  not one of them is a mistake worth reporting, rather than the nil Lua
    *  would hand back. */
   checkStringMember(node, object, key) {
-    if (!this.emitDiagnostics) return;
+    if (!this.emitDiagnostics || !this.aliasDefs.has("StringMethods")) return;
     const parts = this.stringParts(object);
     if (!parts) return;
     const keys = (key.kind === "union" ? key.types : [key]).map((m) => this.expand(m));
@@ -8496,6 +8885,120 @@ var TypeAnalyzer = class {
       message: names.length === 1 ? `'${names[0]}' does not exist on a string` : `'${briefType(key)}' does not name a member of a string`
     });
   }
+  /** `game.Anything` on a `{ GetService: ... }`, or `a.a` on a number: a
+   *  value whose members are all known, and none of them is this one. Only
+   *  a type that is known through and through is reported — an indexer, an
+   *  `any`, or a part still waiting on a type parameter could each supply
+   *  the name. An empty `{}` is a table still being filled in, so it is left
+   *  alone; an array's and a string's members come from a library, so
+   *  without one they say nothing. A string on its own is `checkStringMember`'s. */
+  checkMissingMember(node, object, name) {
+    if (!this.emitDiagnostics || this.missingMemberReported.has(node)) return;
+    if (!this.memberMissing(object, name)) return;
+    this.missingMemberReported.add(node);
+    this.diagnostics.push({
+      node,
+      message: `Property '${name}' does not exist on type '${briefType(withoutNil(this.expand(object)))}'`
+    });
+  }
+  /** Is `name` certainly not a member of `object`? See `checkMissingMember`. */
+  memberMissing(object, name) {
+    if (this.stringParts(object)) return false;
+    const raw = this.expand(object);
+    const parts = (raw.kind === "union" ? raw.types : [raw]).map((m) => this.deferredAccess(this.expand(m)));
+    let missing = false;
+    for (const part of parts) {
+      switch (part.kind) {
+        case "primitive":
+          if (part.name === "nil") continue;
+          if (part.name === "string" && !this.aliasDefs.has("StringMethods")) return false;
+          if (part.name === "string" && this.builtInMethod(part, name)) continue;
+          break;
+        case "literal":
+        case "templateLiteral":
+          if (part.kind === "templateLiteral" || part.base === "string") {
+            if (!this.aliasDefs.has("StringMethods")) return false;
+          }
+          if (this.builtInMethod(part, name)) continue;
+          break;
+        case "array":
+        case "tuple":
+          if (!this.aliasDefs.has("ArrayMethods")) return false;
+          if (this.builtInMethod(part, name)) continue;
+          break;
+        case "object":
+          if (part.properties.has(name)) continue;
+          if (part.indexer || part.properties.size === 0 && !part.class || this.builtInMethod(part, name)) return false;
+          break;
+        default:
+          return false;
+      }
+      missing = true;
+    }
+    return missing;
+  }
+  /** `t[k]` read with a `k` that cannot be a key of `t`: an `unknown`, a
+   *  type none of `t`'s keys has (a number into a record, a string into an
+   *  array or a class), or a name `t` does not have — which is `t.name`'s
+   *  error. An `any` on either side says nothing, and neither does a type
+   *  parameter still to be decided. A plain `string` into a record is
+   *  allowed: it reads as one of the values or nil, and the nil has to be
+   *  dealt with. An empty `{}` is a table still being filled in, and is
+   *  left alone. Reports, and answers whether it did. */
+  checkIndexKey(node, object, key) {
+    if (!this.emitDiagnostics || this.badIndexReported.has(node)) return false;
+    const index = this.expand(key);
+    if (index.kind === "any" || index.kind === "never" || containsTypeParam(index)) return false;
+    const keys = index.kind === "union" ? index.types.map((k) => this.expand(k)) : [index];
+    const nameOf = (k) => k.kind === "literal" && typeof k.value === "string" ? k.value : void 0;
+    const shown = briefType(withoutNil(this.expand(object)));
+    const names = keys.map(nameOf);
+    const others = keys.filter((_, i) => names[i] === void 0);
+    let message;
+    if (others.length && this.cannotIndex(object, others)) {
+      message = `Type '${briefType(index)}' cannot be used to index type '${shown}'`;
+    } else if (!others.length && names.every((name) => this.memberMissing(object, name))) {
+      message = keys.length === 1 ? `Property '${names[0]}' does not exist on type '${shown}'` : `None of ${briefType(index)} is a property of type '${shown}'`;
+    }
+    if (!message) return false;
+    this.badIndexReported.add(node);
+    this.diagnostics.push({ node, message });
+    return true;
+  }
+  /** Can one of `keys` (string literals aside) not index some part of
+   *  `object`? `false` as soon as a part cannot be judged. */
+  cannotIndex(object, keys) {
+    const raw = this.expand(object);
+    const parts = (raw.kind === "union" ? raw.types : [raw]).map((m) => this.deferredAccess(this.expand(m)));
+    const isNumber = (k) => k.kind === "primitive" && k.name === "number" || k.kind === "literal" && typeof k.value === "number";
+    const isString = (k) => k.kind === "primitive" && k.name === "string" || k.kind === "templateLiteral";
+    let bad = false;
+    for (const part of parts) {
+      switch (part.kind) {
+        case "primitive":
+          if (part.name === "nil") continue;
+          return false;
+        case "array":
+        case "tuple":
+          if (!keys.every(isNumber)) bad = true;
+          continue;
+        case "object": {
+          if (!part.indexer && part.properties.size === 0 && !part.class) return false;
+          const fits = (k) => part.indexer !== void 0 && isAssignable(k, part.indexer.key) || !part.indexer && !part.class && isString(k) || k.kind === "literal" && part.properties.has(String(k.value));
+          if (!keys.every(fits)) bad = true;
+          continue;
+        }
+        default:
+          return false;
+      }
+    }
+    return bad;
+  }
+  /** Indexes already reported: a loop body is visited more than once. */
+  badIndexReported = /* @__PURE__ */ new WeakSet();
+  /** Members already reported as missing: a loop body, or an assignment
+   *  target, is visited more than once. */
+  missingMemberReported = /* @__PURE__ */ new WeakSet();
   /** A `private` member read from outside the class that declared it —
    *  a subclass counts as outside, as in TypeScript. */
   checkPrivateMember(node, object, name) {
@@ -8506,18 +9009,46 @@ var TypeAnalyzer = class {
       if (t.kind !== "object") continue;
       const access = t.properties.get(name)?.private;
       if (!access || this.insideClass(access.owner)) continue;
+      if (access.protected && this.insideSubclassOf(access.owner)) continue;
       this.diagnostics.push({
         node,
-        message: `Property '${name}' is private and only accessible within class '${access.className}'`
+        message: access.protected ? `Property '${name}' is protected and only accessible within class '${access.className}' and the classes extending it` : `Property '${name}' is private and only accessible within class '${access.className}'`
       });
       return;
     }
   }
+  /** `Shape.new` on an abstract class, and `super.area` on an abstract
+   *  method: each reaches something with nothing behind it. */
+  checkAbstractAccess(expr, object) {
+    if (!this.emitDiagnostics) return;
+    const t = this.expand(object);
+    if (t.kind !== "object") return;
+    const name = expr.property.name;
+    const property = t.properties.get(name);
+    if (!property?.abstract) return;
+    if (name === "new" && expr.object.type !== "SuperExpression") {
+      const label = expressionLabel(expr.object) ?? formatType(t);
+      this.diagnostics.push({
+        node: expr,
+        message: `'${label}' is an abstract class: build one of the classes extending it instead`
+      });
+    } else if (expr.object.type === "SuperExpression") {
+      this.diagnostics.push({
+        node: expr.property,
+        message: `'${name}' is abstract in the class this one extends: there is nothing to call`
+      });
+    }
+  }
   /** Is the code being checked written inside `owner`'s body — its own
    *  methods, or a class or function nested in them? */
   insideClass(owner) {
     return this.enclosingClasses.includes(owner);
   }
+  /** Is the code being checked inside a class that extends `owner`? */
+  insideSubclassOf(owner) {
+    const identity = this.classIdentity(owner);
+    return this.enclosingClasses.some((cls) => this.instanceType(cls).class?.ancestors.includes(identity));
+  }
   propertyType(raw, name) {
     const t = this.deferredAccess(this.expand(raw));
     if (t.kind === "object") {
@@ -8572,8 +9103,12 @@ var TypeAnalyzer = class {
       }
       if (containsTypeParam(index)) return this.reduceType({ kind: "indexedAccess", objectType: t, indexType: index });
       if (t.indexer) return t.indexer.value;
+      const anyString = index.kind === "primitive" && index.name === "string" || index.kind === "templateLiteral";
+      if (anyString && !t.class && t.properties.size > 0) {
+        return union([...[...t.properties.values()].map((p) => p.type), nilType]);
+      }
     }
-    return unknownType;
+    return index.kind === "any" ? anyType : unknownType;
   }
   /** What a deferred `T[K]` can be: every property its index could name.
    *  Reading a member of one, or calling it, sees that. */
@@ -8583,10 +9118,21 @@ var TypeAnalyzer = class {
     if (containsTypeParam(index)) return unknownType;
     return this.accessType(t.objectType, index);
   }
+  /** `[a, ...rest]`: what `rest` holds — an array of whatever comes after
+   *  the first `from` places. */
+  restAfter(raw, from) {
+    const t = this.expand(raw);
+    if (t.kind === "tuple") {
+      const left = [...t.elements.slice(from), ...t.rest ? [t.rest] : []];
+      return arrayOf(left.length ? union(left) : neverType);
+    }
+    if (t.kind === "union") return union(t.types.map((m) => this.restAfter(m, from)));
+    return arrayOf(this.elementType(t, from));
+  }
   elementType(raw, index) {
     const t = this.expand(raw);
     if (t.kind === "array") return t.element;
-    if (t.kind === "tuple") return t.elements[index] ?? unknownType;
+    if (t.kind === "tuple") return t.elements[index] ?? t.rest ?? unknownType;
     if (t.kind === "union") return union(t.types.map((m) => this.elementType(m, index)));
     if (t.kind === "difference") return this.elementType(t.base, index);
     if (t.kind === "typeParam" && t.constraint) return this.elementType(t.constraint, index);
@@ -8616,8 +9162,6 @@ var TypeAnalyzer = class {
         return stringType;
       }
       // `...` holds what the function declared it takes.
-      case "VarargExpression":
-        return this.varargs[this.varargs.length - 1] ?? anyType;
       // `f(a, ...rest)` — every value the array holds, one after
       // another. Each of them is an element, so that is what the
       // parameters it fills are checked against.
@@ -8650,10 +9194,8 @@ var TypeAnalyzer = class {
         this.checkParamOrder(expr.func.params, expr);
         this.visitFunctionBody(expr.func, env);
         return this.inferFunctionBody(expr.func, env);
-      case "ParenthesizedExpression": {
-        const inner = this.infer(expr.expression, env);
-        return inner.kind === "tuple" && inner.isPack && producesMultipleValues(expr.expression) ? inner.elements[0] ?? nilType : inner;
-      }
+      case "ParenthesizedExpression":
+        return this.infer(expr.expression, env);
       case "TypeAssertionExpression": {
         this.infer(expr.expression, env);
         return this.resolveType(expr.typeAnnotation);
@@ -8686,7 +9228,7 @@ var TypeAnalyzer = class {
           case "not":
             return booleanType;
           case "-":
-            return this.operatorResult(expr, "-", arg, void 0) ?? numberType;
+            return this.operatorResult(expr, "-", arg, void 0) ?? this.arithmeticOn([arg]);
           case "#":
             return this.operatorResult(expr, "#", arg, void 0) ?? numberType;
         }
@@ -8704,7 +9246,11 @@ var TypeAnalyzer = class {
           const left = this.infer(expr.left, env);
           const { whenFalse } = this.narrowFromCondition(expr.left, env);
           const right = this.infer(expr.right, whenFalse);
-          return union([narrowTruthy(left), right]);
+          const fallback = unwrapParens(expr.right);
+          const empty = fallback.type === "TableExpression" && fallback.fields.length === 0 || fallback.type === "ArrayExpression" && fallback.elements.length === 0;
+          const truthy = narrowTruthy(left);
+          if (empty && truthy.kind !== "never" && truthy.kind !== "any" && isAssignable(right, truthy)) return truthy;
+          return union([truthy, right]);
         }
         const l = this.infer(expr.left, env);
         const r = this.infer(expr.right, env);
@@ -8715,12 +9261,14 @@ var TypeAnalyzer = class {
         switch (op) {
           case "..":
             return this.operatorResult(expr, op, l, r) ?? stringType;
-          case "==":
-          case "~=":
           case "<":
           case ">":
           case "<=":
           case ">=":
+            this.checkComparison(expr, op, l, r);
+            return booleanType;
+          case "==":
+          case "~=":
             return booleanType;
           case "+":
           case "-":
@@ -8729,16 +9277,18 @@ var TypeAnalyzer = class {
           case "//":
           case "%":
           case "^":
-            return this.operatorResult(expr, op, l, r) ?? numberType;
+            return this.operatorResult(expr, op, l, r) ?? this.arithmeticOn([l, r]);
         }
         return union([l, r]);
       }
       case "MemberExpression": {
         const { type: obj, shortCircuits } = this.chainObject(expr, expr.object, env);
         this.checkPrivateMember(expr.property, obj, expr.property.name);
+        this.checkAbstractAccess(expr, obj);
         const key = this.refKeyOf(expr);
         const narrowed = key === void 0 ? void 0 : env.get(key);
         this.checkStringMember(expr, obj, literal(expr.property.name));
+        if (narrowed === void 0) this.checkMissingMember(expr.property, obj, expr.property.name);
         return this.chainResult(expr, narrowed ?? this.propertyType(obj, expr.property.name), shortCircuits);
       }
       case "IndexExpression": {
@@ -8747,6 +9297,7 @@ var TypeAnalyzer = class {
         const key = this.refKeyOf(expr);
         const narrowed = key === void 0 ? void 0 : env.get(key);
         this.checkStringMember(expr, obj, this.expand(idx));
+        if (this.checkIndexKey(expr, obj, idx)) return this.chainResult(expr, anyType, shortCircuits);
         const member = this.stringMember(obj, this.expand(idx));
         if (member) return this.chainResult(expr, member, shortCircuits);
         return this.chainResult(expr, narrowed ?? this.indexedType(obj, idx), shortCircuits);
@@ -8756,8 +9307,6 @@ var TypeAnalyzer = class {
         const { type: callee, shortCircuits } = this.chainObject(expr, expr.callee, env);
         return this.chainResult(expr, this.inferCall(expr, callee, env), shortCircuits);
       }
-      case "NewExpression":
-        return this.inferNew(expr, env);
       case "ClassExpression":
         return this.visitClass(expr, env);
       case "SuperExpression": {
@@ -8794,18 +9343,14 @@ var TypeAnalyzer = class {
   /** `new Name(args)` is `Name.new(args)` — the same function, and the
    *  same check. Saying so here rather than rewriting the tree keeps the
    *  error messages pointing at what was written. */
-  inferNew(expr, env) {
-    const calleeType = this.infer(expr.callee, env);
-    const constructor = this.propertyType(calleeType, "new");
-    if (!this.overloadsOf(constructor).length && calleeType.kind !== "any") {
-      if (this.emitDiagnostics) {
-        const label = expressionLabel(expr.callee) ?? formatType(calleeType);
-        this.diagnostics.push({ node: expr.callee, message: `'${label}' is not a class; 'new' needs one` });
-      }
-      for (const argument of expr.arguments) this.infer(argument, env);
-      return anyType;
-    }
-    return this.inferCall(expr, constructor, env);
+  /** `__call` of a value with one, as what calling the value calls. */
+  callMetamethod(raw) {
+    const t = this.expand(raw);
+    if (t.kind !== "object" || this.overloadsOf(t).length) return void 0;
+    const method = t.properties.get("__call");
+    if (!method) return void 0;
+    const bound = this.overloadsOf(method.type).map((f) => this.takesSelf(f) ? fn(f.params.slice(1), f.returns, f.varargs, f.typeParams) : f);
+    return bound.length ? intersection(bound) : void 0;
   }
   /** `super(...)` — the base constructor, run on the instance being built. */
   inferSuperCall(expr, env) {
@@ -8829,8 +9374,9 @@ var TypeAnalyzer = class {
     this.inferCall(expr, callable, env);
     return nilType;
   }
-  inferCall(expr, callee, env) {
+  inferCall(expr, called, env) {
     this.checkAmbiguousCall(expr);
+    const callee = this.callMetamethod(called) ?? called;
     const united = this.unionSignatures(callee);
     const fns = united ?? this.overloadsOf(callee);
     const explicit = this.explicitTypeArguments(expr, fns);
@@ -8853,8 +9399,31 @@ var TypeAnalyzer = class {
       if (arityFits && !picked) this.reportArguments(expr, expr.arguments, fns, () => argTypes, () => 0);
       return union(fns.map((f) => this.callReturn(f, argTypes, explicit)));
     }
+    this.checkCallable(expr.callee, callee);
     return callee.kind === "any" ? anyType : unknownType;
   }
+  /** `a()` where `a` is `1`: a value whose type is known and has no call
+   *  signature. A union is reported when any member cannot be called, but
+   *  only when every member is decided — `unknown`, `any` and anything still
+   *  generic say too little. */
+  checkCallable(node, callee) {
+    if (!this.emitDiagnostics || this.notCallableReported.has(node)) return;
+    const raw = this.expand(callee);
+    const parts = (raw.kind === "union" ? raw.types : [raw]).map((m) => this.expand(m));
+    const notCallable = (m) => m.kind === "primitive" && m.name !== "nil" || m.kind === "literal" || m.kind === "templateLiteral" || m.kind === "array" || m.kind === "tuple" || m.kind === "object";
+    const callable = (m) => this.overloadsOf(m).length > 0;
+    const concrete = parts.filter((m) => !(m.kind === "primitive" && m.name === "nil"));
+    if (!concrete.some(notCallable) || !concrete.every((m) => notCallable(m) || callable(m))) return;
+    this.notCallableReported.add(node);
+    const label = node.type === "Identifier" ? node.name : expressionLabel(node);
+    this.diagnostics.push({
+      node,
+      message: `This expression is not callable: ${label === void 0 ? "" : `'${label}' `}is of type '${briefType(withoutNil(raw))}'`
+    });
+  }
+  /** Callees already reported as not callable: a loop body is visited more
+   *  than once. */
+  notCallableReported = /* @__PURE__ */ new WeakSet();
   /** A `(` on a line of its own continues the statement above it:
    *
    *      const value = map[key]
@@ -8872,6 +9441,8 @@ var TypeAnalyzer = class {
   }
   inferMethodCall(expr, objType, env) {
     this.checkPrivateMember(expr.method, objType, expr.method.name);
+    this.checkStringMember(expr.method, objType, literal(expr.method.name));
+    this.checkMissingMember(expr.method, objType, expr.method.name);
     const method = this.propertyType(objType, expr.method.name);
     const united = this.unionSignatures(method);
     const fns = united ?? this.overloadsOf(method);
@@ -8905,6 +9476,7 @@ var TypeAnalyzer = class {
       if (arityFits && !picked) this.reportArguments(expr, expr.arguments, fns, withSelf, selfOf);
       return union(fns.map((f) => this.callReturn(f, withSelf(f), explicit)));
     }
+    this.checkCallable(expr.method, method);
     return objType.kind === "any" ? anyType : unknownType;
   }
   // --------------------------------------------------------
@@ -8965,6 +9537,8 @@ var TypeAnalyzer = class {
       if (id !== void 0 && this.scopes.bindings.get(id)?.declaredBy === "namespace") return;
     }
     if (!this.isReadonlyProperty(this.expand(this.infer(object, env)), name)) return;
+    const constructing = this.constructing;
+    if (constructing && object.type === "Identifier" && object.name === "this" && constructing.members.some((m) => m.type === "ClassField" && !m.isStatic && m.isReadonly && m.name.name === name)) return;
     this.diagnostics.push({
       node: target,
       message: `Cannot assign to '${name}' because it is a read-only property`
@@ -9024,6 +9598,8 @@ var TypeAnalyzer = class {
   inferArray(expr, env, asConst) {
     const contextual = this.contextualArrays.get(expr);
     if (contextual && !asConst) return contextual;
+    const wantedTuple = this.tupleArrays.get(expr);
+    if (wantedTuple && !asConst) return this.inferTupleLiteral(expr, env, wantedTuple);
     const elems = [];
     let hadSpread = false;
     for (const el of expr.elements) {
@@ -9043,6 +9619,28 @@ var TypeAnalyzer = class {
       return asConst || !element || element.type === "SpreadElement" ? t : this.widenUnlessAsked(t, element);
     })) : unknownType);
   }
+  /** `[a, b, ...more]` where a tuple is wanted: the places it names are the
+   *  tuple's, and what comes after them — more elements, or a spread — is
+   *  its rest. */
+  inferTupleLiteral(expr, env, wanted) {
+    const fixed = [];
+    const tail = [];
+    let spread = false;
+    expr.elements.forEach((element, i) => {
+      if (element.type === "SpreadElement") {
+        spread = true;
+        const held = this.expand(this.infer(element.argument, env));
+        if (held.kind === "array") tail.push(held.element);
+        else if (held.kind === "tuple") tail.push(...tupleMembers(held));
+        else tail.push(unknownType);
+        return;
+      }
+      const t = this.widenUnlessAsked(this.infer(element, env), element);
+      if (!spread && i < wanted.elements.length) fixed.push(t);
+      else tail.push(t);
+    });
+    return tuple(fixed, tail.length ? union(tail) : void 0);
+  }
   /** A literal written inside a fresh table or array widens — `{ n = 1 }` is
    *  `{ n: number }` — unless the surroundings said a literal belongs there.
    *  `request({ Method: "GET" })` keeps `"GET"` when `Method` is a union of
@@ -9128,7 +9726,7 @@ var TypeAnalyzer = class {
       case "tuple": {
         const tupleContext = ctx && this.membersOf(ctx).find((m) => m.kind === "tuple");
         if (tupleContext?.kind === "tuple") {
-          return tuple(value.elements.map((e, i) => this.keepContextualLiterals(e, tupleContext.elements[i])), value.isPack);
+          return tuple(value.elements.map((e, i) => this.keepContextualLiterals(e, tupleContext.elements[i])), value.rest);
         }
         const arrayContext = ctx && this.membersOf(ctx).find((m) => m.kind === "array");
         const element = arrayContext?.kind === "array" ? arrayContext.element : void 0;
@@ -9385,7 +9983,8 @@ var TypeAnalyzer = class {
     for (const f of candidates) {
       if (!f.predicate) continue;
       const arg = args[f.predicate.param];
-      if (!arg || this.refKeyOf(arg) === void 0) continue;
+      const onCondition = f.predicate.asserts && !f.predicate.type;
+      if (!arg || this.refKeyOf(arg) === void 0 && !onCondition) continue;
       if (f.typeParams?.length && f.predicate.type) {
         const subst = this.inferTypeArgs(f, argTypes);
         return {
@@ -9406,6 +10005,10 @@ var TypeAnalyzer = class {
     const found = this.predicateCallTarget(call, env);
     if (!found || !found.predicate.asserts) return;
     const filter = found.predicate.type;
+    if (this.refKeyOf(found.arg) === void 0) {
+      if (!filter) this.applyNarrowing(found.arg, env, env, forkEnv(env));
+      return;
+    }
     this.narrowRef(found.arg, env, env, forkEnv(env), (cur) => filter ? { yes: narrowTo(cur, filter), no: narrowExclude(cur, filter) } : { yes: narrowTruthy(cur), no: narrowFalsy(cur) });
   }
   // --------------------------------------------------------
@@ -9430,6 +10033,10 @@ var TypeAnalyzer = class {
         if (base === void 0) return void 0;
         if (expr.index.type === "StringLiteral") return `${base}.${expr.index.value}`;
         if (expr.index.type === "NumberLiteral") return `${base}#${expr.index.value}`;
+        if (expr.index.type === "Identifier") {
+          const id = this.bindingIdOf(expr.index);
+          return id === void 0 ? void 0 : `${base}[${bindKey(id)}]`;
+        }
         return void 0;
       }
       default:
@@ -9525,26 +10132,45 @@ var TypeAnalyzer = class {
    *  that copied it no longer holds that value: forget the alias. */
   unalias(key) {
     for (const k of [...this.refAliases.keys()]) {
-      if (k !== key && !k.startsWith(`${key}.`) && !k.startsWith(`${key}#`)) continue;
+      if (k !== key && !isBelow(k, key) && !k.includes(`[${key}]`)) continue;
       for (const other of this.refAliases.get(k) ?? []) this.refAliases.get(other)?.delete(k);
       this.refAliases.delete(k);
     }
   }
-  /** Drop every narrowing recorded for a path strictly under `key`. */
+  /** Drop every narrowing recorded for a path strictly under `key` — and,
+   *  when `key` is a whole variable, for every `t[key]` indexed by it: that
+   *  now names a different slot. */
   invalidateBelow(env, key) {
+    const asIndex = `[${key}]`;
     for (const k of [...env.keys()]) {
-      if (k.startsWith(`${key}.`) || k.startsWith(`${key}#`)) env.delete(k);
+      if (isBelow(k, key) || k.includes(asIndex)) env.delete(k);
     }
   }
   /** An assignment through a reference invalidates it and everything under
    *  it, then records the assigned type. */
   assignToRef(expr, value, env) {
+    this.invalidateSiblings(expr, env);
     const key = this.refKeyOf(expr);
     if (key === void 0) return;
     this.invalidateBelow(env, key);
     this.unalias(key);
     env.set(key, value);
   }
+  /** A write to one slot of a table can be a write to a slot narrowed under
+   *  another name: `t.x = nil` is `t[k] = nil` when `k` is `"x"`. So a
+   *  write by name forgets what is known through variable keys, and a write
+   *  through any computed key forgets everything known about the table's
+   *  slots. */
+  invalidateSiblings(expr, env) {
+    const inner = expr.type === "ParenthesizedExpression" ? expr.expression : expr;
+    if (inner.type !== "MemberExpression" && inner.type !== "IndexExpression") return;
+    const parent = this.refKeyOf(inner.object);
+    if (parent === void 0) return;
+    const computed = inner.type === "IndexExpression" && inner.index.type !== "StringLiteral" && inner.index.type !== "NumberLiteral";
+    for (const k of [...env.keys()]) {
+      if (computed ? isBelow(k, parent) : k.startsWith(`${parent}[`)) env.delete(k);
+    }
+  }
   // --------------------------------------------------------
   // Small helpers
   // --------------------------------------------------------
@@ -9559,6 +10185,35 @@ var TypeAnalyzer = class {
       this.selfType = saved;
     }
   }
+  /** Arithmetic no declared metamethod answers: a number — unless an
+   *  operand is `any`, which may be a value with metamethods of its own.
+   *  `(a.Position - b.Position).Magnitude` on an `a` nothing typed is a
+   *  `Vector3` as far as anyone knows, not a number with no `Magnitude`. */
+  arithmeticOn(operands) {
+    return operands.some((t) => this.expand(t).kind === "any") ? anyType : numberType;
+  }
+  /** `a < b` between class instances: Luau asks `__lt` (`__le` for `<=`),
+   *  with the operands swapped for `>` and `>=`, and an instance without
+   *  one cannot be compared at all. */
+  checkComparison(node, op, l, r) {
+    if (!this.emitDiagnostics) return;
+    const left = this.expand(l);
+    const right = this.expand(r);
+    const instance = (t) => t.kind === "object" && t.class !== void 0;
+    if (!instance(left) && !instance(right)) return;
+    const name = op === "<" || op === ">" ? "__lt" : "__le";
+    const operands = op === ">" || op === ">=" ? [right, left] : [left, right];
+    for (const receiver of operands) {
+      const method = receiver.kind === "object" ? receiver.properties.get(name) : void 0;
+      if (!method) continue;
+      if (this.pickOverload(this.overloadsOf(method.type), operands)) return;
+      break;
+    }
+    this.diagnostics.push({
+      node,
+      message: `Operator '${op}' cannot be applied to types '${formatType(l)}' and '${formatType(r)}'`
+    });
+  }
   /** What an operator on a value with metamethods gives: `a + b` calls
    *  `__add` on `a`, or failing that on `b` with the operands swapped — the
    *  order Luau tries them in. That is how `Vector3 + Vector3`, `CFrame *
@@ -9883,7 +10538,7 @@ function briefType(t) {
 }
 
 // src/project/host.ts
-import { readFileSync, statSync } from "fs";
+import { readdirSync, readFileSync, statSync } from "fs";
 var nodeHost = {
   readFile(path) {
     try {
@@ -9891,6 +10546,13 @@ var nodeHost = {
     } catch {
       return void 0;
     }
+  },
+  readDirectory(path) {
+    try {
+      return readdirSync(path, { withFileTypes: true }).filter((entry) => entry.isDirectory() || entry.isSymbolicLink()).map((entry) => entry.name);
+    } catch {
+      return void 0;
+    }
   }
 };
 
@@ -10082,13 +10744,31 @@ function resolveTypeLibraries(config, host = nodeHost) {
       else problems.push({ file: config.path, message: `'${entry}' has no ${ENTRY_FILE} (or 'tilua.types' in its package.json)`, ...entryPosition(config, entry) });
       continue;
     }
-    const name = entry.startsWith("@tilua-types/") ? entry : `@tilua-types/${entry}`;
-    const found = findPackage(name, config.directory, host);
+    if (entry.includes("*")) {
+      const matched = matchPackages(entry, config.directory, host);
+      if (matched === void 0) {
+        problems.push({
+          file: config.path,
+          message: `'${entry}' needs the folders listed, and this tool cannot list them; name the libraries one by one`,
+          ...entryPosition(config, entry)
+        });
+      } else if (!matched.length) {
+        problems.push({
+          file: config.path,
+          message: `No installed type library matches '${entry}'`,
+          ...entryPosition(config, entry)
+        });
+      }
+      for (const found2 of matched ?? []) addPackage(found2.directory, found2.file, /* @__PURE__ */ new Set());
+      continue;
+    }
+    const names = entry.startsWith("@") ? [entry] : [`@tilua-types/${entry}`, entry];
+    const found = names.map((name) => findPackage(name, config.directory, host)).find(Boolean);
     if (found) addPackage(found.directory, found.file, /* @__PURE__ */ new Set());
     else {
       problems.push({
         file: config.path,
-        message: `Cannot find type library '${name}'. Install it with: npm i -D ${name}`,
+        message: names.length === 1 ? `Cannot find type library '${entry}'. Install it with: npm i -D ${entry}` : `Cannot find type library '${names[0]}' or '${entry}'. Install it with: npm i -D ${names[0]}`,
         ...entryPosition(config, entry)
       });
     }
@@ -10125,6 +10805,32 @@ function findPackage(name, from, host) {
     directory = parent;
   }
 }
+function matchPackages(pattern, from, host) {
+  if (!host.readDirectory) return void 0;
+  const slash = pattern.lastIndexOf("/");
+  const scope = slash < 0 ? "" : pattern.slice(0, slash);
+  const last = pattern.slice(slash + 1);
+  const matches = new RegExp(`^${last.split("*").map(escapeRegExp2).join(".*")}$`);
+  const found = /* @__PURE__ */ new Map();
+  let directory = resolve2(from);
+  for (; ; ) {
+    const folder = join2(directory, "node_modules", ...scope ? scope.split("/") : []);
+    for (const name of host.readDirectory(folder) ?? []) {
+      const full = scope ? `${scope}/${name}` : name;
+      if (!matches.test(name) || found.has(full)) continue;
+      const candidate = join2(folder, name);
+      const file = packageEntry(candidate, host);
+      if (file) found.set(full, { directory: candidate, file });
+    }
+    const parent = dirname2(directory);
+    if (parent === directory) break;
+    directory = parent;
+  }
+  return [...found.keys()].sort().map((name) => found.get(name));
+}
+function escapeRegExp2(text) {
+  return text.replace(/[.+?^${}()|[\]\\]/g, "\\$&");
+}
 function dependencyNames(directory, host) {
   const manifest = readJson(join2(directory, "package.json"), host);
   const names = /* @__PURE__ */ new Set();
@@ -10223,7 +10929,8 @@ function sourceMapTypes(text, path, options) {
     for (const child of node.children ?? []) {
       if (!isNode(child)) continue;
       const childAlias = visit(child, [...segments, child.name], alias);
-      if (!IDENTIFIER.test(child.name) || taken.has(child.name) || named.has(child.name)) continue;
+      const service = child.name === child.className && options.classes.has(child.className);
+      if (!IDENTIFIER.test(child.name) || taken.has(child.name) && !service || named.has(child.name)) continue;
       named.add(child.name);
       members.push(`${child.name}: ${childAlias}`);
     }
@@ -10283,6 +10990,7 @@ export {
   BinaryOperators,
   CONFIG_FILE_NAMES,
   Keywords,
+  LANGUAGE_GLOBALS,
   LexError,
   Operators,
   PRELUDE_SOURCE,
@@ -10351,6 +11059,7 @@ export {
   tilua,
   tokenize,
   tuple,
+  tupleMembers,
   typeParam,
   unify,
   union,