@tilua/parser 1.0.0 → 1.0.2

package/dist/index.js

@@ -4395,7 +4395,12 @@ function substitute(t, subst) {
       return t.name && r.kind === "intersection" && !r.name ? { ...r, name: t.name } : r;
     }
     case "genericRef":
-      return { kind: "genericRef", name: t.name, typeArguments: t.typeArguments.map((a) => substitute(a, subst)) };
+      return {
+        kind: "genericRef",
+        name: t.name,
+        typeArguments: t.typeArguments.map((a) => substitute(a, subst)),
+        ...t.origin ? { origin: t.origin } : {}
+      };
     case "keyof":
       return { kind: "keyof", target: substitute(t.target, subst) };
     case "templateLiteral":
@@ -4555,6 +4560,7 @@ function optional(t) {
   return union([t, nilType]);
 }
 function widen(t) {
+  if (isAliasNamed(t)) return t;
   switch (t.kind) {
     case "literal":
       return primitive(t.base);
@@ -4594,7 +4600,7 @@ function isAssignable(rawA, rawB) {
   if (expandAlias) {
     if (a.kind === "genericRef" && b.kind !== "genericRef") a = expandAlias(a);
     else if (b.kind === "genericRef" && a.kind !== "genericRef") b = expandAlias(b);
-    else if (a.kind === "genericRef" && b.kind === "genericRef" && a.name !== b.name) {
+    else if (a.kind === "genericRef" && b.kind === "genericRef" && !sameRefTarget(a, b)) {
       a = expandAlias(a);
       b = expandAlias(b);
     }
@@ -4704,10 +4710,17 @@ function isAssignableInner(a, b) {
   }
   if (b.kind === "typeParam") return false;
   if (a.kind === "genericRef" || b.kind === "genericRef") {
-    return a.kind === "genericRef" && b.kind === "genericRef" && a.name === b.name && a.typeArguments.length === b.typeArguments.length && a.typeArguments.every((x, i) => equalTypes(x, b.typeArguments[i]));
+    return a.kind === "genericRef" && b.kind === "genericRef" && sameRefTarget(a, b) && a.typeArguments.length === b.typeArguments.length && a.typeArguments.every((x, i) => equalTypes(x, b.typeArguments[i]));
   }
   return false;
 }
+function isAliasNamed(t) {
+  if (t.kind === "object" || t.kind === "intersection") return t.name !== void 0;
+  return t.alias !== void 0;
+}
+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;
 }
@@ -5108,6 +5121,7 @@ function mergeObjectMembers(types) {
 var INTERNAL_MEMBERS = /* @__PURE__ */ new Set(["ClassObject", "ParentClass"]);
 var MAX_MISSING = 3;
 var MAX_EXPLANATION = 90;
+var MAX_TYPE = 120;
 function analyzeTypes(program, scopes, options = {}) {
   return new TypeAnalyzer(program, scopes, options).run();
 }
@@ -5486,11 +5500,15 @@ var TypeAnalyzer = class {
   narrowedTypeOf = /* @__PURE__ */ new Map();
   typeOfTypeNode = /* @__PURE__ */ new Map();
   expectedTypeOf = /* @__PURE__ */ new Map();
+  iteratesValues = /* @__PURE__ */ new Set();
   /** Public: each alias resolved once (generic aliases keep their params as
    *  `typeParam` nodes in the body). */
   aliases = new AliasMap();
   /** 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
+   *  type expands the ref here rather than by its name there. */
+  origin = { expand: (t) => this.expand(t) };
   /** See `resolveClass`. */
   classTypes = /* @__PURE__ */ new WeakMap();
   /** See `instanceType` — one instance type per `class ... end`. */
@@ -5566,6 +5584,7 @@ var TypeAnalyzer = class {
       typeOfTypeNode: this.typeOfTypeNode,
       expectedTypeOf: this.expectedTypeOf,
       aliases: this.resolveDeferredAliases(),
+      iteratesValues: this.iteratesValues,
       diagnostics: this.diagnostics
     };
   }
@@ -5898,7 +5917,8 @@ var TypeAnalyzer = class {
     return {
       kind: "genericRef",
       name: stmt.name.name,
-      typeArguments: params.map((p) => typeParam(p.name, p.constraint ? this.resolveType(p.constraint) : void 0))
+      typeArguments: params.map((p) => typeParam(p.name, p.constraint ? this.resolveType(p.constraint) : void 0)),
+      origin: this.origin
     };
   }
   /** The class table: the statics, what it inherits from the class it
@@ -6059,7 +6079,7 @@ var TypeAnalyzer = class {
             if (declared && this.emitDiagnostics && !isAssignable(actual, declared)) {
               this.diagnostics.push({
                 node: member.init,
-                message: `Type '${formatType(actual)}' is not assignable to type '${formatType(declared)}'` + this.explainMismatch(actual, declared)
+                message: `Type '${briefType(actual)}' is not assignable to type '${briefType(declared)}'` + this.explainMismatch(actual, declared)
               });
             }
             continue;
@@ -6246,7 +6266,7 @@ var TypeAnalyzer = class {
     if (fits) return;
     this.diagnostics.push({
       node: stmt,
-      message: `Type '${formatType(actual)}' is not assignable to '${briefType(declared)}'` + this.explainMismatch(actual, declared)
+      message: `Type '${briefType(actual)}' is not assignable to '${briefType(declared)}'` + this.explainMismatch(actual, declared)
     });
   }
   /** A function that declared what it returns but never does. Only a body
@@ -6463,7 +6483,8 @@ var TypeAnalyzer = class {
             return this.expand({
               kind: "genericRef",
               name: node.base,
-              typeArguments: node.typeArguments.map((a) => this.resolveType(a))
+              typeArguments: node.typeArguments.map((a) => this.resolveType(a)),
+              origin: this.origin
             });
           }
           const imported = this.importedTypes.get(node.base);
@@ -6476,7 +6497,8 @@ var TypeAnalyzer = class {
           return this.expand({
             kind: "genericRef",
             name,
-            typeArguments: node.typeArguments.map((a) => this.resolveType(a))
+            typeArguments: node.typeArguments.map((a) => this.resolveType(a)),
+            origin: this.origin
           });
         }
         return {
@@ -6906,7 +6928,7 @@ var TypeAnalyzer = class {
             if (declared.kind !== "any" && !this.namesNothing(declared) && !this.fitsAnnotation(source, declared, inferred, env)) {
               this.diagnostics.push({
                 node: stmt,
-                message: `Type '${formatType(inferred)}' is not assignable to '${formatType(declared)}'` + this.explainMismatch(inferred, declared)
+                message: `Type '${briefType(inferred)}' is not assignable to '${briefType(declared)}'` + this.explainMismatch(inferred, declared)
               });
             } else if (declared.kind !== "any") {
               this.reportExcessProperties(source, declared);
@@ -7000,7 +7022,7 @@ var TypeAnalyzer = class {
                 if (this.emitDiagnostics && !isAssignable(next, declared) && declared.kind !== "any") {
                   this.diagnostics.push({
                     node: stmt,
-                    message: `Type '${formatType(next)}' is not assignable to '${formatType(declared)}'` + this.explainMismatch(next, declared)
+                    message: `Type '${briefType(next)}' is not assignable to '${briefType(declared)}'` + this.explainMismatch(next, declared)
                   });
                 }
                 this.setBinding(env, id, narrowTo(declared, next));
@@ -7085,21 +7107,23 @@ var TypeAnalyzer = class {
           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);
         } else {
-          const [keyT, valT] = this.iterationTypes(stmt.iterators[0], iterTypes[0], stmt.variables.length);
+          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);
         }
         this.visitBlock(stmt.body, bodyEnv);
         return;
       }
       case "ReturnStatement": {
         const declared = this.declaredReturns[this.declaredReturns.length - 1];
-        if (declared) {
+        const wanted = declared ?? this.contextualReturns[this.contextualReturns.length - 1];
+        if (wanted) {
           if (stmt.arguments.length === 1) {
-            this.applyContext(stmt.arguments[0], declared);
-          } else if (declared.kind === "tuple" && declared.isPack) {
-            stmt.arguments.forEach((a, i) => this.applyContext(a, declared.elements[i]));
+            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;
@@ -7328,6 +7352,17 @@ var TypeAnalyzer = class {
   /** What a function expression's unannotated parameters are, from where
    *  it is written — see `applyContext`. */
   contextualParams = /* @__PURE__ */ new WeakMap();
+  /** What a function expression written in a typed position returns, from
+   *  that position — see `applyContext`. A body with no `return` annotation
+   *  would otherwise infer its `return` expressions with nothing wanted of
+   *  them, and widen the literals in them: `() => S = function() { return
+   *  { Status: true } }` inferred `Status: boolean` and then failed against
+   *  `S`. It is a hint, not a contract: only `applyContext` reads it, so a
+   *  body that does not match still reports at the assignment, not here. */
+  contextualReturnOf = /* @__PURE__ */ new WeakMap();
+  /** `contextualReturnOf` for each function body being walked, alongside
+   *  `declaredReturns`. */
+  contextualReturns = [];
   /** `expected` is the type the surroundings want for `expr`. A function
    *  expression written there takes its unannotated parameters' types from
    *  it, as in TypeScript: `signal:Connect(function(player) ... end)` knows
@@ -7350,6 +7385,10 @@ var TypeAnalyzer = class {
     const members = expected.kind === "union" ? expected.types : [expected];
     const signatures = members.flatMap((m) => this.overloadsOf(this.expand(m)));
     if (!signatures.length) return;
+    if (!e.func.returnType && !e.func.predicate) {
+      const returns = signatures.map((s) => s.returns).filter((t) => !containsTypeParam(t));
+      if (returns.length) this.contextualReturnOf.set(e.func, union(returns));
+    }
     e.func.params.forEach((p, k) => {
       if (p.typeAnnotation || p.pattern || p.default) return;
       const candidates = [];
@@ -7393,7 +7432,9 @@ var TypeAnalyzer = class {
         return property ? [property.type] : o.indexer ? [o.indexer.value] : [];
       });
       if (types.length) {
-        this.applyContext(field.type === "TableFieldShorthand" ? field.name : field.value, union(types));
+        const target = field.type === "TableFieldShorthand" ? field.name : field.value;
+        this.contextArms.set(target, types);
+        this.applyContext(target, union(types));
       }
     }
   }
@@ -7454,11 +7495,13 @@ var TypeAnalyzer = class {
   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();
     }
   }
   visitFunctionBodyInner(func, outerEnv) {
@@ -8100,22 +8143,26 @@ var TypeAnalyzer = class {
     if (ids.length < 2) return;
     this.correlateBindings(env, ids, objects.map((member) => names.map((name) => this.propertyType(member, name))));
   }
-  /** `(keyType, valueType)` 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. */
+  /** `(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)];
+      if (name === "ipairs") return [numberType, this.elementType(src, 0), false];
       if (name === "pairs" || name === "next") {
         if (src.kind === "object") {
           return [
             src.indexer?.key ?? stringType,
-            src.indexer?.value ?? union([...src.properties.values()].map((p) => p.type))
+            src.indexer?.value ?? union([...src.properties.values()].map((p) => p.type)),
+            false
           ];
         }
-        if (src.kind === "array") return [numberType, src.element];
+        if (src.kind === "array") return [numberType, src.element, false];
       }
     }
     const iterator = this.expand(iterType);
@@ -8123,16 +8170,18 @@ var TypeAnalyzer = class {
       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)];
+      return [at(0), at(1), false];
     }
     const t = this.expand(iterType);
-    if (t.kind === "array") return varCount >= 2 ? [numberType, t.element] : [t.element, unknownType];
+    if (t.kind === "array") {
+      return varCount >= 2 ? [numberType, t.element, false] : [t.element, unknownType, true];
+    }
     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] : [v, unknownType];
+      return varCount >= 2 ? [k, v, false] : [v, unknownType, true];
     }
-    return [unknownType, unknownType];
+    return [unknownType, unknownType, false];
   }
   inferReturnType(body, env) {
     const returns = [];
@@ -8275,6 +8324,7 @@ var TypeAnalyzer = class {
    *  resolving, which is what breaks re-entry on a recursive alias. */
   expand(t) {
     if (t.kind !== "genericRef") return t;
+    if (t.origin && t.origin !== this.origin) return t.origin.expand(t);
     const def = this.aliasDefs.get(t.name);
     if (!def) {
       const imported = this.importedTypes.get(t.name);
@@ -8578,7 +8628,7 @@ var TypeAnalyzer = class {
         if (!isAssignable(narrow, declared) && !isAssignable(actual, declared)) {
           this.diagnostics.push({
             node: expr,
-            message: `Type '${formatType(actual)}' does not satisfy the expected type '${formatType(declared)}'`
+            message: `Type '${briefType(actual)}' does not satisfy the expected type '${briefType(declared)}'` + this.explainMismatch(actual, declared)
           });
         } else {
           this.reportExcessProperties(expr.expression, declared);
@@ -8957,8 +9007,16 @@ var TypeAnalyzer = class {
    *  inferred, so this is a lookup rather than a second pass. */
   widenUnlessAsked(value, at) {
     const wanted = this.expectedTypeOf.get(at);
+    if (value.kind === "literal") {
+      const arms = this.contextArms.get(at);
+      if (arms?.some((arm) => this.admitsLiteral(arm, value.base))) return value;
+    }
     return wanted === void 0 ? widen(value) : this.keepContextualLiterals(value, wanted);
   }
+  /** What each arm of the contract wanted of an expression, unmerged — see
+   *  `widenUnlessAsked`. Recorded by `applyTableContext` beside the merged
+   *  type it hands to `applyContext`. */
+  contextArms = /* @__PURE__ */ new WeakMap();
   inferObject(expr, env, asConst) {
     const entries = [];
     let indexer;
@@ -9667,8 +9725,9 @@ var TypeAnalyzer = class {
    *  themselves are then the whole story. */
   explainMismatch(actual, expected) {
     const from = this.expand(actual);
-    const to = this.expand(expected);
-    if (from.kind !== "object" || to.kind !== "object") return "";
+    if (from.kind !== "object") return "";
+    const to = this.likeliestArm(from, this.expand(expected));
+    if (to === void 0) return "";
     const missing = [];
     for (const [name, property] of to.properties) {
       if (property.optional || from.properties.has(name) || INTERNAL_MEMBERS.has(name)) continue;
@@ -9693,6 +9752,34 @@ var TypeAnalyzer = class {
     }
     return "";
   }
+  /** Which object of a contract the value was reaching for. One object is
+   *  itself; among several, a discriminant decides — the arm whose literal
+   *  properties the value already agrees with (`Status: true` picks
+   *  `StatSuccess` over `StatError`). Failing that, the arm it is closest to
+   *  fitting, so the explanation is about the shortest gap rather than an
+   *  arbitrary one. `undefined` when there is no object to explain against. */
+  likeliestArm(from, expected) {
+    const arms = this.membersOf(expected).filter((m) => m.kind === "object");
+    if (arms.length <= 1) return arms[0];
+    const gapOf = (arm) => {
+      let gap = 0;
+      for (const [name, property] of arm.properties) {
+        if (INTERNAL_MEMBERS.has(name)) continue;
+        const own = from.properties.get(name);
+        if (!own) {
+          if (!property.optional) gap += 1;
+          continue;
+        }
+        if (isAssignable(own.type, property.type)) continue;
+        gap += this.expand(property.type).kind === "literal" ? 100 : 1;
+      }
+      for (const name of from.properties.keys()) {
+        if (!INTERNAL_MEMBERS.has(name) && !arm.properties.has(name) && !arm.indexer) gap += 1;
+      }
+      return gap;
+    };
+    return arms.reduce((best, arm) => gapOf(arm) < gapOf(best) ? arm : best);
+  }
   bindingIdOf(id) {
     return this.scopes.bindingOf.get(id);
   }
@@ -9739,7 +9826,15 @@ function briefType(t) {
     const shown = t.types.slice(0, 6).map(formatType).join(" | ");
     return `${shown} | ... ${t.types.length - 6} more`;
   }
-  return formatType(t);
+  const full = formatType(t);
+  if (full.length <= MAX_TYPE) return full;
+  if (t.kind === "object" && t.properties.size) {
+    const names = [...t.properties.keys()].filter((n) => !INTERNAL_MEMBERS.has(n));
+    const shown = names.slice(0, MAX_MISSING);
+    const rest = names.length - shown.length;
+    return `{ ${shown.join(", ")}${rest > 0 ? `, ... ${rest} more` : ""} }`;
+  }
+  return `${full.slice(0, MAX_TYPE)}...`;
 }
 
 // src/project/host.ts

package/package.json

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