Merge pull request microsoft#8556 from Microsoft/controlFlowLoopAnalysis

ahejlsberg · ahejlsberg · commit d68cd2042e4c · 2016-05-11T13:29:31.000-07:00
Fix control flow loop analysis issue
diff --git a/src/compiler/checker.ts b/src/compiler/checker.ts
@@ -7780,16 +7780,15 @@ namespace ts {
                     if (cache[key]) {
                         return cache[key];
                     }
-                    // If the type at a particular antecedent path is the declared type and the
-                    // reference is known to always be assigned (i.e. when declared and initial types
-                    // are the same), there is no reason to process more antecedents since the only
-                    // possible outcome is subtypes that will be removed in the final union type anyway.
-                    if (type === declaredType && declaredType === initialType) {
-                        return cache[key] = type;
-                    }
                     if (!contains(antecedentTypes, type)) {
                         antecedentTypes.push(type);
                     }
+                    // If the type at a particular antecedent path is the declared type there is no
+                    // reason to process more antecedents since the only possible outcome is subtypes
+                    // that will be removed in the final union type anyway.
+                    if (type === declaredType) {
+                        break;
+                    }
                 }
                 return cache[key] = getUnionType(antecedentTypes);
             }
diff --git a/tests/baselines/reference/controlFlowLoopAnalysis.errors.txt b/tests/baselines/reference/controlFlowLoopAnalysis.errors.txt
@@ -36,4 +36,23 @@ tests/cases/compiler/controlFlowLoopAnalysis.ts(13,25): error TS2345: Argument o
             }
         }
     }
+    
+    // Repro from #8511
+    
+    function mapUntilCant<a, b>(
+        values: a[],
+        canTake: (value: a, index: number) => boolean,
+        mapping: (value: a, index: number) => b
+    ): b[] {
+        let result: b[] = [];
+        for (let index = 0, length = values.length; index < length; index++) {
+            let value = values[index];
+            if (canTake(value, index)) {
+                result.push(mapping(value, index));
+            } else {
+                return result;
+            }
+        }
+        return result;
+    }
     
diff --git a/tests/baselines/reference/controlFlowLoopAnalysis.js b/tests/baselines/reference/controlFlowLoopAnalysis.js
@@ -29,6 +29,25 @@ function test2() {
         }
     }
 }
+
+// Repro from #8511
+
+function mapUntilCant<a, b>(
+    values: a[],
+    canTake: (value: a, index: number) => boolean,
+    mapping: (value: a, index: number) => b
+): b[] {
+    let result: b[] = [];
+    for (let index = 0, length = values.length; index < length; index++) {
+        let value = values[index];
+        if (canTake(value, index)) {
+            result.push(mapping(value, index));
+        } else {
+            return result;
+        }
+    }
+    return result;
+}
 
 
 //// [controlFlowLoopAnalysis.js]
@@ -56,3 +75,17 @@ function test2() {
         }
     }
 }
+// Repro from #8511
+function mapUntilCant(values, canTake, mapping) {
+    var result = [];
+    for (var index = 0, length = values.length; index < length; index++) {
+        var value = values[index];
+        if (canTake(value, index)) {
+            result.push(mapping(value, index));
+        }
+        else {
+            return result;
+        }
+    }
+    return result;
+}
diff --git a/tests/cases/compiler/controlFlowLoopAnalysis.ts b/tests/cases/compiler/controlFlowLoopAnalysis.ts
@@ -1,4 +1,5 @@
 // @strictNullChecks: true
+// @noImplicitAny: true
 
 // Repro from #8418
 
@@ -29,3 +30,22 @@ function test2() {
         }
     }
 }
+
+// Repro from #8511
+
+function mapUntilCant<a, b>(
+    values: a[],
+    canTake: (value: a, index: number) => boolean,
+    mapping: (value: a, index: number) => b
+): b[] {
+    let result: b[] = [];
+    for (let index = 0, length = values.length; index < length; index++) {
+        let value = values[index];
+        if (canTake(value, index)) {
+            result.push(mapping(value, index));
+        } else {
+            return result;
+        }
+    }
+    return result;
+}

Original file line number	Diff line number	Diff line change
`@@ -7780,16 +7780,15 @@ namespace ts {`
`7780`	`7780`	`if (cache[key]) {`
`7781`	`7781`	`return cache[key];`
`7782`	`7782`	`}`
`7783`		`- // If the type at a particular antecedent path is the declared type and the`
`7784`		`- // reference is known to always be assigned (i.e. when declared and initial types`
`7785`		`- // are the same), there is no reason to process more antecedents since the only`
`7786`		`- // possible outcome is subtypes that will be removed in the final union type anyway.`
`7787`		`- if (type === declaredType && declaredType === initialType) {`
`7788`		`- return cache[key] = type;`
`7789`		`- }`
`7790`	`7783`	`if (!contains(antecedentTypes, type)) {`
`7791`	`7784`	`antecedentTypes.push(type);`
`7792`	`7785`	`}`
	`7786`	`+ // If the type at a particular antecedent path is the declared type there is no`
	`7787`	`+ // reason to process more antecedents since the only possible outcome is subtypes`
	`7788`	`+ // that will be removed in the final union type anyway.`
	`7789`	`+ if (type === declaredType) {`
	`7790`	`+ break;`
	`7791`	`+ }`
`7793`	`7792`	`}`
`7794`	`7793`	`return cache[key] = getUnionType(antecedentTypes);`
`7795`	`7794`	`}`