Remove union type support from analyzer.

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 11141 matching lines @@
       _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) {
-        _overrideManager.joinOverrides(perBranchOverrides);
-      } else {
-        _overrideManager.mergeOverrides(perBranchOverrides);
-      }
+      _overrideManager.mergeOverrides(perBranchOverrides);
     }
     return null;
   }
 
   @override
   Object visitLabel(Label node) => null;
 
   @override
   Object visitLibraryIdentifier(LibraryIdentifier node) => null;
 
@@ skipping 1717 matching lines @@
    * @return the overridden type of the given element
    */
   DartType getType(Element element) {
     if (_currentScope == null) {
       return null;
     }
     return _currentScope.getType(element);
   }
 
   /**
-   * Update overrides assuming `perBranchOverrides` is the collection of per-branch overrides
-   * for *all* branches flowing into a join point. If a variable is updated in each per-branch
-   * override, then its type before the branching is ignored. Otherwise, its type before the
-   * branching is merged with all updates in the branches.
-   *
-   * Although this method would do the right thing for a single set of overrides, we require there
-   * to be at least two override sets. Instead use `applyOverrides` for to apply a single set.
-   *
-   * For example, for the code
-   *
-   * <pre>
-   *   if (c) {
-   *     ...
-   *   } else {
-   *     ...
-   *   }
-   * </pre>
-   * the `perBranchOverrides` would include overrides for the then and else branches, and for
-   * the code
-   *
-   * <pre>
-   *   ...
-   *   while(c) {
-   *     ...
-   *   }
-   * </pre>
-   * the `perBranchOverrides` would include overrides for before the loop and for the loop
-   * body.
-   *
-   * @param perBranchOverrides one set of overrides for each (at least two) branch flowing into the
-   *          join point
-   */
-  void joinOverrides(List<Map<VariableElement, DartType>> perBranchOverrides) {
-    if (perBranchOverrides.length < 2) {
-      throw new IllegalArgumentException(
-          "There is no point in joining zero or one override sets.");
-    }
-    Set<VariableElement> allElements = new HashSet<VariableElement>();
-    Set<VariableElement> commonElements =
-        new HashSet<VariableElement>.from(perBranchOverrides[0].keys.toSet());
-    for (Map<VariableElement, DartType> os in perBranchOverrides) {
-      // Union: elements updated in some branch.
-      allElements.addAll(os.keys.toSet());
-      // Intersection: elements updated in all branches.
-      commonElements.retainAll(os.keys.toSet());
-    }
-    Set<VariableElement> uncommonElements = allElements;
-    // Difference: elements updated in some but not all branches.
-    uncommonElements.removeAll(commonElements);
-    Map<VariableElement, DartType> joinOverrides =
-        new HashMap<VariableElement, DartType>();
-    // The common elements were updated in all branches, so their type
-    // before branching can be ignored.
-    for (VariableElement e in commonElements) {
-      joinOverrides[e] = perBranchOverrides[0][e];
-      for (Map<VariableElement, DartType> os in perBranchOverrides) {
-        joinOverrides[e] = UnionTypeImpl.union([joinOverrides[e], os[e]]);
-      }
-    }
-    // The uncommon elements were updated in some but not all branches,
-    // so they may still have the type they had before branching.
-    for (VariableElement e in uncommonElements) {
-      joinOverrides[e] = getBestType(e);
-      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);
@@ skipping 2495 matching lines @@
     nonFields.add(node);
     return null;
   }
 
   @override
   Object visitNode(AstNode node) => node.accept(TypeResolverVisitor_this);
 
   @override
   Object visitWithClause(WithClause node) => null;
 }