From b75a90e95ab619a8874737a1bce136284b963e11 Mon Sep 17 00:00:00 2001 From: Anders Hejlsberg Date: Tue, 28 May 2019 16:32:10 -0700 Subject: [PATCH 1/4] Return type inference should not include parameter inferences --- src/compiler/checker.ts | 15 ++++++--------- 1 file changed, 6 insertions(+), 9 deletions(-) diff --git a/src/compiler/checker.ts b/src/compiler/checker.ts index 5091f5f030..e83137b87e 100644 --- a/src/compiler/checker.ts +++ b/src/compiler/checker.ts @@ -14864,13 +14864,6 @@ namespace ts { return context && createInferenceContextWorker(map(context.inferences, cloneInferenceInfo), context.signature, context.flags | extraFlags, context.compareTypes); } - function cloneInferredPartOfContext(context: InferenceContext): InferenceContext | undefined { - const inferences = filter(context.inferences, hasInferenceCandidates); - return inferences.length ? - createInferenceContextWorker(map(inferences, cloneInferenceInfo), context.signature, context.flags, context.compareTypes) : - undefined; - } - function createInferenceContextWorker(inferences: InferenceInfo[], signature: Signature | undefined, flags: InferenceFlags, compareTypes: TypeComparer): InferenceContext { const context: InferenceContext = { inferences, @@ -20846,7 +20839,8 @@ namespace ts { // We clone the inference context to avoid disturbing a resolution in progress for an // outer call expression. Effectively we just want a snapshot of whatever has been // inferred for any outer call expression so far. - const outerMapper = getMapperFromContext(cloneInferenceContext(getInferenceContext(node), InferenceFlags.NoDefault)); + const outerContext = getInferenceContext(node); + const outerMapper = getMapperFromContext(cloneInferenceContext(outerContext, InferenceFlags.NoDefault)); const instantiatedType = instantiateType(contextualType, outerMapper); // If the contextual type is a generic function type with a single call signature, we // instantiate the type with its own type parameters and type arguments. This ensures that @@ -20864,7 +20858,10 @@ namespace ts { inferTypes(context.inferences, inferenceSourceType, inferenceTargetType, InferencePriority.ReturnType); // Create a type mapper for instantiating generic contextual types using the inferences made // from the return type. - context.returnMapper = getMapperFromContext(cloneInferredPartOfContext(context)); + const returnContext = createInferenceContext(signature.typeParameters!, signature, context.flags); + const returnSourceType = instantiateType(contextualType, outerContext && outerContext.returnMapper); + inferTypes(returnContext.inferences, returnSourceType, inferenceTargetType); + context.returnMapper = some(returnContext.inferences, hasInferenceCandidates) ? getMapperFromContext(returnContext) : undefined; } } From 2b36fdd08b9a2618ad8531904d9c19ecbb503a2c Mon Sep 17 00:00:00 2001 From: Anders Hejlsberg Date: Thu, 30 May 2019 14:40:03 -0700 Subject: [PATCH 2/4] Add regression tests --- .../inferFromGenericFunctionReturnTypes3.ts | 19 +++++++++++++++++++ 1 file changed, 19 insertions(+) diff --git a/tests/cases/compiler/inferFromGenericFunctionReturnTypes3.ts b/tests/cases/compiler/inferFromGenericFunctionReturnTypes3.ts index 429d98b6a3..d14111c7a7 100644 --- a/tests/cases/compiler/inferFromGenericFunctionReturnTypes3.ts +++ b/tests/cases/compiler/inferFromGenericFunctionReturnTypes3.ts @@ -182,3 +182,22 @@ enum State { A, B } type Foo = { state: State } declare function bar(f: () => T[]): T[]; let x: Foo[] = bar(() => !!true ? [{ state: State.A }] : [{ state: State.B }]); // Error + +// Repros from #31443 + +enum Enum { A, B } + +class ClassWithConvert { + constructor(val: T) { } + convert(converter: { to: (v: T) => T; }) { } +} + +function fn(arg: ClassWithConvert, f: () => ClassWithConvert) { } +fn(new ClassWithConvert(Enum.A), () => new ClassWithConvert(Enum.A)); + +type Func = (x: T) => T; + +declare function makeFoo(x: T): Func; +declare function baz(x: Func, y: Func): void; + +baz(makeFoo(Enum.A), makeFoo(Enum.A)); From c3ef035b022b64c692aa9b3c8e691a269a68fc32 Mon Sep 17 00:00:00 2001 From: Anders Hejlsberg Date: Thu, 30 May 2019 14:40:09 -0700 Subject: [PATCH 3/4] Accept new baselines --- ...FromGenericFunctionReturnTypes3.errors.txt | 19 +++++ .../inferFromGenericFunctionReturnTypes3.js | 32 ++++++++ ...ferFromGenericFunctionReturnTypes3.symbols | 81 +++++++++++++++++++ ...inferFromGenericFunctionReturnTypes3.types | 67 +++++++++++++++ 4 files changed, 199 insertions(+) diff --git a/tests/baselines/reference/inferFromGenericFunctionReturnTypes3.errors.txt b/tests/baselines/reference/inferFromGenericFunctionReturnTypes3.errors.txt index 7c79c63f78..aea21ac250 100644 --- a/tests/baselines/reference/inferFromGenericFunctionReturnTypes3.errors.txt +++ b/tests/baselines/reference/inferFromGenericFunctionReturnTypes3.errors.txt @@ -200,4 +200,23 @@ tests/cases/compiler/inferFromGenericFunctionReturnTypes3.ts(180,26): error TS23 !!! error TS2322: Types of property 'state' are incompatible. !!! error TS2322: Type 'State.B' is not assignable to type 'State.A'. !!! related TS6502 tests/cases/compiler/inferFromGenericFunctionReturnTypes3.ts:179:28: The expected type comes from the return type of this signature. + + // Repros from #31443 + + enum Enum { A, B } + + class ClassWithConvert { + constructor(val: T) { } + convert(converter: { to: (v: T) => T; }) { } + } + + function fn(arg: ClassWithConvert, f: () => ClassWithConvert) { } + fn(new ClassWithConvert(Enum.A), () => new ClassWithConvert(Enum.A)); + + type Func = (x: T) => T; + + declare function makeFoo(x: T): Func; + declare function baz(x: Func, y: Func): void; + + baz(makeFoo(Enum.A), makeFoo(Enum.A)); \ No newline at end of file diff --git a/tests/baselines/reference/inferFromGenericFunctionReturnTypes3.js b/tests/baselines/reference/inferFromGenericFunctionReturnTypes3.js index 99070e6ddc..b6a2e890b1 100644 --- a/tests/baselines/reference/inferFromGenericFunctionReturnTypes3.js +++ b/tests/baselines/reference/inferFromGenericFunctionReturnTypes3.js @@ -179,6 +179,25 @@ enum State { A, B } type Foo = { state: State } declare function bar(f: () => T[]): T[]; let x: Foo[] = bar(() => !!true ? [{ state: State.A }] : [{ state: State.B }]); // Error + +// Repros from #31443 + +enum Enum { A, B } + +class ClassWithConvert { + constructor(val: T) { } + convert(converter: { to: (v: T) => T; }) { } +} + +function fn(arg: ClassWithConvert, f: () => ClassWithConvert) { } +fn(new ClassWithConvert(Enum.A), () => new ClassWithConvert(Enum.A)); + +type Func = (x: T) => T; + +declare function makeFoo(x: T): Func; +declare function baz(x: Func, y: Func): void; + +baz(makeFoo(Enum.A), makeFoo(Enum.A)); //// [inferFromGenericFunctionReturnTypes3.js] @@ -278,6 +297,19 @@ var State; State[State["B"] = 1] = "B"; })(State || (State = {})); let x = bar(() => !!true ? [{ state: State.A }] : [{ state: State.B }]); // Error +// Repros from #31443 +var Enum; +(function (Enum) { + Enum[Enum["A"] = 0] = "A"; + Enum[Enum["B"] = 1] = "B"; +})(Enum || (Enum = {})); +class ClassWithConvert { + constructor(val) { } + convert(converter) { } +} +function fn(arg, f) { } +fn(new ClassWithConvert(Enum.A), () => new ClassWithConvert(Enum.A)); +baz(makeFoo(Enum.A), makeFoo(Enum.A)); //// [inferFromGenericFunctionReturnTypes3.d.ts] diff --git a/tests/baselines/reference/inferFromGenericFunctionReturnTypes3.symbols b/tests/baselines/reference/inferFromGenericFunctionReturnTypes3.symbols index f89421cde0..ecf867a2bf 100644 --- a/tests/baselines/reference/inferFromGenericFunctionReturnTypes3.symbols +++ b/tests/baselines/reference/inferFromGenericFunctionReturnTypes3.symbols @@ -459,3 +459,84 @@ let x: Foo[] = bar(() => !!true ? [{ state: State.A }] : [{ state: State.B }]); >State : Symbol(State, Decl(inferFromGenericFunctionReturnTypes3.ts, 174, 56)) >B : Symbol(State.B, Decl(inferFromGenericFunctionReturnTypes3.ts, 176, 15)) +// Repros from #31443 + +enum Enum { A, B } +>Enum : Symbol(Enum, Decl(inferFromGenericFunctionReturnTypes3.ts, 179, 79)) +>A : Symbol(Enum.A, Decl(inferFromGenericFunctionReturnTypes3.ts, 183, 11)) +>B : Symbol(Enum.B, Decl(inferFromGenericFunctionReturnTypes3.ts, 183, 14)) + +class ClassWithConvert { +>ClassWithConvert : Symbol(ClassWithConvert, Decl(inferFromGenericFunctionReturnTypes3.ts, 183, 18)) +>T : Symbol(T, Decl(inferFromGenericFunctionReturnTypes3.ts, 185, 23)) + + constructor(val: T) { } +>val : Symbol(val, Decl(inferFromGenericFunctionReturnTypes3.ts, 186, 14)) +>T : Symbol(T, Decl(inferFromGenericFunctionReturnTypes3.ts, 185, 23)) + + convert(converter: { to: (v: T) => T; }) { } +>convert : Symbol(ClassWithConvert.convert, Decl(inferFromGenericFunctionReturnTypes3.ts, 186, 25)) +>converter : Symbol(converter, Decl(inferFromGenericFunctionReturnTypes3.ts, 187, 10)) +>to : Symbol(to, Decl(inferFromGenericFunctionReturnTypes3.ts, 187, 22)) +>v : Symbol(v, Decl(inferFromGenericFunctionReturnTypes3.ts, 187, 28)) +>T : Symbol(T, Decl(inferFromGenericFunctionReturnTypes3.ts, 185, 23)) +>T : Symbol(T, Decl(inferFromGenericFunctionReturnTypes3.ts, 185, 23)) +} + +function fn(arg: ClassWithConvert, f: () => ClassWithConvert) { } +>fn : Symbol(fn, Decl(inferFromGenericFunctionReturnTypes3.ts, 188, 1)) +>T : Symbol(T, Decl(inferFromGenericFunctionReturnTypes3.ts, 190, 12)) +>arg : Symbol(arg, Decl(inferFromGenericFunctionReturnTypes3.ts, 190, 15)) +>ClassWithConvert : Symbol(ClassWithConvert, Decl(inferFromGenericFunctionReturnTypes3.ts, 183, 18)) +>T : Symbol(T, Decl(inferFromGenericFunctionReturnTypes3.ts, 190, 12)) +>f : Symbol(f, Decl(inferFromGenericFunctionReturnTypes3.ts, 190, 40)) +>ClassWithConvert : Symbol(ClassWithConvert, Decl(inferFromGenericFunctionReturnTypes3.ts, 183, 18)) +>T : Symbol(T, Decl(inferFromGenericFunctionReturnTypes3.ts, 190, 12)) + +fn(new ClassWithConvert(Enum.A), () => new ClassWithConvert(Enum.A)); +>fn : Symbol(fn, Decl(inferFromGenericFunctionReturnTypes3.ts, 188, 1)) +>ClassWithConvert : Symbol(ClassWithConvert, Decl(inferFromGenericFunctionReturnTypes3.ts, 183, 18)) +>Enum.A : Symbol(Enum.A, Decl(inferFromGenericFunctionReturnTypes3.ts, 183, 11)) +>Enum : Symbol(Enum, Decl(inferFromGenericFunctionReturnTypes3.ts, 179, 79)) +>A : Symbol(Enum.A, Decl(inferFromGenericFunctionReturnTypes3.ts, 183, 11)) +>ClassWithConvert : Symbol(ClassWithConvert, Decl(inferFromGenericFunctionReturnTypes3.ts, 183, 18)) +>Enum.A : Symbol(Enum.A, Decl(inferFromGenericFunctionReturnTypes3.ts, 183, 11)) +>Enum : Symbol(Enum, Decl(inferFromGenericFunctionReturnTypes3.ts, 179, 79)) +>A : Symbol(Enum.A, Decl(inferFromGenericFunctionReturnTypes3.ts, 183, 11)) + +type Func = (x: T) => T; +>Func : Symbol(Func, Decl(inferFromGenericFunctionReturnTypes3.ts, 191, 69)) +>T : Symbol(T, Decl(inferFromGenericFunctionReturnTypes3.ts, 193, 10)) +>x : Symbol(x, Decl(inferFromGenericFunctionReturnTypes3.ts, 193, 16)) +>T : Symbol(T, Decl(inferFromGenericFunctionReturnTypes3.ts, 193, 10)) +>T : Symbol(T, Decl(inferFromGenericFunctionReturnTypes3.ts, 193, 10)) + +declare function makeFoo(x: T): Func; +>makeFoo : Symbol(makeFoo, Decl(inferFromGenericFunctionReturnTypes3.ts, 193, 27)) +>T : Symbol(T, Decl(inferFromGenericFunctionReturnTypes3.ts, 195, 25)) +>x : Symbol(x, Decl(inferFromGenericFunctionReturnTypes3.ts, 195, 28)) +>T : Symbol(T, Decl(inferFromGenericFunctionReturnTypes3.ts, 195, 25)) +>Func : Symbol(Func, Decl(inferFromGenericFunctionReturnTypes3.ts, 191, 69)) +>T : Symbol(T, Decl(inferFromGenericFunctionReturnTypes3.ts, 195, 25)) + +declare function baz(x: Func, y: Func): void; +>baz : Symbol(baz, Decl(inferFromGenericFunctionReturnTypes3.ts, 195, 43)) +>U : Symbol(U, Decl(inferFromGenericFunctionReturnTypes3.ts, 196, 21)) +>x : Symbol(x, Decl(inferFromGenericFunctionReturnTypes3.ts, 196, 24)) +>Func : Symbol(Func, Decl(inferFromGenericFunctionReturnTypes3.ts, 191, 69)) +>U : Symbol(U, Decl(inferFromGenericFunctionReturnTypes3.ts, 196, 21)) +>y : Symbol(y, Decl(inferFromGenericFunctionReturnTypes3.ts, 196, 35)) +>Func : Symbol(Func, Decl(inferFromGenericFunctionReturnTypes3.ts, 191, 69)) +>U : Symbol(U, Decl(inferFromGenericFunctionReturnTypes3.ts, 196, 21)) + +baz(makeFoo(Enum.A), makeFoo(Enum.A)); +>baz : Symbol(baz, Decl(inferFromGenericFunctionReturnTypes3.ts, 195, 43)) +>makeFoo : Symbol(makeFoo, Decl(inferFromGenericFunctionReturnTypes3.ts, 193, 27)) +>Enum.A : Symbol(Enum.A, Decl(inferFromGenericFunctionReturnTypes3.ts, 183, 11)) +>Enum : Symbol(Enum, Decl(inferFromGenericFunctionReturnTypes3.ts, 179, 79)) +>A : Symbol(Enum.A, Decl(inferFromGenericFunctionReturnTypes3.ts, 183, 11)) +>makeFoo : Symbol(makeFoo, Decl(inferFromGenericFunctionReturnTypes3.ts, 193, 27)) +>Enum.A : Symbol(Enum.A, Decl(inferFromGenericFunctionReturnTypes3.ts, 183, 11)) +>Enum : Symbol(Enum, Decl(inferFromGenericFunctionReturnTypes3.ts, 179, 79)) +>A : Symbol(Enum.A, Decl(inferFromGenericFunctionReturnTypes3.ts, 183, 11)) + diff --git a/tests/baselines/reference/inferFromGenericFunctionReturnTypes3.types b/tests/baselines/reference/inferFromGenericFunctionReturnTypes3.types index fd83694a17..4c56070fd3 100644 --- a/tests/baselines/reference/inferFromGenericFunctionReturnTypes3.types +++ b/tests/baselines/reference/inferFromGenericFunctionReturnTypes3.types @@ -506,3 +506,70 @@ let x: Foo[] = bar(() => !!true ? [{ state: State.A }] : [{ state: State.B }]); >State : typeof State >B : State.B +// Repros from #31443 + +enum Enum { A, B } +>Enum : Enum +>A : Enum.A +>B : Enum.B + +class ClassWithConvert { +>ClassWithConvert : ClassWithConvert + + constructor(val: T) { } +>val : T + + convert(converter: { to: (v: T) => T; }) { } +>convert : (converter: { to: (v: T) => T; }) => void +>converter : { to: (v: T) => T; } +>to : (v: T) => T +>v : T +} + +function fn(arg: ClassWithConvert, f: () => ClassWithConvert) { } +>fn : (arg: ClassWithConvert, f: () => ClassWithConvert) => void +>arg : ClassWithConvert +>f : () => ClassWithConvert + +fn(new ClassWithConvert(Enum.A), () => new ClassWithConvert(Enum.A)); +>fn(new ClassWithConvert(Enum.A), () => new ClassWithConvert(Enum.A)) : void +>fn : (arg: ClassWithConvert, f: () => ClassWithConvert) => void +>new ClassWithConvert(Enum.A) : ClassWithConvert +>ClassWithConvert : typeof ClassWithConvert +>Enum.A : Enum.A +>Enum : typeof Enum +>A : Enum.A +>() => new ClassWithConvert(Enum.A) : () => ClassWithConvert +>new ClassWithConvert(Enum.A) : ClassWithConvert +>ClassWithConvert : typeof ClassWithConvert +>Enum.A : Enum.A +>Enum : typeof Enum +>A : Enum.A + +type Func = (x: T) => T; +>Func : Func +>x : T + +declare function makeFoo(x: T): Func; +>makeFoo : (x: T) => Func +>x : T + +declare function baz(x: Func, y: Func): void; +>baz : (x: Func, y: Func) => void +>x : Func +>y : Func + +baz(makeFoo(Enum.A), makeFoo(Enum.A)); +>baz(makeFoo(Enum.A), makeFoo(Enum.A)) : void +>baz : (x: Func, y: Func) => void +>makeFoo(Enum.A) : Func +>makeFoo : (x: T) => Func +>Enum.A : Enum.A +>Enum : typeof Enum +>A : Enum.A +>makeFoo(Enum.A) : Func +>makeFoo : (x: T) => Func +>Enum.A : Enum.A +>Enum : typeof Enum +>A : Enum.A + From 08d8f97bb45697812df434411469c19c80e789ed Mon Sep 17 00:00:00 2001 From: Anders Hejlsberg Date: Thu, 30 May 2019 16:06:49 -0700 Subject: [PATCH 4/4] Add comment --- src/compiler/checker.ts | 4 +++- 1 file changed, 3 insertions(+), 1 deletion(-) diff --git a/src/compiler/checker.ts b/src/compiler/checker.ts index e83137b87e..4558a284f3 100644 --- a/src/compiler/checker.ts +++ b/src/compiler/checker.ts @@ -20857,7 +20857,9 @@ namespace ts { // Inferences made from return types have lower priority than all other inferences. inferTypes(context.inferences, inferenceSourceType, inferenceTargetType, InferencePriority.ReturnType); // Create a type mapper for instantiating generic contextual types using the inferences made - // from the return type. + // from the return type. We need a separate inference pass here because (a) instantiation of + // the source type uses the outer context's return mapper (which excludes inferences made from + // outer arguments), and (b) we don't want any further inferences going into this context. const returnContext = createInferenceContext(signature.typeParameters!, signature, context.flags); const returnSourceType = instantiateType(contextualType, outerContext && outerContext.returnMapper); inferTypes(returnContext.inferences, returnSourceType, inferenceTargetType);