luaut-parser 1.1.0 → 1.2.0

package/README.md

@@ -127,8 +127,7 @@ analyzeTypes(program, scopes, {
   (`export { a } from`) and `export * from` are.
 - `setmetatable` and metatables are not modelled.
 - Accessing a property a type does not have yields `unknown` rather than an
-  error; assigning to a `readonly` property is not reported; generic
-  constraints are not checked at call sites.
+  error; assigning to a `readonly` property is not reported.
 
 ## Development
 

package/dist/index.cjs

@@ -3832,6 +3832,7 @@ var TypeAnalyzer = class {
   bindingType = /* @__PURE__ */ new Map();
   narrowedTypeOf = /* @__PURE__ */ new Map();
   typeOfTypeNode = /* @__PURE__ */ new Map();
+  expectedTypeOf = /* @__PURE__ */ new Map();
   /** Public: each alias resolved once (generic aliases keep their params as
    *  `typeParam` nodes in the body). */
   aliases = /* @__PURE__ */ new Map();
@@ -3897,6 +3898,7 @@ var TypeAnalyzer = class {
       bindingType: this.bindingType,
       narrowedTypeOf: this.narrowedTypeOf,
       typeOfTypeNode: this.typeOfTypeNode,
+      expectedTypeOf: this.expectedTypeOf,
       aliases: this.resolveDeferredAliases(),
       diagnostics: this.diagnostics
     };
@@ -4878,16 +4880,76 @@ var TypeAnalyzer = class {
     return void 0;
   }
   /** Can this signature be called with these argument types? The signature's
-   *  own generic parameters act as wildcards — they are what the call would
-   *  infer, so they must not make the match fail. */
+   *  own type parameters stand for what the call would infer, so each is
+   *  checked only against its constraint — `<K extends keyof Services>`
+   *  accepts `"Players"` but not `""`. */
   overloadAccepts(f, argTypes) {
     if (!f.varargs && argTypes.length > f.params.length) return false;
-    const wildcards = new Map((f.typeParams ?? []).map((n) => [n, anyType]));
+    const params = this.boundParams(f);
     return f.params.every((p, i) => {
       if (argTypes[i] === void 0) return p.optional === true;
-      return isAssignable(argTypes[i], substitute(p.type, wildcards));
+      return isAssignable(argTypes[i], params[i]);
     });
   }
+  /** A signature's parameter types as a call site sees them before inference:
+   *  each type parameter replaced by its constraint, or by `any` when it has
+   *  none — or when the constraint mentions another type parameter, which a
+   *  lone argument cannot be checked against without false errors. */
+  boundParams(f) {
+    if (!f.typeParams?.length) return f.params.map((p) => p.type);
+    const bounds = new Map(f.typeParams.map((name) => [name, anyType]));
+    const seen = /* @__PURE__ */ new WeakSet();
+    const walk = (value) => {
+      if (!value || typeof value !== "object" || seen.has(value)) return;
+      seen.add(value);
+      if (value instanceof Map) {
+        value.forEach(walk);
+        return;
+      }
+      const t = value;
+      if (t.kind === "typeParam" && typeof t.name === "string" && bounds.has(t.name) && t.constraint && !containsTypeParam(t.constraint)) {
+        bounds.set(t.name, this.reduceType(t.constraint));
+      }
+      for (const child of Object.values(value)) walk(child);
+    };
+    for (const p of f.params) walk(p.type);
+    return f.params.map((p) => substitute(p.type, bounds));
+  }
+  /** Record what each written argument is expected to be — see
+   *  `TypeAnalysis.expectedTypeOf`. */
+  recordExpected(written, fns, selfOf) {
+    written.forEach((arg, j) => {
+      const candidates = [];
+      for (const f of fns) {
+        const i = j + selfOf(f);
+        const param = i < f.params.length ? this.boundParams(f)[i] : f.varargs;
+        if (param) candidates.push(param);
+      }
+      if (candidates.length) this.expectedTypeOf.set(arg, union(candidates));
+    });
+  }
+  /** No signature accepts the call, and the argument count is not the
+   *  problem: say which argument is wrong, the way TypeScript does. */
+  reportArguments(call, written, fns, argsFor, selfOf) {
+    if (!this.emitDiagnostics) return;
+    if (fns.length > 1) {
+      this.diagnostics.push({ node: call, message: "No overload matches this call" });
+      return;
+    }
+    const f = fns[0];
+    const args = argsFor(f);
+    const params = this.boundParams(f);
+    const self = selfOf(f);
+    for (let i = 0; i < f.params.length; i++) {
+      const arg = args[i];
+      if (arg === void 0 || isAssignable(arg, params[i])) continue;
+      this.diagnostics.push({
+        node: written[i - self] ?? call,
+        message: `Argument of type '${formatType(arg)}' is not assignable to parameter of type '${briefType(params[i])}'`
+      });
+      return;
+    }
+  }
   /** A required parameter may not follow an optional one — otherwise the
    *  optional one could never actually be omitted. Same rule as TypeScript,
    *  and it applies to a default (`a = 1`) as much as to a `?`. */
@@ -4917,22 +4979,25 @@ var TypeAnalyzer = class {
     return { min, max: f.varargs ? void 0 : f.params.length };
   }
   /** Report a call that passes too few or too many arguments. Only fires
-   *  when *no* overload accepts the call, so an overload set still reports
-   *  once, against its first signature. */
+   *  when *no* overload accepts the count, so an overload set still reports
+   *  once, against its first signature. Returns whether the count fits, so
+   *  an argument's type is only complained about when its count is right. */
   checkArity(node, fns, argCount, selfArgs) {
-    if (!this.emitDiagnostics || !fns.length) return;
+    if (!fns.length) return true;
     const fits = fns.some((f) => {
       const { min: min2, max: max2 } = this.arityOf(f);
       const n = argCount + selfArgs;
       return n >= min2 && (max2 === void 0 || n <= max2);
     });
-    if (fits) return;
+    if (fits) return true;
+    if (!this.emitDiagnostics) return false;
     const { min, max } = this.arityOf(fns[0]);
     const need = max === void 0 ? `at least ${min - selfArgs}` : min === max ? `${min - selfArgs}` : `${min - selfArgs}-${max - selfArgs}`;
     this.diagnostics.push({
       node,
       message: `Expected ${need} argument${need === "1" ? "" : "s"}, got ${argCount}`
     });
+    return false;
   }
   signatureToFnType(sig) {
     const names = sig.generics.map((g) => g.name);
@@ -5370,11 +5435,13 @@ var TypeAnalyzer = class {
         const argTypes = expr.arguments.map((a) => this.infer(a, env));
         const fns = this.overloadsOf(callee);
         if (fns.length) {
-          this.checkArity(expr, fns, argTypes.length, 0);
+          this.recordExpected(expr.arguments, fns, () => 0);
+          const arityFits = this.checkArity(expr, fns, argTypes.length, 0);
           const picked = this.pickOverload(fns, argTypes);
           if (picked) {
             return this.callReturn(picked, this.constArgs(picked, expr.arguments, argTypes, env));
           }
+          if (arityFits) this.reportArguments(expr, expr.arguments, fns, () => argTypes, () => 0);
           return union(fns.map((f) => this.callReturn(f, argTypes)));
         }
         return callee.kind === "any" ? anyType : unknownType;
@@ -5385,13 +5452,16 @@ var TypeAnalyzer = class {
         const fns = this.overloadsOf(this.propertyType(objType, expr.method.name));
         if (fns.length) {
           const withSelf = (f) => this.takesSelf(f) ? [objType, ...argTypes] : argTypes;
-          this.checkArity(expr, fns, argTypes.length, this.takesSelf(fns[0]) ? 1 : 0);
+          const selfOf = (f) => this.takesSelf(f) ? 1 : 0;
+          this.recordExpected(expr.arguments, fns, selfOf);
+          const arityFits = this.checkArity(expr, fns, argTypes.length, this.takesSelf(fns[0]) ? 1 : 0);
           const picked = this.pickOverload(fns, argTypes, withSelf);
           if (picked) {
             const self = this.takesSelf(picked) ? 1 : 0;
             const written = this.constArgs(picked, expr.arguments, argTypes, env, self);
             return this.callReturn(picked, this.takesSelf(picked) ? [objType, ...written] : written);
           }
+          if (arityFits) this.reportArguments(expr, expr.arguments, fns, withSelf, selfOf);
           return union(fns.map((f) => this.callReturn(f, withSelf(f))));
         }
         return objType.kind === "any" ? anyType : unknownType;
@@ -5839,6 +5909,13 @@ function containsTypeQuery(node) {
   if (node.type === "TypeofTypeNode") return true;
   return Object.values(node).some(containsTypeQuery);
 }
+function briefType(t) {
+  if (t.kind === "union" && t.types.length > 8) {
+    const shown = t.types.slice(0, 6).map(formatType).join(" | ");
+    return `${shown} | ... ${t.types.length - 6} more`;
+  }
+  return formatType(t);
+}
 
 // src/lib/luau.ts
 var import_node_fs = require("fs");

package/dist/index.d.cts

@@ -1080,6 +1080,12 @@ interface TypeAnalysis {
      *  `typeof x`, a property's type inside `{ ... }`. Inside a generic alias or
      *  function its parameters stay unresolved (`T`). */
     readonly typeOfTypeNode: Map<TypeNode | TypePackNode, Type>;
+    /** What each call argument is expected to be: the parameter it lands on,
+     *  with the signature's type parameters replaced by their constraints — a
+     *  union when an overload set disagrees. Recorded even for a call that does
+     *  not type-check, since that is exactly when an editor wants to offer the
+     *  values that would. */
+    readonly expectedTypeOf: Map<Expression, Type>;
     /** Top-level type aliases, resolved — and the type names this module
      *  imports, so tooling treats both alike. */
     readonly aliases: Map<string, Type>;

package/dist/index.d.ts

@@ -1080,6 +1080,12 @@ interface TypeAnalysis {
      *  `typeof x`, a property's type inside `{ ... }`. Inside a generic alias or
      *  function its parameters stay unresolved (`T`). */
     readonly typeOfTypeNode: Map<TypeNode | TypePackNode, Type>;
+    /** What each call argument is expected to be: the parameter it lands on,
+     *  with the signature's type parameters replaced by their constraints — a
+     *  union when an overload set disagrees. Recorded even for a call that does
+     *  not type-check, since that is exactly when an editor wants to offer the
+     *  values that would. */
+    readonly expectedTypeOf: Map<Expression, Type>;
     /** Top-level type aliases, resolved — and the type names this module
      *  imports, so tooling treats both alike. */
     readonly aliases: Map<string, Type>;

package/dist/index.js

@@ -3738,6 +3738,7 @@ var TypeAnalyzer = class {
   bindingType = /* @__PURE__ */ new Map();
   narrowedTypeOf = /* @__PURE__ */ new Map();
   typeOfTypeNode = /* @__PURE__ */ new Map();
+  expectedTypeOf = /* @__PURE__ */ new Map();
   /** Public: each alias resolved once (generic aliases keep their params as
    *  `typeParam` nodes in the body). */
   aliases = /* @__PURE__ */ new Map();
@@ -3803,6 +3804,7 @@ var TypeAnalyzer = class {
       bindingType: this.bindingType,
       narrowedTypeOf: this.narrowedTypeOf,
       typeOfTypeNode: this.typeOfTypeNode,
+      expectedTypeOf: this.expectedTypeOf,
       aliases: this.resolveDeferredAliases(),
       diagnostics: this.diagnostics
     };
@@ -4784,16 +4786,76 @@ var TypeAnalyzer = class {
     return void 0;
   }
   /** Can this signature be called with these argument types? The signature's
-   *  own generic parameters act as wildcards — they are what the call would
-   *  infer, so they must not make the match fail. */
+   *  own type parameters stand for what the call would infer, so each is
+   *  checked only against its constraint — `<K extends keyof Services>`
+   *  accepts `"Players"` but not `""`. */
   overloadAccepts(f, argTypes) {
     if (!f.varargs && argTypes.length > f.params.length) return false;
-    const wildcards = new Map((f.typeParams ?? []).map((n) => [n, anyType]));
+    const params = this.boundParams(f);
     return f.params.every((p, i) => {
       if (argTypes[i] === void 0) return p.optional === true;
-      return isAssignable(argTypes[i], substitute(p.type, wildcards));
+      return isAssignable(argTypes[i], params[i]);
     });
   }
+  /** A signature's parameter types as a call site sees them before inference:
+   *  each type parameter replaced by its constraint, or by `any` when it has
+   *  none — or when the constraint mentions another type parameter, which a
+   *  lone argument cannot be checked against without false errors. */
+  boundParams(f) {
+    if (!f.typeParams?.length) return f.params.map((p) => p.type);
+    const bounds = new Map(f.typeParams.map((name) => [name, anyType]));
+    const seen = /* @__PURE__ */ new WeakSet();
+    const walk = (value) => {
+      if (!value || typeof value !== "object" || seen.has(value)) return;
+      seen.add(value);
+      if (value instanceof Map) {
+        value.forEach(walk);
+        return;
+      }
+      const t = value;
+      if (t.kind === "typeParam" && typeof t.name === "string" && bounds.has(t.name) && t.constraint && !containsTypeParam(t.constraint)) {
+        bounds.set(t.name, this.reduceType(t.constraint));
+      }
+      for (const child of Object.values(value)) walk(child);
+    };
+    for (const p of f.params) walk(p.type);
+    return f.params.map((p) => substitute(p.type, bounds));
+  }
+  /** Record what each written argument is expected to be — see
+   *  `TypeAnalysis.expectedTypeOf`. */
+  recordExpected(written, fns, selfOf) {
+    written.forEach((arg, j) => {
+      const candidates = [];
+      for (const f of fns) {
+        const i = j + selfOf(f);
+        const param = i < f.params.length ? this.boundParams(f)[i] : f.varargs;
+        if (param) candidates.push(param);
+      }
+      if (candidates.length) this.expectedTypeOf.set(arg, union(candidates));
+    });
+  }
+  /** No signature accepts the call, and the argument count is not the
+   *  problem: say which argument is wrong, the way TypeScript does. */
+  reportArguments(call, written, fns, argsFor, selfOf) {
+    if (!this.emitDiagnostics) return;
+    if (fns.length > 1) {
+      this.diagnostics.push({ node: call, message: "No overload matches this call" });
+      return;
+    }
+    const f = fns[0];
+    const args = argsFor(f);
+    const params = this.boundParams(f);
+    const self = selfOf(f);
+    for (let i = 0; i < f.params.length; i++) {
+      const arg = args[i];
+      if (arg === void 0 || isAssignable(arg, params[i])) continue;
+      this.diagnostics.push({
+        node: written[i - self] ?? call,
+        message: `Argument of type '${formatType(arg)}' is not assignable to parameter of type '${briefType(params[i])}'`
+      });
+      return;
+    }
+  }
   /** A required parameter may not follow an optional one — otherwise the
    *  optional one could never actually be omitted. Same rule as TypeScript,
    *  and it applies to a default (`a = 1`) as much as to a `?`. */
@@ -4823,22 +4885,25 @@ var TypeAnalyzer = class {
     return { min, max: f.varargs ? void 0 : f.params.length };
   }
   /** Report a call that passes too few or too many arguments. Only fires
-   *  when *no* overload accepts the call, so an overload set still reports
-   *  once, against its first signature. */
+   *  when *no* overload accepts the count, so an overload set still reports
+   *  once, against its first signature. Returns whether the count fits, so
+   *  an argument's type is only complained about when its count is right. */
   checkArity(node, fns, argCount, selfArgs) {
-    if (!this.emitDiagnostics || !fns.length) return;
+    if (!fns.length) return true;
     const fits = fns.some((f) => {
       const { min: min2, max: max2 } = this.arityOf(f);
       const n = argCount + selfArgs;
       return n >= min2 && (max2 === void 0 || n <= max2);
     });
-    if (fits) return;
+    if (fits) return true;
+    if (!this.emitDiagnostics) return false;
     const { min, max } = this.arityOf(fns[0]);
     const need = max === void 0 ? `at least ${min - selfArgs}` : min === max ? `${min - selfArgs}` : `${min - selfArgs}-${max - selfArgs}`;
     this.diagnostics.push({
       node,
       message: `Expected ${need} argument${need === "1" ? "" : "s"}, got ${argCount}`
     });
+    return false;
   }
   signatureToFnType(sig) {
     const names = sig.generics.map((g) => g.name);
@@ -5276,11 +5341,13 @@ var TypeAnalyzer = class {
         const argTypes = expr.arguments.map((a) => this.infer(a, env));
         const fns = this.overloadsOf(callee);
         if (fns.length) {
-          this.checkArity(expr, fns, argTypes.length, 0);
+          this.recordExpected(expr.arguments, fns, () => 0);
+          const arityFits = this.checkArity(expr, fns, argTypes.length, 0);
           const picked = this.pickOverload(fns, argTypes);
           if (picked) {
             return this.callReturn(picked, this.constArgs(picked, expr.arguments, argTypes, env));
           }
+          if (arityFits) this.reportArguments(expr, expr.arguments, fns, () => argTypes, () => 0);
           return union(fns.map((f) => this.callReturn(f, argTypes)));
         }
         return callee.kind === "any" ? anyType : unknownType;
@@ -5291,13 +5358,16 @@ var TypeAnalyzer = class {
         const fns = this.overloadsOf(this.propertyType(objType, expr.method.name));
         if (fns.length) {
           const withSelf = (f) => this.takesSelf(f) ? [objType, ...argTypes] : argTypes;
-          this.checkArity(expr, fns, argTypes.length, this.takesSelf(fns[0]) ? 1 : 0);
+          const selfOf = (f) => this.takesSelf(f) ? 1 : 0;
+          this.recordExpected(expr.arguments, fns, selfOf);
+          const arityFits = this.checkArity(expr, fns, argTypes.length, this.takesSelf(fns[0]) ? 1 : 0);
           const picked = this.pickOverload(fns, argTypes, withSelf);
           if (picked) {
             const self = this.takesSelf(picked) ? 1 : 0;
             const written = this.constArgs(picked, expr.arguments, argTypes, env, self);
             return this.callReturn(picked, this.takesSelf(picked) ? [objType, ...written] : written);
           }
+          if (arityFits) this.reportArguments(expr, expr.arguments, fns, withSelf, selfOf);
           return union(fns.map((f) => this.callReturn(f, withSelf(f))));
         }
         return objType.kind === "any" ? anyType : unknownType;
@@ -5745,6 +5815,13 @@ function containsTypeQuery(node) {
   if (node.type === "TypeofTypeNode") return true;
   return Object.values(node).some(containsTypeQuery);
 }
+function briefType(t) {
+  if (t.kind === "union" && t.types.length > 8) {
+    const shown = t.types.slice(0, 6).map(formatType).join(" | ");
+    return `${shown} | ... ${t.types.length - 6} more`;
+  }
+  return formatType(t);
+}
 
 // src/lib/luau.ts
 import { readFileSync } from "fs";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "luaut-parser",
-  "version": "1.1.0",
+  "version": "1.2.0",
   "description": "luaut parser for roblox",
   "main": "./dist/index.js",
   "module": "./dist/index.js",
@@ -36,8 +36,5 @@
     "tsup": "^8.5.1",
     "tsx": "^4.19.0",
     "typescript": "^5.0.4"
-  },
-  "dependencies": {
-    "luaut-parser": "^1.0.0"
   }
 }