Merge pull request #30334 from Microsoft/inferenceContextCleanup

Revise InferenceContext implementation

Author: ahejlsberg

src/compiler/checker.ts

@@ -630,7 +630,7 @@ namespace ts {
         /* @internal */ flowNode?: FlowNode;                  // Associated FlowNode (initialized by binding)
         /* @internal */ emitNode?: EmitNode;                  // Associated EmitNode (initialized by transforms)
         /* @internal */ contextualType?: Type;                // Used to temporarily assign a contextual type during overload resolution
-        /* @internal */ contextualMapper?: TypeMapper;        // Mapper for contextual type
+        /* @internal */ inferenceContext?: InferenceContext;  // Inference context for contextual type
     }
 
     export interface JSDocContainer {
@@ -4423,8 +4423,7 @@ namespace ts {
         None            =      0,  // No special inference behaviors
         NoDefault       = 1 << 0,  // Infer unknownType for no inferences (otherwise anyType or emptyObjectType)
         AnyDefault      = 1 << 1,  // Infer anyType for no inferences (otherwise emptyObjectType)
-        NoFixing        = 1 << 2,  // Disable type parameter fixing
-        SkippedGenericFunction = 1 << 3,
+        SkippedGenericFunction = 1 << 2, // A generic function was skipped during inference
     }
 
     /**
@@ -4447,14 +4446,15 @@ namespace ts {
     export type TypeComparer = (s: Type, t: Type, reportErrors?: boolean) => Ternary;
 
     /* @internal */
-    export interface InferenceContext extends TypeMapper {
-        typeParameters: ReadonlyArray<TypeParameter>; // Type parameters for which inferences are made
-        signature?: Signature;                        // Generic signature for which inferences are made (if any)
+    export interface InferenceContext {
         inferences: InferenceInfo[];                  // Inferences made for each type parameter
+        signature?: Signature;                        // Generic signature for which inferences are made (if any)
         flags: InferenceFlags;                        // Inference flags
         compareTypes: TypeComparer;                   // Type comparer function
+        mapper: TypeMapper;                           // Mapper that fixes inferences
+        nonFixingMapper: TypeMapper;                  // Mapper that doesn't fix inferences
         returnMapper?: TypeMapper;                    // Type mapper for inferences from return types (if any)
-        inferredTypeParameters?: ReadonlyArray<TypeParameter>;
+        inferredTypeParameters?: ReadonlyArray<TypeParameter>; // Inferred type parameters for function result
     }
 
     /* @internal */

src/compiler/types.ts

@@ -190,4 +190,12 @@ tests/cases/compiler/genericFunctionInference1.ts(83,14): error TS2345: Argument
         x => x,
         x => first(x),
     );
+    
+    // Repro from #30297
+    
+    declare function foo2<T, U = T>(fn: T, a?: U, b?: U): [T, U];
+    
+    foo2(() => {});
+    foo2(identity);
+    foo2(identity, 1);
 

tests/baselines/reference/genericFunctionInference1.errors.txt

@@ -183,6 +183,14 @@ const fn62 = pipe(
     x => x,
     x => first(x),
 );
+
+// Repro from #30297
+
+declare function foo2<T, U = T>(fn: T, a?: U, b?: U): [T, U];
+
+foo2(() => {});
+foo2(identity);
+foo2(identity, 1);
 
 
 //// [genericFunctionInference1.js]
@@ -265,3 +273,6 @@ const fn40 = pipe(getString, string => orUndefined(string), identity);
 const fn60 = pipe(getArray, x => x, first);
 const fn61 = pipe(getArray, identity, first);
 const fn62 = pipe(getArray, x => x, x => first(x));
+foo2(() => { });
+foo2(identity);
+foo2(identity, 1);

tests/baselines/reference/genericFunctionInference1.js

@@ -848,3 +848,30 @@ const fn62 = pipe(
 
 );
 
+// Repro from #30297
+
+declare function foo2<T, U = T>(fn: T, a?: U, b?: U): [T, U];
+>foo2 : Symbol(foo2, Decl(genericFunctionInference1.ts, 183, 2))
+>T : Symbol(T, Decl(genericFunctionInference1.ts, 187, 22))
+>U : Symbol(U, Decl(genericFunctionInference1.ts, 187, 24))
+>T : Symbol(T, Decl(genericFunctionInference1.ts, 187, 22))
+>fn : Symbol(fn, Decl(genericFunctionInference1.ts, 187, 32))
+>T : Symbol(T, Decl(genericFunctionInference1.ts, 187, 22))
+>a : Symbol(a, Decl(genericFunctionInference1.ts, 187, 38))
+>U : Symbol(U, Decl(genericFunctionInference1.ts, 187, 24))
+>b : Symbol(b, Decl(genericFunctionInference1.ts, 187, 45))
+>U : Symbol(U, Decl(genericFunctionInference1.ts, 187, 24))
+>T : Symbol(T, Decl(genericFunctionInference1.ts, 187, 22))
+>U : Symbol(U, Decl(genericFunctionInference1.ts, 187, 24))
+
+foo2(() => {});
+>foo2 : Symbol(foo2, Decl(genericFunctionInference1.ts, 183, 2))
+
+foo2(identity);
+>foo2 : Symbol(foo2, Decl(genericFunctionInference1.ts, 183, 2))
+>identity : Symbol(identity, Decl(genericFunctionInference1.ts, 154, 13))
+
+foo2(identity, 1);
+>foo2 : Symbol(foo2, Decl(genericFunctionInference1.ts, 183, 2))
+>identity : Symbol(identity, Decl(genericFunctionInference1.ts, 154, 13))
+

tests/baselines/reference/genericFunctionInference1.symbols

@@ -799,3 +799,27 @@ const fn62 = pipe(
 
 );
 
+// Repro from #30297
+
+declare function foo2<T, U = T>(fn: T, a?: U, b?: U): [T, U];
+>foo2 : <T, U = T>(fn: T, a?: U | undefined, b?: U | undefined) => [T, U]
+>fn : T
+>a : U | undefined
+>b : U | undefined
+
+foo2(() => {});
+>foo2(() => {}) : [() => void, () => void]
+>foo2 : <T, U = T>(fn: T, a?: U | undefined, b?: U | undefined) => [T, U]
+>() => {} : () => void
+
+foo2(identity);
+>foo2(identity) : [<T>(value: T) => T, {}]
+>foo2 : <T, U = T>(fn: T, a?: U | undefined, b?: U | undefined) => [T, U]
+>identity : <T>(value: T) => T
+
+foo2(identity, 1);
+>foo2(identity, 1) : [<T>(value: T) => T, number]
+>foo2 : <T, U = T>(fn: T, a?: U | undefined, b?: U | undefined) => [T, U]
+>identity : <T>(value: T) => T
+>1 : 1
+

tests/baselines/reference/genericFunctionInference1.types

@@ -185,3 +185,11 @@ const fn62 = pipe(
     x => x,
     x => first(x),
 );
+
+// Repro from #30297
+
+declare function foo2<T, U = T>(fn: T, a?: U, b?: U): [T, U];
+
+foo2(() => {});
+foo2(identity);
+foo2(identity, 1);