Merge pull request #32362 from microsoft/fix32230

ahejlsberg · web-flow · commit 303297aa27e1 · 2019-07-12T16:57:34.000-07:00
Fix type parameter inference cache invalidation logic
diff --git a/src/compiler/checker.ts b/src/compiler/checker.ts
@@ -15266,15 +15266,23 @@ namespace ts {
                 const inference = inferences[i];
                 if (t === inference.typeParameter) {
                     if (fix && !inference.isFixed) {
+                        clearCachedInferences(inferences);
                         inference.isFixed = true;
-                        inference.inferredType = undefined;
                     }
                     return getInferredType(context, i);
                 }
             }
             return t;
         }
 
+        function clearCachedInferences(inferences: InferenceInfo[]) {
+            for (const inference of inferences) {
+                if (!inference.isFixed) {
+                    inference.inferredType = undefined;
+                }
+            }
+        }
+
         function createInferenceInfo(typeParameter: TypeParameter): InferenceInfo {
             return {
                 typeParameter,
@@ -15554,17 +15562,17 @@ namespace ts {
                                 if (contravariant && !bivariant) {
                                     if (!contains(inference.contraCandidates, candidate)) {
                                         inference.contraCandidates = append(inference.contraCandidates, candidate);
-                                        inference.inferredType = undefined;
+                                        clearCachedInferences(inferences);
                                     }
                                 }
                                 else if (!contains(inference.candidates, candidate)) {
                                     inference.candidates = append(inference.candidates, candidate);
-                                    inference.inferredType = undefined;
+                                    clearCachedInferences(inferences);
                                 }
                             }
                             if (!(priority & InferencePriority.ReturnType) && target.flags & TypeFlags.TypeParameter && inference.topLevel && !isTypeParameterAtTopLevel(originalTarget, <TypeParameter>target)) {
                                 inference.topLevel = false;
-                                inference.inferredType = undefined;
+                                clearCachedInferences(inferences);
                             }
                         }
                         return;
diff --git a/tests/baselines/reference/typeInferenceCacheInvalidation.js b/tests/baselines/reference/typeInferenceCacheInvalidation.js
@@ -0,0 +1,37 @@
+//// [typeInferenceCacheInvalidation.ts]
+// Repro from #32230
+
+type Callback<TFoo, TBar> = (foo: TFoo, bar: TBar) => any
+
+declare function example<TFoo, TBar, TCallback extends Callback<TFoo, TBar>>(
+    foo: TFoo,
+    callback: TCallback,
+    bar: TBar,
+): TCallback
+
+example(42, (foo, bar) => ({
+    t: () => {
+        let s: string = bar;
+    }
+}), '42');
+
+example(42, (foo, bar) => ({
+    t() {
+        let s: string = bar;
+    }
+}), '42');
+
+
+//// [typeInferenceCacheInvalidation.js]
+"use strict";
+// Repro from #32230
+example(42, function (foo, bar) { return ({
+    t: function () {
+        var s = bar;
+    }
+}); }, '42');
+example(42, function (foo, bar) { return ({
+    t: function () {
+        var s = bar;
+    }
+}); }, '42');
diff --git a/tests/baselines/reference/typeInferenceCacheInvalidation.symbols b/tests/baselines/reference/typeInferenceCacheInvalidation.symbols
@@ -0,0 +1,64 @@
+=== tests/cases/compiler/typeInferenceCacheInvalidation.ts ===
+// Repro from #32230
+
+type Callback<TFoo, TBar> = (foo: TFoo, bar: TBar) => any
+>Callback : Symbol(Callback, Decl(typeInferenceCacheInvalidation.ts, 0, 0))
+>TFoo : Symbol(TFoo, Decl(typeInferenceCacheInvalidation.ts, 2, 14))
+>TBar : Symbol(TBar, Decl(typeInferenceCacheInvalidation.ts, 2, 19))
+>foo : Symbol(foo, Decl(typeInferenceCacheInvalidation.ts, 2, 29))
+>TFoo : Symbol(TFoo, Decl(typeInferenceCacheInvalidation.ts, 2, 14))
+>bar : Symbol(bar, Decl(typeInferenceCacheInvalidation.ts, 2, 39))
+>TBar : Symbol(TBar, Decl(typeInferenceCacheInvalidation.ts, 2, 19))
+
+declare function example<TFoo, TBar, TCallback extends Callback<TFoo, TBar>>(
+>example : Symbol(example, Decl(typeInferenceCacheInvalidation.ts, 2, 57))
+>TFoo : Symbol(TFoo, Decl(typeInferenceCacheInvalidation.ts, 4, 25))
+>TBar : Symbol(TBar, Decl(typeInferenceCacheInvalidation.ts, 4, 30))
+>TCallback : Symbol(TCallback, Decl(typeInferenceCacheInvalidation.ts, 4, 36))
+>Callback : Symbol(Callback, Decl(typeInferenceCacheInvalidation.ts, 0, 0))
+>TFoo : Symbol(TFoo, Decl(typeInferenceCacheInvalidation.ts, 4, 25))
+>TBar : Symbol(TBar, Decl(typeInferenceCacheInvalidation.ts, 4, 30))
+
+    foo: TFoo,
+>foo : Symbol(foo, Decl(typeInferenceCacheInvalidation.ts, 4, 77))
+>TFoo : Symbol(TFoo, Decl(typeInferenceCacheInvalidation.ts, 4, 25))
+
+    callback: TCallback,
+>callback : Symbol(callback, Decl(typeInferenceCacheInvalidation.ts, 5, 14))
+>TCallback : Symbol(TCallback, Decl(typeInferenceCacheInvalidation.ts, 4, 36))
+
+    bar: TBar,
+>bar : Symbol(bar, Decl(typeInferenceCacheInvalidation.ts, 6, 24))
+>TBar : Symbol(TBar, Decl(typeInferenceCacheInvalidation.ts, 4, 30))
+
+): TCallback
+>TCallback : Symbol(TCallback, Decl(typeInferenceCacheInvalidation.ts, 4, 36))
+
+example(42, (foo, bar) => ({
+>example : Symbol(example, Decl(typeInferenceCacheInvalidation.ts, 2, 57))
+>foo : Symbol(foo, Decl(typeInferenceCacheInvalidation.ts, 10, 13))
+>bar : Symbol(bar, Decl(typeInferenceCacheInvalidation.ts, 10, 17))
+
+    t: () => {
+>t : Symbol(t, Decl(typeInferenceCacheInvalidation.ts, 10, 28))
+
+        let s: string = bar;
+>s : Symbol(s, Decl(typeInferenceCacheInvalidation.ts, 12, 11))
+>bar : Symbol(bar, Decl(typeInferenceCacheInvalidation.ts, 10, 17))
+    }
+}), '42');
+
+example(42, (foo, bar) => ({
+>example : Symbol(example, Decl(typeInferenceCacheInvalidation.ts, 2, 57))
+>foo : Symbol(foo, Decl(typeInferenceCacheInvalidation.ts, 16, 13))
+>bar : Symbol(bar, Decl(typeInferenceCacheInvalidation.ts, 16, 17))
+
+    t() {
+>t : Symbol(t, Decl(typeInferenceCacheInvalidation.ts, 16, 28))
+
+        let s: string = bar;
+>s : Symbol(s, Decl(typeInferenceCacheInvalidation.ts, 18, 11))
+>bar : Symbol(bar, Decl(typeInferenceCacheInvalidation.ts, 16, 17))
+    }
+}), '42');
+
diff --git a/tests/baselines/reference/typeInferenceCacheInvalidation.types b/tests/baselines/reference/typeInferenceCacheInvalidation.types
@@ -0,0 +1,63 @@
+=== tests/cases/compiler/typeInferenceCacheInvalidation.ts ===
+// Repro from #32230
+
+type Callback<TFoo, TBar> = (foo: TFoo, bar: TBar) => any
+>Callback : Callback<TFoo, TBar>
+>foo : TFoo
+>bar : TBar
+
+declare function example<TFoo, TBar, TCallback extends Callback<TFoo, TBar>>(
+>example : <TFoo, TBar, TCallback extends Callback<TFoo, TBar>>(foo: TFoo, callback: TCallback, bar: TBar) => TCallback
+
+    foo: TFoo,
+>foo : TFoo
+
+    callback: TCallback,
+>callback : TCallback
+
+    bar: TBar,
+>bar : TBar
+
+): TCallback
+
+example(42, (foo, bar) => ({
+>example(42, (foo, bar) => ({    t: () => {        let s: string = bar;    }}), '42') : (foo: number, bar: string) => { t: () => void; }
+>example : <TFoo, TBar, TCallback extends Callback<TFoo, TBar>>(foo: TFoo, callback: TCallback, bar: TBar) => TCallback
+>42 : 42
+>(foo, bar) => ({    t: () => {        let s: string = bar;    }}) : (foo: number, bar: string) => { t: () => void; }
+>foo : number
+>bar : string
+>({    t: () => {        let s: string = bar;    }}) : { t: () => void; }
+>{    t: () => {        let s: string = bar;    }} : { t: () => void; }
+
+    t: () => {
+>t : () => void
+>() => {        let s: string = bar;    } : () => void
+
+        let s: string = bar;
+>s : string
+>bar : string
+    }
+}), '42');
+>'42' : "42"
+
+example(42, (foo, bar) => ({
+>example(42, (foo, bar) => ({    t() {        let s: string = bar;    }}), '42') : (foo: number, bar: string) => { t(): void; }
+>example : <TFoo, TBar, TCallback extends Callback<TFoo, TBar>>(foo: TFoo, callback: TCallback, bar: TBar) => TCallback
+>42 : 42
+>(foo, bar) => ({    t() {        let s: string = bar;    }}) : (foo: number, bar: string) => { t(): void; }
+>foo : number
+>bar : string
+>({    t() {        let s: string = bar;    }}) : { t(): void; }
+>{    t() {        let s: string = bar;    }} : { t(): void; }
+
+    t() {
+>t : () => void
+
+        let s: string = bar;
+>s : string
+>bar : string
+    }
+}), '42');
+>'42' : "42"
+
diff --git a/tests/cases/compiler/typeInferenceCacheInvalidation.ts b/tests/cases/compiler/typeInferenceCacheInvalidation.ts
@@ -0,0 +1,23 @@
+// @strict: true
+
+// Repro from #32230
+
+type Callback<TFoo, TBar> = (foo: TFoo, bar: TBar) => any
+
+declare function example<TFoo, TBar, TCallback extends Callback<TFoo, TBar>>(
+    foo: TFoo,
+    callback: TCallback,
+    bar: TBar,
+): TCallback
+
+example(42, (foo, bar) => ({
+    t: () => {
+        let s: string = bar;
+    }
+}), '42');
+
+example(42, (foo, bar) => ({
+    t() {
+        let s: string = bar;
+    }
+}), '42');

Original file line number	Diff line number	Diff line change
`@@ -15266,15 +15266,23 @@ namespace ts {`
`15266`	`15266`	`const inference = inferences[i];`
`15267`	`15267`	`if (t === inference.typeParameter) {`
`15268`	`15268`	`if (fix && !inference.isFixed) {`
	`15269`	`+ clearCachedInferences(inferences);`
`15269`	`15270`	`inference.isFixed = true;`
`15270`		`- inference.inferredType = undefined;`
`15271`	`15271`	`}`
`15272`	`15272`	`return getInferredType(context, i);`
`15273`	`15273`	`}`
`15274`	`15274`	`}`
`15275`	`15275`	`return t;`
`15276`	`15276`	`}`
`15277`	`15277`
	`15278`	`+ function clearCachedInferences(inferences: InferenceInfo[]) {`
	`15279`	`+ for (const inference of inferences) {`
	`15280`	`+ if (!inference.isFixed) {`
	`15281`	`+ inference.inferredType = undefined;`
	`15282`	`+ }`
	`15283`	`+ }`
	`15284`	`+ }`
	`15285`	`+`
`15278`	`15286`	`function createInferenceInfo(typeParameter: TypeParameter): InferenceInfo {`
`15279`	`15287`	`return {`
`15280`	`15288`	`typeParameter,`
`@@ -15554,17 +15562,17 @@ namespace ts {`
`15554`	`15562`	`if (contravariant && !bivariant) {`
`15555`	`15563`	`if (!contains(inference.contraCandidates, candidate)) {`
`15556`	`15564`	`inference.contraCandidates = append(inference.contraCandidates, candidate);`
`15557`		`- inference.inferredType = undefined;`
	`15565`	`+ clearCachedInferences(inferences);`
`15558`	`15566`	`}`
`15559`	`15567`	`}`
`15560`	`15568`	`else if (!contains(inference.candidates, candidate)) {`
`15561`	`15569`	`inference.candidates = append(inference.candidates, candidate);`
`15562`		`- inference.inferredType = undefined;`
	`15570`	`+ clearCachedInferences(inferences);`
`15563`	`15571`	`}`
`15564`	`15572`	`}`
`15565`	`15573`	`if (!(priority & InferencePriority.ReturnType) && target.flags & TypeFlags.TypeParameter && inference.topLevel && !isTypeParameterAtTopLevel(originalTarget, <TypeParameter>target)) {`
`15566`	`15574`	`inference.topLevel = false;`
`15567`		`- inference.inferredType = undefined;`
	`15575`	`+ clearCachedInferences(inferences);`
`15568`	`15576`	`}`
`15569`	`15577`	`}`
`15570`	`15578`	`return;`