Issue 20144. Reset propagated type if one of the 'if' branches changes it to a different one.

pkg/analyzer/lib/src/generated/resolver.dart

 // Copyright (c) 2014, the Dart project authors.  Please see the AUTHORS file
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 
 library engine.resolver;
 
 import "dart:math" as math;
 import 'dart:collection';
 
 import 'package:analyzer/src/generated/utilities_collection.dart';
@@ skipping 10951 matching lines @@
     // Join overrides.
     bool thenIsAbrupt = _isAbruptTerminationStatement(thenStatement);
     bool elseIsAbrupt = _isAbruptTerminationStatement(elseStatement);
     if (elseIsAbrupt && !thenIsAbrupt) {
       _propagateTrueState(condition);
       _overrideManager.applyOverrides(thenOverrides);
     } else if (thenIsAbrupt && !elseIsAbrupt) {
       _propagateFalseState(condition);
       _overrideManager.applyOverrides(elseOverrides);
     } else if (!thenIsAbrupt && !elseIsAbrupt) {
+      List<Map<VariableElement, DartType>> perBranchOverrides =
+          new List<Map<VariableElement, DartType>>();
+      perBranchOverrides.add(thenOverrides);
+      perBranchOverrides.add(elseOverrides);
       if (AnalysisEngine.instance.enableUnionTypes) {
-        List<Map<VariableElement, DartType>> perBranchOverrides =
-            new List<Map<VariableElement, DartType>>();
-        perBranchOverrides.add(thenOverrides);
-        perBranchOverrides.add(elseOverrides);
         _overrideManager.joinOverrides(perBranchOverrides);
+      } else {
+        _overrideManager.mergeOverrides(perBranchOverrides);
       }
     }
     return null;
   }
 
   @override
   Object visitLabel(Label node) => null;
 
   @override
   Object visitLibraryIdentifier(LibraryIdentifier node) => null;
@@ skipping 1781 matching lines @@
       for (Map<VariableElement, DartType> os in perBranchOverrides) {
         if (os.containsKey(e)) {
           joinOverrides[e] = UnionTypeImpl.union([joinOverrides[e], os[e]]);
         }
       }
     }
     applyOverrides(joinOverrides);
   }
 
   /**
+   * Update overrides assuming [perBranchOverrides] is the collection of
+   * per-branch overrides for *all* branches flowing into a join point.
+   *
+   * If a variable type in any of branches is not the same as its type before
+   * the branching, then its propagated type is reset to `null`.
+   */
+  void mergeOverrides(List<Map<VariableElement, DartType>> perBranchOverrides) {
+    for (Map<VariableElement, DartType> branch in perBranchOverrides) {
+      branch.forEach((VariableElement variable, DartType branchType) {
+        DartType currentType = _currentScope.getType(variable);
+        if (currentType != branchType) {
+          _currentScope.resetType(variable);
+        }
+      });
+    }
+  }
+
+  /**
    * Set the overridden type of the given element to the given type
    *
    * @param element the element whose type might have been overridden
    * @param type the overridden type of the given element
    */
   void setType(VariableElement element, DartType type) {
     if (_currentScope == null) {
       throw new IllegalStateException("Cannot override without a scope");
     }
     _currentScope.setType(element, type);
@@ skipping 66 matching lines @@
   }
 
   /**
    * Return the overridden type of the given element, or `null` if the type of the element
    * has not been overridden.
    *
    * @param element the element whose type might have been overridden
    * @return the overridden type of the given element
    */
   DartType getType(Element element) {
+    if (element is PropertyAccessorElement) {
+      element = (element as PropertyAccessorElement).variable;
+    }
     DartType type = _overridenTypes[element];
-    if (type == null && element is PropertyAccessorElement) {
-      type = _overridenTypes[element.variable];
+    if (_overridenTypes.containsKey(element)) {
+      return type;
     }
     if (type != null) {
       return type;
     } else if (_outerScope != null) {
       return _outerScope.getType(element);
     }
     return null;
   }
 
   /**
+   * Clears the overridden type of the given [element].
+   */
+  void resetType(VariableElement element) {
+    _overridenTypes[element] = null;
+  }
+
+  /**
    * Set the overridden type of the given element to the given type
    *
    * @param element the element whose type might have been overridden
    * @param type the overridden type of the given element
    */
   void setType(VariableElement element, DartType type) {
     _overridenTypes[element] = type;
   }
 }
 
@@ skipping 2487 matching lines @@
   }
 
   bool isCatchException(LocalVariableElement element) {
     return catchExceptionElements.contains(element);
   }
 
   bool isCatchStackTrace(LocalVariableElement element) {
     return catchStackTraceElements.contains(element);
   }
 }