@tilua/parser 2.3.0 → 2.4.0

package/dist/index.cjs

@@ -2112,7 +2112,7 @@ var Parser = class {
   parseExpressionStatement() {
     const start = this.current();
     if (this.checkPunctuator("{") || this.checkPunctuator("[")) {
-      const target = this.checkPunctuator("{") ? this.parseObjectPattern() : this.parseArrayPattern();
+      const target = this.checkPunctuator("{") ? this.parseObjectPattern(true) : this.parseArrayPattern(true);
       return this.parseAssignmentRest(start, target);
     }
     const statementStart = this.cursor;
@@ -2667,8 +2667,8 @@ var Parser = class {
   /** An assignment target after the first — Luau's `a, b = ...`, read only
    *  to be reported: a prefix expression or a destructuring pattern. */
   parseAssignTarget() {
-    if (this.checkPunctuator("{")) return this.parseObjectPattern();
-    if (this.checkPunctuator("[")) return this.parseArrayPattern();
+    if (this.checkPunctuator("{")) return this.parseObjectPattern(true);
+    if (this.checkPunctuator("[")) return this.parseArrayPattern(true);
     return this.parsePrefixExpression();
   }
   /** Does a call's argument list start here? Lua's three forms: `(`, a
@@ -2847,13 +2847,17 @@ var Parser = class {
   /** Parses a binding target. When `topLevel`, also consumes a trailing
    *  `<attr>` list (identifier only) and a `: Type` annotation — these are
    *  only valid at the outermost level of a `local` / parameter binding,
-   *  never nested inside another pattern. */
-  parseBindingTarget(topLevel) {
+   *  never nested inside another pattern. When `assign`, the pattern is a
+   *  destructuring assignment's (`[t[i], t[j]] = ...`), and a leaf is any
+   *  place a value can be assigned to: a name, a member or an index. */
+  parseBindingTarget(topLevel, assign = false) {
     let target;
     if (this.checkPunctuator("{")) {
-      target = this.parseObjectPattern();
+      target = this.parseObjectPattern(assign);
     } else if (this.checkPunctuator("[")) {
-      target = this.parseArrayPattern();
+      target = this.parseArrayPattern(assign);
+    } else if (assign) {
+      return this.parseAssignPatternLeaf();
     } else {
       const nameTok = this.expectIdentifier();
       let attributes;
@@ -2875,10 +2879,25 @@ var Parser = class {
     }
     return target;
   }
-  parseObjectPattern() {
-    return this.inBrackets(() => this.parseObjectPatternInner());
+  /** A leaf of a destructuring assignment: `a`, `a.b` or `a[i]`. */
+  parseAssignPatternLeaf() {
+    const expression = this.parsePrefixExpression();
+    if (expression.type === "Identifier") {
+      return { type: "IdentifierPattern", name: expression.name, line: expression.line, column: expression.column };
+    }
+    if (expression.type === "MemberExpression" || expression.type === "IndexExpression") {
+      this.rejectOptionalTarget(expression);
+      return expression;
+    }
+    const err = new ParseError("Only a name, a member or an index can be assigned to", expression.line.start, expression.column.start);
+    if (!this.recover) throw err;
+    this.record(err);
+    return { type: "IdentifierPattern", name: "", line: expression.line, column: expression.column };
   }
-  parseObjectPatternInner() {
+  parseObjectPattern(assign = false) {
+    return this.inBrackets(() => this.parseObjectPatternInner(assign));
+  }
+  parseObjectPatternInner(assign) {
     const start = this.current();
     this.expectPunctuator("{");
     const properties = [];
@@ -2886,7 +2905,7 @@ var Parser = class {
     while (!this.checkPunctuator("}")) {
       if (this.checkOperator("...")) {
         this.advance();
-        rest = this.parseBindingTarget(false);
+        rest = this.parseBindingTarget(false, assign);
         break;
       }
       const propStart = this.current();
@@ -2899,17 +2918,17 @@ var Parser = class {
         key = this.parseExpression();
         this.expectPunctuator("]");
         this.expectPunctuator(":");
-        value = this.parseBindingTarget(false);
+        value = this.parseBindingTarget(false, assign);
       } else if (this.checkType("Literal") && this.current().kind === "string") {
         const t = this.advance();
         key = { type: "StringLiteral", value: t.value, raw: t.raw, ...spanFrom(t, t) };
         this.expectPunctuator(":");
-        value = this.parseBindingTarget(false);
+        value = this.parseBindingTarget(false, assign);
       } else {
         const nameTok = this.expectIdentifier();
         key = { type: "Identifier", name: nameTok.value, ...spanFrom(nameTok, nameTok) };
         if (this.matchPunctuator(":")) {
-          value = this.parseBindingTarget(false);
+          value = this.parseBindingTarget(false, assign);
         } else {
           shorthand = true;
           value = { type: "IdentifierPattern", name: nameTok.value, ...spanFrom(nameTok, nameTok) };
@@ -2932,10 +2951,10 @@ var Parser = class {
     this.expectPunctuator("}");
     return { type: "ObjectPattern", properties, rest, ...spanFrom(start, this.previous()) };
   }
-  parseArrayPattern() {
-    return this.inBrackets(() => this.parseArrayPatternInner());
+  parseArrayPattern(assign = false) {
+    return this.inBrackets(() => this.parseArrayPatternInner(assign));
   }
-  parseArrayPatternInner() {
+  parseArrayPatternInner(assign) {
     const start = this.current();
     this.expectPunctuator("[");
     const elements = [];
@@ -2943,7 +2962,7 @@ var Parser = class {
     while (!this.checkPunctuator("]")) {
       if (this.checkOperator("...")) {
         this.advance();
-        rest = this.parseBindingTarget(false);
+        rest = this.parseBindingTarget(false, assign);
         break;
       }
       if (this.checkPunctuator(",")) {
@@ -2952,7 +2971,7 @@ var Parser = class {
         continue;
       }
       const elStart = this.current();
-      const value = this.parseBindingTarget(false);
+      const value = this.parseBindingTarget(false, assign);
       let def;
       if (this.matchOperator("=")) def = this.parseExpression();
       elements.push({ type: "ArrayPatternElement", value, default: def, ...spanFrom(elStart, this.previous()) });
@@ -4089,6 +4108,10 @@ var Analyzer = class {
           this.checkConstAssign(id, t);
           return;
         }
+        case "MemberExpression":
+        case "IndexExpression":
+          this.visitExpression(t, scope);
+          return;
         case "ObjectPattern":
           for (const p of t.properties) {
             if (p.computed) this.visitExpression(p.key, scope);
@@ -4124,7 +4147,9 @@ var Analyzer = class {
     switch (stmt.type) {
       case "VariableDeclaration": {
         if (stmt.init) this.visitExpression(stmt.init, scope);
-        this.visitType(stmt.name.typeAnnotation, scope);
+        if (stmt.name.type !== "MemberExpression" && stmt.name.type !== "IndexExpression") {
+          this.visitType(stmt.name.typeAnnotation, scope);
+        }
         this.declarePattern(scope, stmt.name, "local", scope, stmt.kind === "const");
         return;
       }
@@ -6541,6 +6566,14 @@ var TypeAnalyzer = class {
         report(stmt.superclass, known ? `'${stmt.superclass.name}' is not a class; a class can only extend another class` : `Cannot find class '${stmt.superclass.name}'`);
       }
     }
+    this.withClass(stmt, () => this.withTypeParams(this.classTypeParams(stmt), () => {
+      this.withSelfType(this.selfTypeOf(stmt), () => {
+        for (const member of stmt.members) {
+          if (member.type !== "ClassMethod" || !member.signatures) continue;
+          for (const signature of member.signatures) this.checkOverload(member.func, signature);
+        }
+      });
+    }));
     for (const member of stmt.members) {
       if (member.type === "ClassConstructor") continue;
       if (CLASS_RESERVED.has(member.name.name)) {
@@ -8047,7 +8080,7 @@ var TypeAnalyzer = class {
   /** Synthesize a type from a destructuring pattern used without an
    *  annotation (`function f({ a, b = 1 })`). */
   patternToType(target, env) {
-    const leaf = (v, def) => v.type !== "IdentifierPattern" ? this.patternToType(v, env) : v.typeAnnotation ? this.resolveType(v.typeAnnotation) : def ? widen(this.infer(def, env)) : anyType;
+    const leaf = (v, def) => v.type === "ObjectPattern" || v.type === "ArrayPattern" ? this.patternToType(v, env) : v.type !== "IdentifierPattern" ? anyType : v.typeAnnotation ? this.resolveType(v.typeAnnotation) : def ? widen(this.infer(def, env)) : anyType;
     if (target.type === "ObjectPattern") {
       const entries = [];
       for (const p of target.properties) {
@@ -8453,6 +8486,7 @@ var TypeAnalyzer = class {
    *  can actually be. An annotation, a pattern or a default still wins. */
   paramsFromSignatures(func, signatures) {
     if (!signatures?.length) return;
+    for (const signature of signatures) this.checkOverload(func, signature);
     const resolved = signatures.map((sig) => this.signatureToFnType(sig));
     func.params.forEach((param, i) => {
       if (param.typeAnnotation || param.pattern || param.default) return;
@@ -8466,6 +8500,64 @@ var TypeAnalyzer = class {
       if (candidates.length) this.contextualParams.set(param, union(candidates));
     });
   }
+  /** The implementation is what runs for every signature of an overload
+   *  set, so each signature must be one it can serve: no parameter it does
+   *  not have, no fewer arguments than it requires, no argument type it does
+   *  not accept, and a return it can give. Stricter than TypeScript, which
+   *  lets a signature name parameters the implementation never reads. */
+  checkOverload(func, signature) {
+    if (!this.emitDiagnostics) return;
+    const node = signature;
+    const report = (message) => {
+      this.diagnostics.push({ node, message });
+    };
+    const own = (params) => params.filter((p, i) => !p.rest && !(i === 0 && !p.typeAnnotation && (p.name === "self" || p.name === "this")));
+    const implementation = own(func.params);
+    const offered = own(signature.params);
+    const implementationRest = func.params.some((p) => p.rest);
+    const signatureRest = signature.params.some((p) => p.rest);
+    const label = (p) => p.pattern ? "a destructured parameter" : `'${p.name}'`;
+    if (!implementationRest) {
+      const extra = offered[implementation.length];
+      if (extra) {
+        report(`This overload takes parameter ${label(extra)}, which the implementation does not have: it takes ${implementation.length} parameter${implementation.length === 1 ? "" : "s"}`);
+        return;
+      }
+      if (signatureRest) {
+        report("This overload takes a rest parameter, which the implementation does not have");
+        return;
+      }
+    }
+    if (!signatureRest) {
+      let required = 0;
+      implementation.forEach((p, i) => {
+        if (!p.optional && p.default === void 0) required = i + 1;
+      });
+      if (offered.length < required) {
+        report(`The implementation requires ${required} argument${required === 1 ? "" : "s"}, and this overload passes at most ${offered.length}`);
+        return;
+      }
+    }
+    if (signature.generics.length || func.generics.length) return;
+    for (let i = 0; i < offered.length && i < implementation.length; i++) {
+      const target = implementation[i];
+      if (!target.typeAnnotation && target.default === void 0) continue;
+      let accepted = this.paramType(target, /* @__PURE__ */ new Map());
+      if (target.default !== void 0) accepted = optional(accepted);
+      const given = this.paramType(offered[i], /* @__PURE__ */ new Map());
+      if (!isAssignable(given, accepted)) {
+        report(`Parameter ${label(offered[i])} of this overload is '${briefType(given)}', which the implementation's '${briefType(accepted)}' does not accept`);
+        return;
+      }
+    }
+    if (signature.returnType && func.returnType) {
+      const promised = this.resolveType(signature.returnType);
+      const returned = this.resolveType(func.returnType);
+      if (!isAssignable(promised, returned) && !isAssignable(returned, promised)) {
+        report(`This overload returns '${briefType(promised)}', which the implementation's '${briefType(returned)}' cannot be`);
+      }
+    }
+  }
   signatureToFnType(sig) {
     const names = sig.generics.map((g) => g.name);
     const record = (type) => {
@@ -8890,6 +8982,12 @@ var TypeAnalyzer = class {
         }
         return;
       }
+      case "MemberExpression":
+      case "IndexExpression":
+        this.infer(target, env);
+        this.checkReadonlyAssign(target, env);
+        this.assignToRef(target, widen(valueType), env);
+        return;
       case "ObjectPattern": {
         for (const p of target.properties) {
           const key = !p.computed && p.key.type === "Identifier" ? p.key.name : !p.computed && p.key.type === "StringLiteral" ? p.key.value : void 0;

package/dist/index.d.cts

@@ -254,7 +254,9 @@ interface VariableDeclaration extends BaseNode {
     /** Absent only on `let x`. */
     init?: Expression;
 }
-type BindingTarget = IdentifierPattern | ObjectPattern | ArrayPattern;
+/** A member or an index (`t.a`, `t[i]`) is a leaf only in a destructuring
+ *  assignment (`[t[i], t[j]] = [t[j], t[i]]`): a declaration binds names. */
+type BindingTarget = IdentifierPattern | ObjectPattern | ArrayPattern | MemberExpression | IndexExpression;
 interface IdentifierPattern extends BaseNode {
     type: "IdentifierPattern";
     name: string;

package/dist/index.d.ts

@@ -254,7 +254,9 @@ interface VariableDeclaration extends BaseNode {
     /** Absent only on `let x`. */
     init?: Expression;
 }
-type BindingTarget = IdentifierPattern | ObjectPattern | ArrayPattern;
+/** A member or an index (`t.a`, `t[i]`) is a leaf only in a destructuring
+ *  assignment (`[t[i], t[j]] = [t[j], t[i]]`): a declaration binds names. */
+type BindingTarget = IdentifierPattern | ObjectPattern | ArrayPattern | MemberExpression | IndexExpression;
 interface IdentifierPattern extends BaseNode {
     type: "IdentifierPattern";
     name: string;

package/dist/index.js

@@ -2007,7 +2007,7 @@ var Parser = class {
   parseExpressionStatement() {
     const start = this.current();
     if (this.checkPunctuator("{") || this.checkPunctuator("[")) {
-      const target = this.checkPunctuator("{") ? this.parseObjectPattern() : this.parseArrayPattern();
+      const target = this.checkPunctuator("{") ? this.parseObjectPattern(true) : this.parseArrayPattern(true);
       return this.parseAssignmentRest(start, target);
     }
     const statementStart = this.cursor;
@@ -2562,8 +2562,8 @@ var Parser = class {
   /** An assignment target after the first — Luau's `a, b = ...`, read only
    *  to be reported: a prefix expression or a destructuring pattern. */
   parseAssignTarget() {
-    if (this.checkPunctuator("{")) return this.parseObjectPattern();
-    if (this.checkPunctuator("[")) return this.parseArrayPattern();
+    if (this.checkPunctuator("{")) return this.parseObjectPattern(true);
+    if (this.checkPunctuator("[")) return this.parseArrayPattern(true);
     return this.parsePrefixExpression();
   }
   /** Does a call's argument list start here? Lua's three forms: `(`, a
@@ -2742,13 +2742,17 @@ var Parser = class {
   /** Parses a binding target. When `topLevel`, also consumes a trailing
    *  `<attr>` list (identifier only) and a `: Type` annotation — these are
    *  only valid at the outermost level of a `local` / parameter binding,
-   *  never nested inside another pattern. */
-  parseBindingTarget(topLevel) {
+   *  never nested inside another pattern. When `assign`, the pattern is a
+   *  destructuring assignment's (`[t[i], t[j]] = ...`), and a leaf is any
+   *  place a value can be assigned to: a name, a member or an index. */
+  parseBindingTarget(topLevel, assign = false) {
     let target;
     if (this.checkPunctuator("{")) {
-      target = this.parseObjectPattern();
+      target = this.parseObjectPattern(assign);
     } else if (this.checkPunctuator("[")) {
-      target = this.parseArrayPattern();
+      target = this.parseArrayPattern(assign);
+    } else if (assign) {
+      return this.parseAssignPatternLeaf();
     } else {
       const nameTok = this.expectIdentifier();
       let attributes;
@@ -2770,10 +2774,25 @@ var Parser = class {
     }
     return target;
   }
-  parseObjectPattern() {
-    return this.inBrackets(() => this.parseObjectPatternInner());
+  /** A leaf of a destructuring assignment: `a`, `a.b` or `a[i]`. */
+  parseAssignPatternLeaf() {
+    const expression = this.parsePrefixExpression();
+    if (expression.type === "Identifier") {
+      return { type: "IdentifierPattern", name: expression.name, line: expression.line, column: expression.column };
+    }
+    if (expression.type === "MemberExpression" || expression.type === "IndexExpression") {
+      this.rejectOptionalTarget(expression);
+      return expression;
+    }
+    const err = new ParseError("Only a name, a member or an index can be assigned to", expression.line.start, expression.column.start);
+    if (!this.recover) throw err;
+    this.record(err);
+    return { type: "IdentifierPattern", name: "", line: expression.line, column: expression.column };
   }
-  parseObjectPatternInner() {
+  parseObjectPattern(assign = false) {
+    return this.inBrackets(() => this.parseObjectPatternInner(assign));
+  }
+  parseObjectPatternInner(assign) {
     const start = this.current();
     this.expectPunctuator("{");
     const properties = [];
@@ -2781,7 +2800,7 @@ var Parser = class {
     while (!this.checkPunctuator("}")) {
       if (this.checkOperator("...")) {
         this.advance();
-        rest = this.parseBindingTarget(false);
+        rest = this.parseBindingTarget(false, assign);
         break;
       }
       const propStart = this.current();
@@ -2794,17 +2813,17 @@ var Parser = class {
         key = this.parseExpression();
         this.expectPunctuator("]");
         this.expectPunctuator(":");
-        value = this.parseBindingTarget(false);
+        value = this.parseBindingTarget(false, assign);
       } else if (this.checkType("Literal") && this.current().kind === "string") {
         const t = this.advance();
         key = { type: "StringLiteral", value: t.value, raw: t.raw, ...spanFrom(t, t) };
         this.expectPunctuator(":");
-        value = this.parseBindingTarget(false);
+        value = this.parseBindingTarget(false, assign);
       } else {
         const nameTok = this.expectIdentifier();
         key = { type: "Identifier", name: nameTok.value, ...spanFrom(nameTok, nameTok) };
         if (this.matchPunctuator(":")) {
-          value = this.parseBindingTarget(false);
+          value = this.parseBindingTarget(false, assign);
         } else {
           shorthand = true;
           value = { type: "IdentifierPattern", name: nameTok.value, ...spanFrom(nameTok, nameTok) };
@@ -2827,10 +2846,10 @@ var Parser = class {
     this.expectPunctuator("}");
     return { type: "ObjectPattern", properties, rest, ...spanFrom(start, this.previous()) };
   }
-  parseArrayPattern() {
-    return this.inBrackets(() => this.parseArrayPatternInner());
+  parseArrayPattern(assign = false) {
+    return this.inBrackets(() => this.parseArrayPatternInner(assign));
   }
-  parseArrayPatternInner() {
+  parseArrayPatternInner(assign) {
     const start = this.current();
     this.expectPunctuator("[");
     const elements = [];
@@ -2838,7 +2857,7 @@ var Parser = class {
     while (!this.checkPunctuator("]")) {
       if (this.checkOperator("...")) {
         this.advance();
-        rest = this.parseBindingTarget(false);
+        rest = this.parseBindingTarget(false, assign);
         break;
       }
       if (this.checkPunctuator(",")) {
@@ -2847,7 +2866,7 @@ var Parser = class {
         continue;
       }
       const elStart = this.current();
-      const value = this.parseBindingTarget(false);
+      const value = this.parseBindingTarget(false, assign);
       let def;
       if (this.matchOperator("=")) def = this.parseExpression();
       elements.push({ type: "ArrayPatternElement", value, default: def, ...spanFrom(elStart, this.previous()) });
@@ -3984,6 +4003,10 @@ var Analyzer = class {
           this.checkConstAssign(id, t);
           return;
         }
+        case "MemberExpression":
+        case "IndexExpression":
+          this.visitExpression(t, scope);
+          return;
         case "ObjectPattern":
           for (const p of t.properties) {
             if (p.computed) this.visitExpression(p.key, scope);
@@ -4019,7 +4042,9 @@ var Analyzer = class {
     switch (stmt.type) {
       case "VariableDeclaration": {
         if (stmt.init) this.visitExpression(stmt.init, scope);
-        this.visitType(stmt.name.typeAnnotation, scope);
+        if (stmt.name.type !== "MemberExpression" && stmt.name.type !== "IndexExpression") {
+          this.visitType(stmt.name.typeAnnotation, scope);
+        }
         this.declarePattern(scope, stmt.name, "local", scope, stmt.kind === "const");
         return;
       }
@@ -6436,6 +6461,14 @@ var TypeAnalyzer = class {
         report(stmt.superclass, known ? `'${stmt.superclass.name}' is not a class; a class can only extend another class` : `Cannot find class '${stmt.superclass.name}'`);
       }
     }
+    this.withClass(stmt, () => this.withTypeParams(this.classTypeParams(stmt), () => {
+      this.withSelfType(this.selfTypeOf(stmt), () => {
+        for (const member of stmt.members) {
+          if (member.type !== "ClassMethod" || !member.signatures) continue;
+          for (const signature of member.signatures) this.checkOverload(member.func, signature);
+        }
+      });
+    }));
     for (const member of stmt.members) {
       if (member.type === "ClassConstructor") continue;
       if (CLASS_RESERVED.has(member.name.name)) {
@@ -7942,7 +7975,7 @@ var TypeAnalyzer = class {
   /** Synthesize a type from a destructuring pattern used without an
    *  annotation (`function f({ a, b = 1 })`). */
   patternToType(target, env) {
-    const leaf = (v, def) => v.type !== "IdentifierPattern" ? this.patternToType(v, env) : v.typeAnnotation ? this.resolveType(v.typeAnnotation) : def ? widen(this.infer(def, env)) : anyType;
+    const leaf = (v, def) => v.type === "ObjectPattern" || v.type === "ArrayPattern" ? this.patternToType(v, env) : v.type !== "IdentifierPattern" ? anyType : v.typeAnnotation ? this.resolveType(v.typeAnnotation) : def ? widen(this.infer(def, env)) : anyType;
     if (target.type === "ObjectPattern") {
       const entries = [];
       for (const p of target.properties) {
@@ -8348,6 +8381,7 @@ var TypeAnalyzer = class {
    *  can actually be. An annotation, a pattern or a default still wins. */
   paramsFromSignatures(func, signatures) {
     if (!signatures?.length) return;
+    for (const signature of signatures) this.checkOverload(func, signature);
     const resolved = signatures.map((sig) => this.signatureToFnType(sig));
     func.params.forEach((param, i) => {
       if (param.typeAnnotation || param.pattern || param.default) return;
@@ -8361,6 +8395,64 @@ var TypeAnalyzer = class {
       if (candidates.length) this.contextualParams.set(param, union(candidates));
     });
   }
+  /** The implementation is what runs for every signature of an overload
+   *  set, so each signature must be one it can serve: no parameter it does
+   *  not have, no fewer arguments than it requires, no argument type it does
+   *  not accept, and a return it can give. Stricter than TypeScript, which
+   *  lets a signature name parameters the implementation never reads. */
+  checkOverload(func, signature) {
+    if (!this.emitDiagnostics) return;
+    const node = signature;
+    const report = (message) => {
+      this.diagnostics.push({ node, message });
+    };
+    const own = (params) => params.filter((p, i) => !p.rest && !(i === 0 && !p.typeAnnotation && (p.name === "self" || p.name === "this")));
+    const implementation = own(func.params);
+    const offered = own(signature.params);
+    const implementationRest = func.params.some((p) => p.rest);
+    const signatureRest = signature.params.some((p) => p.rest);
+    const label = (p) => p.pattern ? "a destructured parameter" : `'${p.name}'`;
+    if (!implementationRest) {
+      const extra = offered[implementation.length];
+      if (extra) {
+        report(`This overload takes parameter ${label(extra)}, which the implementation does not have: it takes ${implementation.length} parameter${implementation.length === 1 ? "" : "s"}`);
+        return;
+      }
+      if (signatureRest) {
+        report("This overload takes a rest parameter, which the implementation does not have");
+        return;
+      }
+    }
+    if (!signatureRest) {
+      let required = 0;
+      implementation.forEach((p, i) => {
+        if (!p.optional && p.default === void 0) required = i + 1;
+      });
+      if (offered.length < required) {
+        report(`The implementation requires ${required} argument${required === 1 ? "" : "s"}, and this overload passes at most ${offered.length}`);
+        return;
+      }
+    }
+    if (signature.generics.length || func.generics.length) return;
+    for (let i = 0; i < offered.length && i < implementation.length; i++) {
+      const target = implementation[i];
+      if (!target.typeAnnotation && target.default === void 0) continue;
+      let accepted = this.paramType(target, /* @__PURE__ */ new Map());
+      if (target.default !== void 0) accepted = optional(accepted);
+      const given = this.paramType(offered[i], /* @__PURE__ */ new Map());
+      if (!isAssignable(given, accepted)) {
+        report(`Parameter ${label(offered[i])} of this overload is '${briefType(given)}', which the implementation's '${briefType(accepted)}' does not accept`);
+        return;
+      }
+    }
+    if (signature.returnType && func.returnType) {
+      const promised = this.resolveType(signature.returnType);
+      const returned = this.resolveType(func.returnType);
+      if (!isAssignable(promised, returned) && !isAssignable(returned, promised)) {
+        report(`This overload returns '${briefType(promised)}', which the implementation's '${briefType(returned)}' cannot be`);
+      }
+    }
+  }
   signatureToFnType(sig) {
     const names = sig.generics.map((g) => g.name);
     const record = (type) => {
@@ -8785,6 +8877,12 @@ var TypeAnalyzer = class {
         }
         return;
       }
+      case "MemberExpression":
+      case "IndexExpression":
+        this.infer(target, env);
+        this.checkReadonlyAssign(target, env);
+        this.assignToRef(target, widen(valueType), env);
+        return;
       case "ObjectPattern": {
         for (const p of target.properties) {
           const key = !p.computed && p.key.type === "Identifier" ? p.key.name : !p.computed && p.key.type === "StringLiteral" ? p.key.value : void 0;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tilua/parser",
-  "version": "2.3.0",
+  "version": "2.4.0",
   "description": "tilua parser for roblox",
   "main": "./dist/index.js",
   "module": "./dist/index.js",