New analyzer snapshot.

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';
@@ skipping 5487 matching lines @@
   }
 
   @override
   bool internalIsMoreSpecificThan(DartType type, bool withDynamic, Set<TypeImpl_TypePair> visitedTypePairs) {
     // trivial base cases
     if (type == null) {
       return false;
     } else if (identical(this, type) || type.isDynamic || type.isDartCoreFunction || type.isObject) {
       return true;
     } else if (type is UnionType) {
-      return (type as UnionTypeImpl).internalUnionTypeIsMoreSpecificThan(this, withDynamic, visitedTypePairs);
+      return (type as UnionTypeImpl).internalUnionTypeIsLessSpecificThan(this, withDynamic, visitedTypePairs);
     } else if (type is! FunctionType) {
       return false;
     } else if (this == type) {
       return true;
     }
     FunctionType t = this;
     FunctionType s = type as FunctionType;
     List<DartType> tTypes = t.normalParameterTypes;
     List<DartType> tOpTypes = t.optionalParameterTypes;
     List<DartType> sTypes = s.normalParameterTypes;
@@ skipping 1752 matching lines @@
   @override
   bool internalIsMoreSpecificThan(DartType type, bool withDynamic, Set<TypeImpl_TypePair> visitedTypePairs) {
     //
     // S is dynamic.
     // The test to determine whether S is dynamic is done here because dynamic is not an instance of
     // InterfaceType.
     //
     if (identical(type, DynamicTypeImpl.instance)) {
       return true;
     } else if (type is UnionType) {
-      return (type as UnionTypeImpl).internalUnionTypeIsMoreSpecificThan(this, withDynamic, visitedTypePairs);
+      return (type as UnionTypeImpl).internalUnionTypeIsLessSpecificThan(this, withDynamic, visitedTypePairs);
     } else if (type is! InterfaceType) {
       return false;
     }
     return _isMoreSpecificThan(type as InterfaceType, new HashSet<ClassElement>(), withDynamic, visitedTypePairs);
   }
 
   @override
   bool internalIsSubtypeOf(DartType type, Set<TypeImpl_TypePair> visitedTypePairs) {
     //
     // T is a subtype of S, written T <: S, iff [bottom/dynamic]T << S
@@ skipping 3443 matching lines @@
    * or <i>S</i> <: <i>T</i> (Interface Types section of spec).
    *
    * The given set of pairs of types (T1, T2), where each pair indicates that we invoked this method
    * because we are in the process of answering the question of whether T1 is a subtype of T2, is
    * used to prevent infinite loops.
    *
    * @param type the type being compared with this type
    * @param visitedTypePairs the set of pairs of types used to prevent infinite loops
    * @return `true` if this type is assignable to the given type
    */
-  bool isAssignableTo2(DartType type, Set<TypeImpl_TypePair> visitedTypePairs) => isSubtypeOf2(type, visitedTypePairs) || (type as TypeImpl).isSubtypeOf2(this, visitedTypePairs);
+  bool isAssignableTo2(DartType type, Set<TypeImpl_TypePair> visitedTypePairs) {
+    // Strictness matters for union types on the LHS, but not for union types
+    // on the RHS.
+    if (this is UnionType) {
+      if (AnalysisEngine.instance.strictUnionTypes) {
+        // *Every* element on the LHS must be assignable to the RHS. We recursively fall into
+        // the next case when the RHS is also a union: the order here is important!
+        for (DartType left in (this as UnionType).elements) {
+          // Would have to cast to [TypeImpl] to call the [visitedTypePairs] version here.
+          if (!left.isAssignableTo(type)) {
+            return false;
+          }
+        }
+        return true;
+      } else {
+        // *Some* element on the LHS must be assignable to the RHS.
+        for (DartType left in (this as UnionType).elements) {
+          // Would have to cast to [TypeImpl] to call the [visitedTypePairs] version here.
+          if (left.isAssignableTo(type)) {
+            return true;
+          }
+        }
+        return false;
+      }
+    } else if (type is UnionType) {
+      // The LHS, which is not a union, must be assignable to *some* element on the RHS.
+      for (DartType right in type.elements) {
+        if (this.isAssignableTo2(right, visitedTypePairs)) {
+          return true;
+        }
+      }
+      return false;
+    } else {
+      // For non union types we use the language spec definition of [<=>].
+      return isSubtypeOf2(type, visitedTypePairs) || (type as TypeImpl).isSubtypeOf2(this, visitedTypePairs);
+    }
+  }
 
   @override
   bool get isBottom => false;
 
   @override
   bool get isDartCoreFunction => false;
 
   @override
   bool get isDynamic => false;
 
@@ skipping 445 matching lines @@
     }
     builder.append("}");
   }
 
   @override
   bool internalEquals(Object object, Set<ElementPair> visitedElementPairs) => this == object;
 
   @override
   bool internalIsMoreSpecificThan(DartType type, bool withDynamic, Set<TypeImpl_TypePair> visitedTypePairs) {
     // What version of subtyping do we want? See discussion below in [internalIsSubtypeOf].
-    //
-    // The more unsound version: any.
-    for (DartType t in _types) {
-      if ((t as TypeImpl).internalIsMoreSpecificThan(type, withDynamic, visitedTypePairs)) {
-        return true;
+    if (AnalysisEngine.instance.strictUnionTypes) {
+      // The less unsound version: all.
+      for (DartType t in _types) {
+        if (!(t as TypeImpl).internalIsMoreSpecificThan(type, withDynamic, visitedTypePairs)) {
+          return false;
+        }
       }
+      return true;
+    } else {
+      // The more unsound version: any.
+      for (DartType t in _types) {
+        if ((t as TypeImpl).internalIsMoreSpecificThan(type, withDynamic, visitedTypePairs)) {
+          return true;
+        }
+      }
+      return false;
     }
-    return false;
   }
 
   @override
   bool internalIsSubtypeOf(DartType type, Set<TypeImpl_TypePair> visitedTypePairs) {
-    // The more unsound version: any.
-    for (DartType t in _types) {
-      if ((t as TypeImpl).internalIsSubtypeOf(type, visitedTypePairs)) {
-        return true;
+    if (AnalysisEngine.instance.strictUnionTypes) {
+      // The less unsound version: all.
+      //
+      // For this version to make sense we also need to redefine assignment compatibility [<=>].
+      // See discussion above.
+      for (DartType t in _types) {
+        if (!(t as TypeImpl).internalIsSubtypeOf(type, visitedTypePairs)) {
+          return false;
+        }
       }
+      return true;
+    } else {
+      // The more unsound version: any.
+      for (DartType t in _types) {
+        if ((t as TypeImpl).internalIsSubtypeOf(type, visitedTypePairs)) {
+          return true;
+        }
+      }
+      return false;
     }
-    return false;
   }
 
   /**
    * The more-specific-than test for union types on the RHS is uniform in non-union LHSs. So, other
    * `TypeImpl`s can call this method to implement `internalIsMoreSpecificThan` for
    * union types.
    *
    * @param type
    * @param visitedTypePairs
    * @return true if `type` is more specific than this union type
    */
-  bool internalUnionTypeIsMoreSpecificThan(DartType type, bool withDynamic, Set<TypeImpl_TypePair> visitedTypePairs) {
+  bool internalUnionTypeIsLessSpecificThan(DartType type, bool withDynamic, Set<TypeImpl_TypePair> visitedTypePairs) {
     // This implementation does not make sense when [type] is a union type, at least
     // for the "less unsound" version of [internalIsMoreSpecificThan] above.
     if (type is UnionType) {
       throw new IllegalArgumentException("Only non-union types are supported.");
     }
     for (DartType t in _types) {
       if ((type as TypeImpl).internalIsMoreSpecificThan(t, withDynamic, visitedTypePairs)) {
         return true;
       }
     }
@@ skipping 362 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) || identical(type, DynamicTypeImpl.instance);
   }
 }