Use a better way to compute InterfaceTypes least upper bound.

pkg/analyzer/lib/src/generated/element.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.
 
 // This code was auto-generated, is not intended to be edited, and is subject to
 // significant change. Please see the README file for more information.
 
 library engine.element;
 
 import 'dart:collection';
 import 'java_core.dart';
 import 'java_engine.dart';
 import 'utilities_collection.dart';
 import 'source.dart';
 import 'scanner.dart' show Keyword;
 import 'ast.dart';
 import 'sdk.dart' show DartSdk;
 import 'html.dart' show XmlAttributeNode, XmlTagNode;
 import 'engine.dart' show AnalysisContext, AnalysisEngine, AnalysisException;
 import 'constant.dart' show EvaluationResultImpl;
 import 'resolver.dart';
 import 'utilities_dart.dart';
+import 'element.dart';
 
 /**
  * Information about Angular application.
  */
 class AngularApplication {
   final Source entryPoint;
 
   final Set<Source> _librarySources;
 
   final List<AngularElement> elements;
@@ skipping 6666 matching lines @@
 
   /**
    * Return the type resulting from substituting the given arguments for this
    * type's parameters. This is fully equivalent to `substitute2(argumentTypes,
    * getTypeArguments())`.
    */
   InterfaceType substitute4(List<DartType> argumentTypes);
 
   @override
   InterfaceType substitute2(List<DartType> argumentTypes, List<DartType> parameterTypes);
+
+  /**
+   * Returns a "smart" version of the "least upper bound" of the given types.
+   *
+   * If these types have the same element and differ only in terms of the type
+   * arguments, attempts to find a compatible set of type arguments.
+   *
+   * Otherwise, calls [DartType.getLeastUpperBound].
+   */
+  static InterfaceType getSmartLeastUpperBound(InterfaceType first,
+                                               InterfaceType second) {
+    if (first.element == second.element) {
+      return _leastUpperBound(first, second);
+    }
+    return first.getLeastUpperBound(second);
+  }
+
+  /**
+   * Return the "least upper bound" of the given types under the assumption that
+   * the types have the same element and differ only in terms of the type
+   * arguments.
+   *
+   * The resulting type is composed by comparing the corresponding type
+   * arguments, keeping those that are the same, and using 'dynamic' for those
+   * that are different.
+   */
+  static InterfaceType _leastUpperBound(InterfaceType firstType,
+                                        InterfaceType secondType) {
+    ClassElement firstElement = firstType.element;
+    ClassElement secondElement = secondType.element;
+    if (firstElement != secondElement) {
+      throw new IllegalArgumentException('The same elements expected, but '
+          '$firstElement and $secondElement are given.');
+    }
+    if (firstType == secondType) {
+      return firstType;
+    }
+    List<DartType> firstArguments = firstType.typeArguments;
+    List<DartType> secondArguments = secondType.typeArguments;
+    int argumentCount = firstArguments.length;
+    if (argumentCount == 0) {
+      return firstType;
+    }
+    List<DartType> lubArguments = new List<DartType>(argumentCount);
+    for (int i = 0; i < argumentCount; i++) {
+      //
+      // Ideally we would take the least upper bound of the two argument types,
+      // but this can cause an infinite recursion (such as when finding the
+      // least upper bound of String and num).
+      //
+      if (firstArguments[i] == secondArguments[i]) {
+        lubArguments[i] = firstArguments[i];
+      }
+      if (lubArguments[i] == null) {
+        lubArguments[i] = DynamicTypeImpl.instance;
+      }
+    }
+    InterfaceTypeImpl lub = new InterfaceTypeImpl.con1(firstElement);
+    lub.typeArguments = lubArguments;
+    return lub;
+  }
 }
 
 /**
  * Instances of the class `InterfaceTypeImpl` defines the behavior common to objects
  * representing the type introduced by either a class or an interface, or a reference to such a
  * type.
  */
 class InterfaceTypeImpl extends TypeImpl implements InterfaceType {
   /**
    * This method computes the longest inheritance path from some passed [Type] to Object.
@@ skipping 5038 matching lines @@
     if (type is UnionType) {
       return (type as UnionTypeImpl).internalUnionTypeIsSuperTypeOf(this, visitedTypePairs);
     }
     // The only subtype relations that pertain to void are therefore:
     // void <: void (by reflexivity)
     // bottom <: void (as bottom is a subtype of all types).
     // void <: dynamic (as dynamic is a supertype of all types)
     return identical(type, this) || type.isDynamic;
   }
 }