@tilua/parser 2.1.0 → 2.2.0

package/dist/index.cjs

@@ -4670,14 +4670,17 @@ function classArguments(t, name) {
   if (t.kind === "object") return t.class?.typeArguments?.get(name);
   return void 0;
 }
-function unify(param, arg, vars, out) {
+function unify(param, arg, vars, out, how = "union") {
   if (param.kind === "typeParam" && param.constraint && !vars.has(param.name)) {
-    unify(param.constraint, arg, vars, out);
+    unify(param.constraint, arg, vars, out, how);
     return;
   }
   if (param.kind === "typeParam" && vars.has(param.name)) {
     const prev = out.get(param.name);
-    out.set(param.name, prev ? union([prev, arg]) : arg);
+    if (!prev) out.set(param.name, arg);
+    else if (isAssignable(arg, prev)) {
+    } else if (isAssignable(prev, arg)) out.set(param.name, arg);
+    else if (how === "union") out.set(param.name, union([prev, arg]));
     return;
   }
   if (arg.kind === "any" || arg.kind === "never") return;
@@ -7862,8 +7865,10 @@ var TypeAnalyzer = class {
   // --------------------------------------------------------
   // Functions
   // --------------------------------------------------------
-  visitFunctionBody(func, outerEnv) {
-    this.withTypeParams(func.generics, () => this.visitFunctionBodyInner(func, outerEnv));
+  /** `returns`, when given, collects the type of each `return` the walk
+   *  reads — see `inferFunctionBody`. */
+  visitFunctionBody(func, outerEnv, returns) {
+    this.withTypeParams(func.generics, () => this.visitFunctionBodyInner(func, outerEnv, returns));
   }
   /** A parameter's type: annotation, else a shape synthesized from a
    *  destructuring pattern, else inferred from its default, else `any`. */
@@ -7912,6 +7917,53 @@ var TypeAnalyzer = class {
    *  it, as in TypeScript: `signal:Connect(function(player) ... end)` knows
    *  `player` from `Connect`'s callback type. Anything else is inferred as
    *  usual. */
+  /** The arguments of a call, in two passes where one is needed.
+   *
+   *  A function written at the call site with a parameter nothing annotates
+   *  reads that parameter from the signature — and where the signature says
+   *  `(v: T) => U`, `T` is only known once the other arguments have been
+   *  read. So such an argument is read once quietly, to get a shape to pick
+   *  a signature with, and then again with `T` in hand: `map(xs, v => v + 1)`
+   *  has its `v` a number by then, and `U` follows from what the body
+   *  answers. Everything else is read once, as it always was. */
+  inferArguments(written, fns, selfOf, extra, env) {
+    const expected = this.expectedArguments(written, fns, selfOf);
+    written.forEach((a, i) => this.applyContext(a, expected[i]));
+    const waits = written.map((a, i) => this.waitsOnInference(a, expected[i]));
+    if (!waits.some(Boolean)) return written.map((a) => this.infer(a, env));
+    const argTypes = written.map((a, i) => waits[i] ? this.quietly(() => this.infer(a, env)) : this.infer(a, env));
+    const picked = this.pickOverload(fns, argTypes, (f) => extra(f, argTypes), this.spreadOf(written, selfOf(fns[0])));
+    const subst = picked?.typeParams?.length ? this.inferTypeArgs(picked, extra(picked, argTypes)) : void 0;
+    written.forEach((a, i) => {
+      if (!waits[i]) return;
+      if (picked && subst) {
+        const self = selfOf(picked);
+        const declared = i + self < picked.params.length ? picked.params[i + self].type : picked.varargs;
+        if (declared) this.applyContext(a, this.reduceType(substitute(declared, subst)));
+      }
+      argTypes[i] = this.infer(a, env);
+    });
+    return argTypes;
+  }
+  /** Is this argument a function whose own type waits on the call's? */
+  waitsOnInference(arg, expected) {
+    if (!expected || !containsTypeParam(expected)) return false;
+    let e = arg;
+    while (e.type === "ParenthesizedExpression") e = e.expression;
+    if (e.type !== "FunctionExpression") return false;
+    return e.func.params.some((p) => !p.typeAnnotation && !p.default && !p.pattern && p.name !== "self" && p.name !== "this");
+  }
+  /** Read something without saying anything about it: a first pass whose
+   *  only purpose is a shape to go on. */
+  quietly(read) {
+    const was = this.emitDiagnostics;
+    this.emitDiagnostics = false;
+    try {
+      return read();
+    } finally {
+      this.emitDiagnostics = was;
+    }
+  }
   applyContext(expr, expected) {
     let e = expr;
     while (e.type === "ParenthesizedExpression") e = e.expression;
@@ -8060,7 +8112,7 @@ var TypeAnalyzer = class {
       this.contextualReturns.pop();
     }
   }
-  visitFunctionBodyInner(func, outerEnv) {
+  visitFunctionBodyInner(func, outerEnv, returns) {
     const env = forkEnv(outerEnv);
     for (const p of func.params) {
       if (p.pattern) {
@@ -8077,7 +8129,7 @@ var TypeAnalyzer = class {
         if (p.typeAnnotation) this.annotated.add(id);
       }
     }
-    this.withVarargs(func, () => this.collectReturns(void 0, () => {
+    this.withVarargs(func, () => this.collectReturns(returns, () => {
       this.visitBlock(func.body, env);
       this.checkReturnsAtAll(func, this.declaredReturns[this.declaredReturns.length - 1]);
     }));
@@ -8131,7 +8183,7 @@ var TypeAnalyzer = class {
       if (arg === void 0) return;
       const param = p.type.kind === "typeParam" && p.type.constraint ? { ...p.type, constraint: this.reduceType(p.type.constraint) } : p.type;
       const preserve = keepsLiterals(param) || param.kind !== "typeParam" && containsTypeParam(param);
-      unify(p.type, preserve ? arg : widen(arg), vars, subst);
+      unify(p.type, preserve ? arg : widen(arg), vars, subst, "first");
     });
     if (f.varargs && f.restIsWhole) {
       const rest = argTypes.slice(f.params.length).map((a) => a === void 0 ? unknownType : widen(a));
@@ -8482,7 +8534,12 @@ var TypeAnalyzer = class {
       asserts: node.asserts
     };
   }
-  inferFunctionBody(func, env) {
+  /** `visited`, when given, is what the real walk of the body just
+   *  collected from its `return`s: a function expression is walked before
+   *  its type is asked for, so there is nothing left to guess, and walking
+   *  the body a second time only to read them made every callback nested in
+   *  another cost twice its parent's. */
+  inferFunctionBody(func, env, visited) {
     const names = func.generics.map((g) => g.name);
     return this.withTypeParams(func.generics, () => {
       const params = func.params.flatMap((p) => {
@@ -8511,6 +8568,8 @@ var TypeAnalyzer = class {
         returns = this.resolveType(func.returnType);
       } else if (func.predicate) {
         returns = booleanType;
+      } else if (visited) {
+        returns = visited.length ? union([...visited]) : this.withVarargs(func, () => this.silently(() => this.inferReturnType(func.body, bodyEnv)));
       } else {
         const collected = [];
         returns = this.withVarargs(func, () => this.silently(() => {
@@ -9383,10 +9442,12 @@ var TypeAnalyzer = class {
         return this.inferArray(expr, env, false);
       case "TableExpression":
         return this.inferObject(expr, env, false);
-      case "FunctionExpression":
+      case "FunctionExpression": {
         this.checkParamOrder(expr.func.params, expr);
-        this.visitFunctionBody(expr.func, env);
-        return this.inferFunctionBody(expr.func, env);
+        const returned = [];
+        this.visitFunctionBody(expr.func, env, returned);
+        return this.inferFunctionBody(expr.func, env, returned);
+      }
       case "ParenthesizedExpression":
         return this.infer(expr.expression, env);
       case "TypeAssertionExpression": {
@@ -9590,9 +9651,7 @@ var TypeAnalyzer = class {
     const united = this.unionSignatures(callee);
     const fns = united ?? this.overloadsOf(callee);
     const explicit = this.explicitTypeArguments(expr, fns);
-    const expected = this.expectedArguments(expr.arguments, fns, () => 0);
-    expr.arguments.forEach((a, i) => this.applyContext(a, expected[i]));
-    const argTypes = expr.arguments.map((a) => this.infer(a, env));
+    const argTypes = this.inferArguments(expr.arguments, fns, () => 0, (_, args) => args, env);
     if (fns.length) {
       this.recordExpected(expr.arguments, fns, () => 0, () => argTypes);
       const spread = this.spreadOf(expr.arguments);
@@ -9657,9 +9716,13 @@ var TypeAnalyzer = class {
     const united = this.unionSignatures(method);
     const fns = united ?? this.overloadsOf(method);
     const explicit = this.explicitTypeArguments(expr, fns);
-    const expected = this.expectedArguments(expr.arguments, fns, (f) => this.takesSelf(f) ? 1 : 0);
-    expr.arguments.forEach((a, i) => this.applyContext(a, expected[i]));
-    const argTypes = expr.arguments.map((a) => this.infer(a, env));
+    const argTypes = this.inferArguments(
+      expr.arguments,
+      fns,
+      (f) => this.takesSelf(f) ? 1 : 0,
+      (f, args) => this.takesSelf(f) ? [objType, ...args] : args,
+      env
+    );
     if (fns.length) {
       const withSelf = (f) => this.takesSelf(f) ? [objType, ...argTypes] : argTypes;
       const selfOf = (f) => this.takesSelf(f) ? 1 : 0;

package/dist/index.d.cts

@@ -1377,7 +1377,15 @@ declare function tupleMembers(t: TupleType): Type[];
 declare function objectType(entries: Iterable<[string, ObjectProperty]>, indexer?: ObjectType["indexer"], frozen?: boolean): ObjectType;
 declare function fn(params: FunctionParam[], returns: Type, varargs?: Type, typeParams?: string[], predicate?: TypePredicate): FunctionType;
 declare function substitute(t: Type, subst: Map<string, Type>): Type;
-declare function unify(param: Type, arg: Type, vars: Set<string>, out: Map<string, Type>): void;
+/** How a type parameter takes a second candidate, at the top of a
+ *  parameter. Below it — a list's elements, a tuple's places — every
+ *  candidate is the same site and they gather, whichever mode was asked for. Arguments collected by
+ *  one `...rest: T[]` are all of them equally, so `firstOf(1, "a")` reads
+ *  `T` as their union. Two parameters written separately are not: the one
+ *  written first says what `T` is, and an argument that disagrees with it is
+ *  a mistake to report rather than a reason to widen. */
+type Unification = "union" | "first";
+declare function unify(param: Type, arg: Type, vars: Set<string>, out: Map<string, Type>, how?: Unification): void;
 declare function union(types: Type[]): Type;
 declare function intersection(types: Type[]): Type;
 /** `base - excluded`, simplified as far as the base allows. */
@@ -1818,4 +1826,4 @@ declare const tilua: {
     readonly analyzeTypes: typeof analyzeTypes;
 };
 
-export { type AnalyzeTypesOptions, type AnyType, type ArgumentInfo, type ArrayExpression, type ArrayPattern, type ArrayPatternElement, type ArrayType, type ArrayTypeNode, type AsConstExpression, type AssignmentStatement, type BaseNode, type BaseToken, type BinaryExpression, BinaryOperators, type Binding, type BindingId, type BindingKind, type BindingTarget, type Block, type BooleanLiteral, type BreakStatement, type BuildTarget, CONFIG_FILE_NAMES, type CallExpression, type CallLowering, type CallSite, type CallStatement, type ClassAccessibility, type ClassAccessor, type ClassConstructor, type ClassDeclaration, type ClassExpression, type ClassField, type ClassInfo, type ClassLike, type ClassMember, type ClassMethod, type CompoundAssignmentStatement, type ConditionalType, type ConditionalTypeNode, type ConfigLookup, type ConfigProblem, type ContinueStatement, type DeclareClassStatement, type DeclareStatement, type DifferenceType, type DifferenceTypeNode, type Directive, type DirectiveKind, type DirectiveOutcome, type Directives, type DoStatement, type EOFToken, type ErrorExpression, type ErrorStatement, type ExportAllStatement, type ExportDefaultStatement, type ExportNamedStatement, type ExportSpecifier, type ExportStatement, type ExportTypeAliasStatement, type ExportedType, type Expression, type ExpressionStatement, type FunctionBody, type FunctionDeclaration, type FunctionDeclarationStatement, type FunctionExpression, type FunctionName, type FunctionParam, type FunctionParameter, type FunctionSignature, type FunctionType, type FunctionTypeNode, type FunctionTypeParameter, type GenericForStatement, type GenericRefType, type GenericTypeParameter, type GlobalCall, type GlobalValue, type Identifier, type IdentifierPattern, type IdentifierToken, type IfClause, type IfElseExpression, type IfStatement, type ImportSpecifier, type ImportStatement, type IndexExpression, type IndexedAccessType, type IndexedAccessTypeNode, type InferType, type InferTypeNode, type InterpolatedStringExpression, type InterpolatedStringPart, type InterpolatedStringPart_Expression, type InterpolatedStringPart_String, type InterpolatedStringToken, type IntersectionType, type IntersectionTypeNode, type KeyofType, type KeyofTypeNode, type KeywordToken, Keywords, LANGUAGE_GLOBALS, LexError, type LiteralToken, type LiteralType, type LoweringModule, type LoweringPlugin, type MappedType, type MappedTypeNode, type MemberExpression, type MethodCall, type MethodCallExpression, type MethodLowering, type ModuleExports, type NeverType, type NilLiteral, type Node, type NumberLiteral, type NumericForStatement, type ObjectPattern, type ObjectPatternProperty, type ObjectProperty, type ObjectType, type OperatorToken, Operators, PRELUDE_SOURCE, type ParenthesizedExpression, type ParenthesizedTypeNode, ParseError, type ParserOptions, type PrimitiveName, type PrimitiveType, type Program, type ProjectHost, type PunctuatorToken, Punctuators, type RecoverResult, type RepeatStatement, type ReturnStatement, type SatisfiesExpression, type ScopeAnalysis, type ScopeDiagnostic, type SourceComment, type SourceMapNode, type SourceMapOptions, type SourceMapTypes, type SpreadElement, type Statement, type StringLiteral, type SuperExpression, type TableExpression, type TableField, type TableTypeNode, type TableTypeProperty, type TemplateLiteralType, type TemplateLiteralTypeNode, type TiluaConfig, type Token, type TokenizeOptions, type TupleType, type TupleTypeNode, type Type, type TypeAliasStatement, type TypeAnalysis, type TypeAssertionExpression, type TypeDiagnostic, type TypeLibraries, type TypeLiteralBoolean, type TypeLiteralNumber, type TypeLiteralString, type TypeNode, type TypeOrigin, type TypeParamType, type TypePredicate, type TypePredicateNode, type TypeReference, type TypedIdentifier, type TypeofTypeNode, UNUSED_EXPECT_ERROR, type UnaryExpression, UnaryOperators, type UnionType, type UnionTypeNode, type UnknownType, type VariableDeclaration, type WhileStatement, aliasNameOf, analyzeScopes, analyzeTypes, anyType, applyDirectives, arrayOf, booleanType, bufferType, containsTypeParam, declaredUnknownType, tilua as default, difference, directivesOf, equalTypes, falsyType, findConfig, fn, formatType, getBinding, intersection, isAssignable, isClassType, isGlobal, isPossiblyFalsy, isPossiblyTruthy, isUnassignedGlobal, literal, loadConfig, matchInfer, moduleCandidates, moduleExports, narrowExclude, narrowFalsy, narrowTo, narrowTruthy, neverType, nilType, nodeHost, numberType, objectType, optional, overlaps, parse, parseExpressionFromSource, parseTokens, parseWithRecovery, primitive, readDirectives, resolveModulePath, resolveTypeLibraries, setAliasExpander, setDeferredBound, sourceMapTypes, stringType, stripJsonComments, substitute, templateMatches, threadType, tilua, tokenize, tuple, tupleMembers, typeParam, unify, union, unknownType, widen, withAliasName, withoutAliasName };
+export { type AnalyzeTypesOptions, type AnyType, type ArgumentInfo, type ArrayExpression, type ArrayPattern, type ArrayPatternElement, type ArrayType, type ArrayTypeNode, type AsConstExpression, type AssignmentStatement, type BaseNode, type BaseToken, type BinaryExpression, BinaryOperators, type Binding, type BindingId, type BindingKind, type BindingTarget, type Block, type BooleanLiteral, type BreakStatement, type BuildTarget, CONFIG_FILE_NAMES, type CallExpression, type CallLowering, type CallSite, type CallStatement, type ClassAccessibility, type ClassAccessor, type ClassConstructor, type ClassDeclaration, type ClassExpression, type ClassField, type ClassInfo, type ClassLike, type ClassMember, type ClassMethod, type CompoundAssignmentStatement, type ConditionalType, type ConditionalTypeNode, type ConfigLookup, type ConfigProblem, type ContinueStatement, type DeclareClassStatement, type DeclareStatement, type DifferenceType, type DifferenceTypeNode, type Directive, type DirectiveKind, type DirectiveOutcome, type Directives, type DoStatement, type EOFToken, type ErrorExpression, type ErrorStatement, type ExportAllStatement, type ExportDefaultStatement, type ExportNamedStatement, type ExportSpecifier, type ExportStatement, type ExportTypeAliasStatement, type ExportedType, type Expression, type ExpressionStatement, type FunctionBody, type FunctionDeclaration, type FunctionDeclarationStatement, type FunctionExpression, type FunctionName, type FunctionParam, type FunctionParameter, type FunctionSignature, type FunctionType, type FunctionTypeNode, type FunctionTypeParameter, type GenericForStatement, type GenericRefType, type GenericTypeParameter, type GlobalCall, type GlobalValue, type Identifier, type IdentifierPattern, type IdentifierToken, type IfClause, type IfElseExpression, type IfStatement, type ImportSpecifier, type ImportStatement, type IndexExpression, type IndexedAccessType, type IndexedAccessTypeNode, type InferType, type InferTypeNode, type InterpolatedStringExpression, type InterpolatedStringPart, type InterpolatedStringPart_Expression, type InterpolatedStringPart_String, type InterpolatedStringToken, type IntersectionType, type IntersectionTypeNode, type KeyofType, type KeyofTypeNode, type KeywordToken, Keywords, LANGUAGE_GLOBALS, LexError, type LiteralToken, type LiteralType, type LoweringModule, type LoweringPlugin, type MappedType, type MappedTypeNode, type MemberExpression, type MethodCall, type MethodCallExpression, type MethodLowering, type ModuleExports, type NeverType, type NilLiteral, type Node, type NumberLiteral, type NumericForStatement, type ObjectPattern, type ObjectPatternProperty, type ObjectProperty, type ObjectType, type OperatorToken, Operators, PRELUDE_SOURCE, type ParenthesizedExpression, type ParenthesizedTypeNode, ParseError, type ParserOptions, type PrimitiveName, type PrimitiveType, type Program, type ProjectHost, type PunctuatorToken, Punctuators, type RecoverResult, type RepeatStatement, type ReturnStatement, type SatisfiesExpression, type ScopeAnalysis, type ScopeDiagnostic, type SourceComment, type SourceMapNode, type SourceMapOptions, type SourceMapTypes, type SpreadElement, type Statement, type StringLiteral, type SuperExpression, type TableExpression, type TableField, type TableTypeNode, type TableTypeProperty, type TemplateLiteralType, type TemplateLiteralTypeNode, type TiluaConfig, type Token, type TokenizeOptions, type TupleType, type TupleTypeNode, type Type, type TypeAliasStatement, type TypeAnalysis, type TypeAssertionExpression, type TypeDiagnostic, type TypeLibraries, type TypeLiteralBoolean, type TypeLiteralNumber, type TypeLiteralString, type TypeNode, type TypeOrigin, type TypeParamType, type TypePredicate, type TypePredicateNode, type TypeReference, type TypedIdentifier, type TypeofTypeNode, UNUSED_EXPECT_ERROR, type UnaryExpression, UnaryOperators, type Unification, type UnionType, type UnionTypeNode, type UnknownType, type VariableDeclaration, type WhileStatement, aliasNameOf, analyzeScopes, analyzeTypes, anyType, applyDirectives, arrayOf, booleanType, bufferType, containsTypeParam, declaredUnknownType, tilua as default, difference, directivesOf, equalTypes, falsyType, findConfig, fn, formatType, getBinding, intersection, isAssignable, isClassType, isGlobal, isPossiblyFalsy, isPossiblyTruthy, isUnassignedGlobal, literal, loadConfig, matchInfer, moduleCandidates, moduleExports, narrowExclude, narrowFalsy, narrowTo, narrowTruthy, neverType, nilType, nodeHost, numberType, objectType, optional, overlaps, parse, parseExpressionFromSource, parseTokens, parseWithRecovery, primitive, readDirectives, resolveModulePath, resolveTypeLibraries, setAliasExpander, setDeferredBound, sourceMapTypes, stringType, stripJsonComments, substitute, templateMatches, threadType, tilua, tokenize, tuple, tupleMembers, typeParam, unify, union, unknownType, widen, withAliasName, withoutAliasName };

package/dist/index.d.ts

@@ -1377,7 +1377,15 @@ declare function tupleMembers(t: TupleType): Type[];
 declare function objectType(entries: Iterable<[string, ObjectProperty]>, indexer?: ObjectType["indexer"], frozen?: boolean): ObjectType;
 declare function fn(params: FunctionParam[], returns: Type, varargs?: Type, typeParams?: string[], predicate?: TypePredicate): FunctionType;
 declare function substitute(t: Type, subst: Map<string, Type>): Type;
-declare function unify(param: Type, arg: Type, vars: Set<string>, out: Map<string, Type>): void;
+/** How a type parameter takes a second candidate, at the top of a
+ *  parameter. Below it — a list's elements, a tuple's places — every
+ *  candidate is the same site and they gather, whichever mode was asked for. Arguments collected by
+ *  one `...rest: T[]` are all of them equally, so `firstOf(1, "a")` reads
+ *  `T` as their union. Two parameters written separately are not: the one
+ *  written first says what `T` is, and an argument that disagrees with it is
+ *  a mistake to report rather than a reason to widen. */
+type Unification = "union" | "first";
+declare function unify(param: Type, arg: Type, vars: Set<string>, out: Map<string, Type>, how?: Unification): void;
 declare function union(types: Type[]): Type;
 declare function intersection(types: Type[]): Type;
 /** `base - excluded`, simplified as far as the base allows. */
@@ -1818,4 +1826,4 @@ declare const tilua: {
     readonly analyzeTypes: typeof analyzeTypes;
 };
 
-export { type AnalyzeTypesOptions, type AnyType, type ArgumentInfo, type ArrayExpression, type ArrayPattern, type ArrayPatternElement, type ArrayType, type ArrayTypeNode, type AsConstExpression, type AssignmentStatement, type BaseNode, type BaseToken, type BinaryExpression, BinaryOperators, type Binding, type BindingId, type BindingKind, type BindingTarget, type Block, type BooleanLiteral, type BreakStatement, type BuildTarget, CONFIG_FILE_NAMES, type CallExpression, type CallLowering, type CallSite, type CallStatement, type ClassAccessibility, type ClassAccessor, type ClassConstructor, type ClassDeclaration, type ClassExpression, type ClassField, type ClassInfo, type ClassLike, type ClassMember, type ClassMethod, type CompoundAssignmentStatement, type ConditionalType, type ConditionalTypeNode, type ConfigLookup, type ConfigProblem, type ContinueStatement, type DeclareClassStatement, type DeclareStatement, type DifferenceType, type DifferenceTypeNode, type Directive, type DirectiveKind, type DirectiveOutcome, type Directives, type DoStatement, type EOFToken, type ErrorExpression, type ErrorStatement, type ExportAllStatement, type ExportDefaultStatement, type ExportNamedStatement, type ExportSpecifier, type ExportStatement, type ExportTypeAliasStatement, type ExportedType, type Expression, type ExpressionStatement, type FunctionBody, type FunctionDeclaration, type FunctionDeclarationStatement, type FunctionExpression, type FunctionName, type FunctionParam, type FunctionParameter, type FunctionSignature, type FunctionType, type FunctionTypeNode, type FunctionTypeParameter, type GenericForStatement, type GenericRefType, type GenericTypeParameter, type GlobalCall, type GlobalValue, type Identifier, type IdentifierPattern, type IdentifierToken, type IfClause, type IfElseExpression, type IfStatement, type ImportSpecifier, type ImportStatement, type IndexExpression, type IndexedAccessType, type IndexedAccessTypeNode, type InferType, type InferTypeNode, type InterpolatedStringExpression, type InterpolatedStringPart, type InterpolatedStringPart_Expression, type InterpolatedStringPart_String, type InterpolatedStringToken, type IntersectionType, type IntersectionTypeNode, type KeyofType, type KeyofTypeNode, type KeywordToken, Keywords, LANGUAGE_GLOBALS, LexError, type LiteralToken, type LiteralType, type LoweringModule, type LoweringPlugin, type MappedType, type MappedTypeNode, type MemberExpression, type MethodCall, type MethodCallExpression, type MethodLowering, type ModuleExports, type NeverType, type NilLiteral, type Node, type NumberLiteral, type NumericForStatement, type ObjectPattern, type ObjectPatternProperty, type ObjectProperty, type ObjectType, type OperatorToken, Operators, PRELUDE_SOURCE, type ParenthesizedExpression, type ParenthesizedTypeNode, ParseError, type ParserOptions, type PrimitiveName, type PrimitiveType, type Program, type ProjectHost, type PunctuatorToken, Punctuators, type RecoverResult, type RepeatStatement, type ReturnStatement, type SatisfiesExpression, type ScopeAnalysis, type ScopeDiagnostic, type SourceComment, type SourceMapNode, type SourceMapOptions, type SourceMapTypes, type SpreadElement, type Statement, type StringLiteral, type SuperExpression, type TableExpression, type TableField, type TableTypeNode, type TableTypeProperty, type TemplateLiteralType, type TemplateLiteralTypeNode, type TiluaConfig, type Token, type TokenizeOptions, type TupleType, type TupleTypeNode, type Type, type TypeAliasStatement, type TypeAnalysis, type TypeAssertionExpression, type TypeDiagnostic, type TypeLibraries, type TypeLiteralBoolean, type TypeLiteralNumber, type TypeLiteralString, type TypeNode, type TypeOrigin, type TypeParamType, type TypePredicate, type TypePredicateNode, type TypeReference, type TypedIdentifier, type TypeofTypeNode, UNUSED_EXPECT_ERROR, type UnaryExpression, UnaryOperators, type UnionType, type UnionTypeNode, type UnknownType, type VariableDeclaration, type WhileStatement, aliasNameOf, analyzeScopes, analyzeTypes, anyType, applyDirectives, arrayOf, booleanType, bufferType, containsTypeParam, declaredUnknownType, tilua as default, difference, directivesOf, equalTypes, falsyType, findConfig, fn, formatType, getBinding, intersection, isAssignable, isClassType, isGlobal, isPossiblyFalsy, isPossiblyTruthy, isUnassignedGlobal, literal, loadConfig, matchInfer, moduleCandidates, moduleExports, narrowExclude, narrowFalsy, narrowTo, narrowTruthy, neverType, nilType, nodeHost, numberType, objectType, optional, overlaps, parse, parseExpressionFromSource, parseTokens, parseWithRecovery, primitive, readDirectives, resolveModulePath, resolveTypeLibraries, setAliasExpander, setDeferredBound, sourceMapTypes, stringType, stripJsonComments, substitute, templateMatches, threadType, tilua, tokenize, tuple, tupleMembers, typeParam, unify, union, unknownType, widen, withAliasName, withoutAliasName };
+export { type AnalyzeTypesOptions, type AnyType, type ArgumentInfo, type ArrayExpression, type ArrayPattern, type ArrayPatternElement, type ArrayType, type ArrayTypeNode, type AsConstExpression, type AssignmentStatement, type BaseNode, type BaseToken, type BinaryExpression, BinaryOperators, type Binding, type BindingId, type BindingKind, type BindingTarget, type Block, type BooleanLiteral, type BreakStatement, type BuildTarget, CONFIG_FILE_NAMES, type CallExpression, type CallLowering, type CallSite, type CallStatement, type ClassAccessibility, type ClassAccessor, type ClassConstructor, type ClassDeclaration, type ClassExpression, type ClassField, type ClassInfo, type ClassLike, type ClassMember, type ClassMethod, type CompoundAssignmentStatement, type ConditionalType, type ConditionalTypeNode, type ConfigLookup, type ConfigProblem, type ContinueStatement, type DeclareClassStatement, type DeclareStatement, type DifferenceType, type DifferenceTypeNode, type Directive, type DirectiveKind, type DirectiveOutcome, type Directives, type DoStatement, type EOFToken, type ErrorExpression, type ErrorStatement, type ExportAllStatement, type ExportDefaultStatement, type ExportNamedStatement, type ExportSpecifier, type ExportStatement, type ExportTypeAliasStatement, type ExportedType, type Expression, type ExpressionStatement, type FunctionBody, type FunctionDeclaration, type FunctionDeclarationStatement, type FunctionExpression, type FunctionName, type FunctionParam, type FunctionParameter, type FunctionSignature, type FunctionType, type FunctionTypeNode, type FunctionTypeParameter, type GenericForStatement, type GenericRefType, type GenericTypeParameter, type GlobalCall, type GlobalValue, type Identifier, type IdentifierPattern, type IdentifierToken, type IfClause, type IfElseExpression, type IfStatement, type ImportSpecifier, type ImportStatement, type IndexExpression, type IndexedAccessType, type IndexedAccessTypeNode, type InferType, type InferTypeNode, type InterpolatedStringExpression, type InterpolatedStringPart, type InterpolatedStringPart_Expression, type InterpolatedStringPart_String, type InterpolatedStringToken, type IntersectionType, type IntersectionTypeNode, type KeyofType, type KeyofTypeNode, type KeywordToken, Keywords, LANGUAGE_GLOBALS, LexError, type LiteralToken, type LiteralType, type LoweringModule, type LoweringPlugin, type MappedType, type MappedTypeNode, type MemberExpression, type MethodCall, type MethodCallExpression, type MethodLowering, type ModuleExports, type NeverType, type NilLiteral, type Node, type NumberLiteral, type NumericForStatement, type ObjectPattern, type ObjectPatternProperty, type ObjectProperty, type ObjectType, type OperatorToken, Operators, PRELUDE_SOURCE, type ParenthesizedExpression, type ParenthesizedTypeNode, ParseError, type ParserOptions, type PrimitiveName, type PrimitiveType, type Program, type ProjectHost, type PunctuatorToken, Punctuators, type RecoverResult, type RepeatStatement, type ReturnStatement, type SatisfiesExpression, type ScopeAnalysis, type ScopeDiagnostic, type SourceComment, type SourceMapNode, type SourceMapOptions, type SourceMapTypes, type SpreadElement, type Statement, type StringLiteral, type SuperExpression, type TableExpression, type TableField, type TableTypeNode, type TableTypeProperty, type TemplateLiteralType, type TemplateLiteralTypeNode, type TiluaConfig, type Token, type TokenizeOptions, type TupleType, type TupleTypeNode, type Type, type TypeAliasStatement, type TypeAnalysis, type TypeAssertionExpression, type TypeDiagnostic, type TypeLibraries, type TypeLiteralBoolean, type TypeLiteralNumber, type TypeLiteralString, type TypeNode, type TypeOrigin, type TypeParamType, type TypePredicate, type TypePredicateNode, type TypeReference, type TypedIdentifier, type TypeofTypeNode, UNUSED_EXPECT_ERROR, type UnaryExpression, UnaryOperators, type Unification, type UnionType, type UnionTypeNode, type UnknownType, type VariableDeclaration, type WhileStatement, aliasNameOf, analyzeScopes, analyzeTypes, anyType, applyDirectives, arrayOf, booleanType, bufferType, containsTypeParam, declaredUnknownType, tilua as default, difference, directivesOf, equalTypes, falsyType, findConfig, fn, formatType, getBinding, intersection, isAssignable, isClassType, isGlobal, isPossiblyFalsy, isPossiblyTruthy, isUnassignedGlobal, literal, loadConfig, matchInfer, moduleCandidates, moduleExports, narrowExclude, narrowFalsy, narrowTo, narrowTruthy, neverType, nilType, nodeHost, numberType, objectType, optional, overlaps, parse, parseExpressionFromSource, parseTokens, parseWithRecovery, primitive, readDirectives, resolveModulePath, resolveTypeLibraries, setAliasExpander, setDeferredBound, sourceMapTypes, stringType, stripJsonComments, substitute, templateMatches, threadType, tilua, tokenize, tuple, tupleMembers, typeParam, unify, union, unknownType, widen, withAliasName, withoutAliasName };

package/dist/index.js

@@ -4565,14 +4565,17 @@ function classArguments(t, name) {
   if (t.kind === "object") return t.class?.typeArguments?.get(name);
   return void 0;
 }
-function unify(param, arg, vars, out) {
+function unify(param, arg, vars, out, how = "union") {
   if (param.kind === "typeParam" && param.constraint && !vars.has(param.name)) {
-    unify(param.constraint, arg, vars, out);
+    unify(param.constraint, arg, vars, out, how);
     return;
   }
   if (param.kind === "typeParam" && vars.has(param.name)) {
     const prev = out.get(param.name);
-    out.set(param.name, prev ? union([prev, arg]) : arg);
+    if (!prev) out.set(param.name, arg);
+    else if (isAssignable(arg, prev)) {
+    } else if (isAssignable(prev, arg)) out.set(param.name, arg);
+    else if (how === "union") out.set(param.name, union([prev, arg]));
     return;
   }
   if (arg.kind === "any" || arg.kind === "never") return;
@@ -7757,8 +7760,10 @@ var TypeAnalyzer = class {
   // --------------------------------------------------------
   // Functions
   // --------------------------------------------------------
-  visitFunctionBody(func, outerEnv) {
-    this.withTypeParams(func.generics, () => this.visitFunctionBodyInner(func, outerEnv));
+  /** `returns`, when given, collects the type of each `return` the walk
+   *  reads — see `inferFunctionBody`. */
+  visitFunctionBody(func, outerEnv, returns) {
+    this.withTypeParams(func.generics, () => this.visitFunctionBodyInner(func, outerEnv, returns));
   }
   /** A parameter's type: annotation, else a shape synthesized from a
    *  destructuring pattern, else inferred from its default, else `any`. */
@@ -7807,6 +7812,53 @@ var TypeAnalyzer = class {
    *  it, as in TypeScript: `signal:Connect(function(player) ... end)` knows
    *  `player` from `Connect`'s callback type. Anything else is inferred as
    *  usual. */
+  /** The arguments of a call, in two passes where one is needed.
+   *
+   *  A function written at the call site with a parameter nothing annotates
+   *  reads that parameter from the signature — and where the signature says
+   *  `(v: T) => U`, `T` is only known once the other arguments have been
+   *  read. So such an argument is read once quietly, to get a shape to pick
+   *  a signature with, and then again with `T` in hand: `map(xs, v => v + 1)`
+   *  has its `v` a number by then, and `U` follows from what the body
+   *  answers. Everything else is read once, as it always was. */
+  inferArguments(written, fns, selfOf, extra, env) {
+    const expected = this.expectedArguments(written, fns, selfOf);
+    written.forEach((a, i) => this.applyContext(a, expected[i]));
+    const waits = written.map((a, i) => this.waitsOnInference(a, expected[i]));
+    if (!waits.some(Boolean)) return written.map((a) => this.infer(a, env));
+    const argTypes = written.map((a, i) => waits[i] ? this.quietly(() => this.infer(a, env)) : this.infer(a, env));
+    const picked = this.pickOverload(fns, argTypes, (f) => extra(f, argTypes), this.spreadOf(written, selfOf(fns[0])));
+    const subst = picked?.typeParams?.length ? this.inferTypeArgs(picked, extra(picked, argTypes)) : void 0;
+    written.forEach((a, i) => {
+      if (!waits[i]) return;
+      if (picked && subst) {
+        const self = selfOf(picked);
+        const declared = i + self < picked.params.length ? picked.params[i + self].type : picked.varargs;
+        if (declared) this.applyContext(a, this.reduceType(substitute(declared, subst)));
+      }
+      argTypes[i] = this.infer(a, env);
+    });
+    return argTypes;
+  }
+  /** Is this argument a function whose own type waits on the call's? */
+  waitsOnInference(arg, expected) {
+    if (!expected || !containsTypeParam(expected)) return false;
+    let e = arg;
+    while (e.type === "ParenthesizedExpression") e = e.expression;
+    if (e.type !== "FunctionExpression") return false;
+    return e.func.params.some((p) => !p.typeAnnotation && !p.default && !p.pattern && p.name !== "self" && p.name !== "this");
+  }
+  /** Read something without saying anything about it: a first pass whose
+   *  only purpose is a shape to go on. */
+  quietly(read) {
+    const was = this.emitDiagnostics;
+    this.emitDiagnostics = false;
+    try {
+      return read();
+    } finally {
+      this.emitDiagnostics = was;
+    }
+  }
   applyContext(expr, expected) {
     let e = expr;
     while (e.type === "ParenthesizedExpression") e = e.expression;
@@ -7955,7 +8007,7 @@ var TypeAnalyzer = class {
       this.contextualReturns.pop();
     }
   }
-  visitFunctionBodyInner(func, outerEnv) {
+  visitFunctionBodyInner(func, outerEnv, returns) {
     const env = forkEnv(outerEnv);
     for (const p of func.params) {
       if (p.pattern) {
@@ -7972,7 +8024,7 @@ var TypeAnalyzer = class {
         if (p.typeAnnotation) this.annotated.add(id);
       }
     }
-    this.withVarargs(func, () => this.collectReturns(void 0, () => {
+    this.withVarargs(func, () => this.collectReturns(returns, () => {
       this.visitBlock(func.body, env);
       this.checkReturnsAtAll(func, this.declaredReturns[this.declaredReturns.length - 1]);
     }));
@@ -8026,7 +8078,7 @@ var TypeAnalyzer = class {
       if (arg === void 0) return;
       const param = p.type.kind === "typeParam" && p.type.constraint ? { ...p.type, constraint: this.reduceType(p.type.constraint) } : p.type;
       const preserve = keepsLiterals(param) || param.kind !== "typeParam" && containsTypeParam(param);
-      unify(p.type, preserve ? arg : widen(arg), vars, subst);
+      unify(p.type, preserve ? arg : widen(arg), vars, subst, "first");
     });
     if (f.varargs && f.restIsWhole) {
       const rest = argTypes.slice(f.params.length).map((a) => a === void 0 ? unknownType : widen(a));
@@ -8377,7 +8429,12 @@ var TypeAnalyzer = class {
       asserts: node.asserts
     };
   }
-  inferFunctionBody(func, env) {
+  /** `visited`, when given, is what the real walk of the body just
+   *  collected from its `return`s: a function expression is walked before
+   *  its type is asked for, so there is nothing left to guess, and walking
+   *  the body a second time only to read them made every callback nested in
+   *  another cost twice its parent's. */
+  inferFunctionBody(func, env, visited) {
     const names = func.generics.map((g) => g.name);
     return this.withTypeParams(func.generics, () => {
       const params = func.params.flatMap((p) => {
@@ -8406,6 +8463,8 @@ var TypeAnalyzer = class {
         returns = this.resolveType(func.returnType);
       } else if (func.predicate) {
         returns = booleanType;
+      } else if (visited) {
+        returns = visited.length ? union([...visited]) : this.withVarargs(func, () => this.silently(() => this.inferReturnType(func.body, bodyEnv)));
       } else {
         const collected = [];
         returns = this.withVarargs(func, () => this.silently(() => {
@@ -9278,10 +9337,12 @@ var TypeAnalyzer = class {
         return this.inferArray(expr, env, false);
       case "TableExpression":
         return this.inferObject(expr, env, false);
-      case "FunctionExpression":
+      case "FunctionExpression": {
         this.checkParamOrder(expr.func.params, expr);
-        this.visitFunctionBody(expr.func, env);
-        return this.inferFunctionBody(expr.func, env);
+        const returned = [];
+        this.visitFunctionBody(expr.func, env, returned);
+        return this.inferFunctionBody(expr.func, env, returned);
+      }
       case "ParenthesizedExpression":
         return this.infer(expr.expression, env);
       case "TypeAssertionExpression": {
@@ -9485,9 +9546,7 @@ var TypeAnalyzer = class {
     const united = this.unionSignatures(callee);
     const fns = united ?? this.overloadsOf(callee);
     const explicit = this.explicitTypeArguments(expr, fns);
-    const expected = this.expectedArguments(expr.arguments, fns, () => 0);
-    expr.arguments.forEach((a, i) => this.applyContext(a, expected[i]));
-    const argTypes = expr.arguments.map((a) => this.infer(a, env));
+    const argTypes = this.inferArguments(expr.arguments, fns, () => 0, (_, args) => args, env);
     if (fns.length) {
       this.recordExpected(expr.arguments, fns, () => 0, () => argTypes);
       const spread = this.spreadOf(expr.arguments);
@@ -9552,9 +9611,13 @@ var TypeAnalyzer = class {
     const united = this.unionSignatures(method);
     const fns = united ?? this.overloadsOf(method);
     const explicit = this.explicitTypeArguments(expr, fns);
-    const expected = this.expectedArguments(expr.arguments, fns, (f) => this.takesSelf(f) ? 1 : 0);
-    expr.arguments.forEach((a, i) => this.applyContext(a, expected[i]));
-    const argTypes = expr.arguments.map((a) => this.infer(a, env));
+    const argTypes = this.inferArguments(
+      expr.arguments,
+      fns,
+      (f) => this.takesSelf(f) ? 1 : 0,
+      (f, args) => this.takesSelf(f) ? [objType, ...args] : args,
+      env
+    );
     if (fns.length) {
       const withSelf = (f) => this.takesSelf(f) ? [objType, ...argTypes] : argTypes;
       const selfOf = (f) => this.takesSelf(f) ? 1 : 0;

package/package.json

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