New analyzer snapshot.

pkg/analyzer/test/generated/element_test.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_test;
 
 import 'package:analyzer/src/generated/java_core.dart';
@@ skipping 3478 matching lines @@
   void test_setTypeArguments() {
     InterfaceTypeImpl type = ElementFactory.classElement2("A", []).type as InterfaceTypeImpl;
     List<DartType> typeArguments = <DartType> [
         ElementFactory.classElement2("B", []).type,
         ElementFactory.classElement2("C", []).type];
     type.typeArguments = typeArguments;
     JUnitTestCase.assertEquals(typeArguments, type.typeArguments);
   }
 
   void test_substitute_equal() {
-    ClassElementImpl classA = ElementFactory.classElement2("A", []);
-    TypeParameterElementImpl parameterElement = new TypeParameterElementImpl.forNode(AstFactory.identifier3("E"));
-    InterfaceTypeImpl type = new InterfaceTypeImpl.con1(classA);
-    TypeParameterTypeImpl parameter = new TypeParameterTypeImpl(parameterElement);
-    type.typeArguments = <DartType> [parameter];
+    ClassElement classAE = ElementFactory.classElement2("A", ["E"]);
+    InterfaceType typeAE = classAE.type;
     InterfaceType argumentType = ElementFactory.classElement2("B", []).type;
-    InterfaceType result = type.substitute2(<DartType> [argumentType], <DartType> [parameter]);
-    JUnitTestCase.assertEquals(classA, result.element);
-    List<DartType> resultArguments = result.typeArguments;
+    List<DartType> args = [argumentType];
+    List<DartType> params = [classAE.typeParameters[0].type];
+    InterfaceType typeAESubbed = typeAE.substitute2(args, params);
+    JUnitTestCase.assertEquals(classAE, typeAESubbed.element);
+    List<DartType> resultArguments = typeAESubbed.typeArguments;
     EngineTestCase.assertLength(1, resultArguments);
     JUnitTestCase.assertEquals(argumentType, resultArguments[0]);
   }
 
   void test_substitute_exception() {
     try {
       ClassElementImpl classA = ElementFactory.classElement2("A", []);
       InterfaceTypeImpl type = new InterfaceTypeImpl.con1(classA);
       InterfaceType argumentType = ElementFactory.classElement2("B", []).type;
       type.substitute2(<DartType> [argumentType], <DartType> []);
       JUnitTestCase.fail("Expected to encounter exception, argument and parameter type array lengths not equal.");
     } catch (e) {
     }
   }
 
   void test_substitute_notEqual() {
+    // The [test_substitute_equals] above has a slightly higher level implementation.
     ClassElementImpl classA = ElementFactory.classElement2("A", []);
     TypeParameterElementImpl parameterElement = new TypeParameterElementImpl.forNode(AstFactory.identifier3("E"));
     InterfaceTypeImpl type = new InterfaceTypeImpl.con1(classA);
     TypeParameterTypeImpl parameter = new TypeParameterTypeImpl(parameterElement);
     type.typeArguments = <DartType> [parameter];
     InterfaceType argumentType = ElementFactory.classElement2("B", []).type;
     TypeParameterTypeImpl parameterType = new TypeParameterTypeImpl(new TypeParameterElementImpl.forNode(AstFactory.identifier3("F")));
     InterfaceType result = type.substitute2(<DartType> [argumentType], <DartType> [parameterType]);
     JUnitTestCase.assertEquals(classA, result.element);
     List<DartType> resultArguments = result.typeArguments;
@@ skipping 851 matching lines @@
   DartType _uA;
 
   DartType _uB;
 
   DartType _uAB;
 
   DartType _uBA;
 
   List<DartType> _us;
 
-  void fail_isSubtypeOf_element() {
-    // Elements of union are sub types
-    JUnitTestCase.assertTrue(_typeA.isSubtypeOf(_uAB));
-    JUnitTestCase.assertTrue(_typeB.isSubtypeOf(_uAB));
-  }
-
-  void fail_isSubtypeOf_reflexivity() {
-    for (DartType u in _us) {
-      JUnitTestCase.assertTrue(u.isSubtypeOf(u));
-    }
-  }
-
-  void fail_toString_pair() {
-    DartType u = UnionTypeImpl.union([_typeA, _typeB]);
-    String s = u.toString();
-    JUnitTestCase.assertTrue(s == "{A,B}" || s == "{B,A}");
-  }
-
   void test_emptyUnionsNotAllowed() {
     try {
       UnionTypeImpl.union([]);
     } on IllegalArgumentException catch (e) {
       return;
     }
     JUnitTestCase.fail("Expected illegal argument exception.");
   }
 
   void test_equality_beingASubtypeOfAnElementIsNotSufficient() {
@@ skipping 11 matching lines @@
     for (DartType u in _us) {
       JUnitTestCase.assertTrue(u == u);
     }
   }
 
   void test_equality_singletonsCollapse() {
     JUnitTestCase.assertTrue(_typeA == _uA);
     JUnitTestCase.assertTrue(_uA == _typeA);
   }
 
+  void test_isMoreSpecificThan_allElementsOnLHSAreSubtypesOfSomeElementOnRHS() {
+    // Unions are subtypes when all elements are subtypes
+    JUnitTestCase.assertTrue(_uAB.isMoreSpecificThan(_uA));
+    JUnitTestCase.assertTrue(_uAB.isMoreSpecificThan(_typeA));
+  }
+
+  void test_isMoreSpecificThan_element() {
+    // Elements of union are sub types
+    JUnitTestCase.assertTrue(_typeA.isMoreSpecificThan(_uAB));
+    JUnitTestCase.assertTrue(_typeB.isMoreSpecificThan(_uAB));
+  }
+
+  void test_isMoreSpecificThan_notSubtypeOfAnyElement() {
+    // Types that are not subtypes of elements are not subtypes
+    JUnitTestCase.assertFalse(_typeA.isMoreSpecificThan(_uB));
+  }
+
+  void test_isMoreSpecificThan_reflexivity() {
+    for (DartType u in _us) {
+      JUnitTestCase.assertTrue(u.isMoreSpecificThan(u));
+    }
+  }
+
+  void test_isMoreSpecificThan_someElementOnLHSIsNotASubtypeOfAnyElementOnRHS() {
+    // Unions are not subtypes when some element is not a subtype
+    JUnitTestCase.assertFalse(_uAB.isMoreSpecificThan(_uB));
+    JUnitTestCase.assertFalse(_uAB.isMoreSpecificThan(_typeB));
+  }
+
+  void test_isMoreSpecificThan_subtypeOfSomeElement() {
+    // Subtypes of elements are sub types
+    JUnitTestCase.assertTrue(_typeB.isMoreSpecificThan(_uA));
+  }
+
   void test_isSubtypeOf_allElementsOnLHSAreSubtypesOfSomeElementOnRHS() {
     // Unions are subtypes when all elements are subtypes
     JUnitTestCase.assertTrue(_uAB.isSubtypeOf(_uA));
     JUnitTestCase.assertTrue(_uAB.isSubtypeOf(_typeA));
   }
 
+  void test_isSubtypeOf_element() {
+    // Elements of union are sub types
+    JUnitTestCase.assertTrue(_typeA.isSubtypeOf(_uAB));
+    JUnitTestCase.assertTrue(_typeB.isSubtypeOf(_uAB));
+  }
+
   void test_isSubtypeOf_notSubtypeOfAnyElement() {
     // Types that are not subtypes of elements are not subtypes
     JUnitTestCase.assertFalse(_typeA.isSubtypeOf(_uB));
   }
 
+  void test_isSubtypeOf_reflexivity() {
+    for (DartType u in _us) {
+      JUnitTestCase.assertTrue(u.isSubtypeOf(u));
+    }
+  }
+
   void test_isSubtypeOf_someElementOnLHSIsNotASubtypeOfAnyElementOnRHS() {
     // Unions are not subtypes when some element is not a subtype
     JUnitTestCase.assertFalse(_uAB.isSubtypeOf(_uB));
     JUnitTestCase.assertFalse(_uAB.isSubtypeOf(_typeB));
   }
 
   void test_isSubtypeOf_subtypeOfSomeElement() {
     // Subtypes of elements are sub types
     JUnitTestCase.assertTrue(_typeB.isSubtypeOf(_uA));
   }
 
   void test_nestedUnionsCollapse() {
     UnionType u = UnionTypeImpl.union([_uAB, _typeA]) as UnionType;
     for (DartType t in u.elements) {
       if (t is UnionType) {
         JUnitTestCase.fail("Expected only non-union types but found ${t}!");
       }
     }
   }
 
   void test_noLossage() {
     UnionType u = UnionTypeImpl.union([_typeA, _typeB, _typeB, _typeA, _typeB, _typeB]) as UnionType;
     Set<DartType> elements = u.elements;
     JUnitTestCase.assertTrue(elements.contains(_typeA));
     JUnitTestCase.assertTrue(elements.contains(_typeB));
     JUnitTestCase.assertTrue(elements.length == 2);
   }
 
+  void test_substitute() {
+    // Based on [InterfaceTypeImplTest.test_substitute_equal].
+    ClassElement classAE = ElementFactory.classElement2("A", ["E"]);
+    InterfaceType typeAE = classAE.type;
+    List<DartType> args = [_typeB];
+    List<DartType> params = [classAE.typeParameters[0].type];
+    DartType typeAESubbed = typeAE.substitute2(args, params);
+    JUnitTestCase.assertFalse(typeAE == typeAESubbed);
+    JUnitTestCase.assertEquals(UnionTypeImpl.union([_typeA, typeAE]).substitute2(args, params), UnionTypeImpl.union([_typeA, typeAESubbed]));
+  }
+
+  void test_toString_pair() {
+    String s = _uAB.toString();
+    JUnitTestCase.assertTrue(s == "{A,B}" || s == "{B,A}");
+    JUnitTestCase.assertEquals(s, _uAB.displayName);
+  }
+
   void test_toString_singleton() {
     // Singleton unions collapse to the the single type.
     JUnitTestCase.assertEquals("A", _uA.toString());
   }
 
+  void test_unionTypeIsLessSpecificThan_function() {
+    // Based on [FunctionTypeImplTest.test_isAssignableTo_normalAndPositionalArgs].
+    ClassElement a = ElementFactory.classElement2("A", []);
+    FunctionType t = ElementFactory.functionElement6("t", null, <ClassElement> [a]).type;
+    DartType uAT = UnionTypeImpl.union([_uA, t]);
+    JUnitTestCase.assertTrue(t.isMoreSpecificThan(uAT));
+    JUnitTestCase.assertFalse(t.isMoreSpecificThan(_uAB));
+  }
+
+  void test_unionTypeIsSuperTypeOf_function() {
+    // Based on [FunctionTypeImplTest.test_isAssignableTo_normalAndPositionalArgs].
+    ClassElement a = ElementFactory.classElement2("A", []);
+    FunctionType t = ElementFactory.functionElement6("t", null, <ClassElement> [a]).type;
+    DartType uAT = UnionTypeImpl.union([_uA, t]);
+    JUnitTestCase.assertTrue(t.isSubtypeOf(uAT));
+    JUnitTestCase.assertFalse(t.isSubtypeOf(_uAB));
+  }
+
   @override
   void setUp() {
     super.setUp();
     _classA = ElementFactory.classElement2("A", []);
     _typeA = _classA.type;
     _classB = ElementFactory.classElement("B", _typeA, []);
     _typeB = _classB.type;
     _uA = UnionTypeImpl.union([_typeA]);
     _uB = UnionTypeImpl.union([_typeB]);
     _uAB = UnionTypeImpl.union([_typeA, _typeB]);
@@ skipping 16 matching lines @@
         runJUnitTest(__test, __test.test_equality_insertionOrderDoesntMatter);
       });
       _ut.test('test_equality_reflexivity', () {
         final __test = new UnionTypeImplTest();
         runJUnitTest(__test, __test.test_equality_reflexivity);
       });
       _ut.test('test_equality_singletonsCollapse', () {
         final __test = new UnionTypeImplTest();
         runJUnitTest(__test, __test.test_equality_singletonsCollapse);
       });
+      _ut.test('test_isMoreSpecificThan_allElementsOnLHSAreSubtypesOfSomeElementOnRHS', () {
+        final __test = new UnionTypeImplTest();
+        runJUnitTest(__test, __test.test_isMoreSpecificThan_allElementsOnLHSAreSubtypesOfSomeElementOnRHS);
+      });
+      _ut.test('test_isMoreSpecificThan_element', () {
+        final __test = new UnionTypeImplTest();
+        runJUnitTest(__test, __test.test_isMoreSpecificThan_element);
+      });
+      _ut.test('test_isMoreSpecificThan_notSubtypeOfAnyElement', () {
+        final __test = new UnionTypeImplTest();
+        runJUnitTest(__test, __test.test_isMoreSpecificThan_notSubtypeOfAnyElement);
+      });
+      _ut.test('test_isMoreSpecificThan_reflexivity', () {
+        final __test = new UnionTypeImplTest();
+        runJUnitTest(__test, __test.test_isMoreSpecificThan_reflexivity);
+      });
+      _ut.test('test_isMoreSpecificThan_someElementOnLHSIsNotASubtypeOfAnyElementOnRHS', () {
+        final __test = new UnionTypeImplTest();
+        runJUnitTest(__test, __test.test_isMoreSpecificThan_someElementOnLHSIsNotASubtypeOfAnyElementOnRHS);
+      });
+      _ut.test('test_isMoreSpecificThan_subtypeOfSomeElement', () {
+        final __test = new UnionTypeImplTest();
+        runJUnitTest(__test, __test.test_isMoreSpecificThan_subtypeOfSomeElement);
+      });
       _ut.test('test_isSubtypeOf_allElementsOnLHSAreSubtypesOfSomeElementOnRHS', () {
         final __test = new UnionTypeImplTest();
         runJUnitTest(__test, __test.test_isSubtypeOf_allElementsOnLHSAreSubtypesOfSomeElementOnRHS);
       });
+      _ut.test('test_isSubtypeOf_element', () {
+        final __test = new UnionTypeImplTest();
+        runJUnitTest(__test, __test.test_isSubtypeOf_element);
+      });
       _ut.test('test_isSubtypeOf_notSubtypeOfAnyElement', () {
         final __test = new UnionTypeImplTest();
         runJUnitTest(__test, __test.test_isSubtypeOf_notSubtypeOfAnyElement);
       });
+      _ut.test('test_isSubtypeOf_reflexivity', () {
+        final __test = new UnionTypeImplTest();
+        runJUnitTest(__test, __test.test_isSubtypeOf_reflexivity);
+      });
       _ut.test('test_isSubtypeOf_someElementOnLHSIsNotASubtypeOfAnyElementOnRHS', () {
         final __test = new UnionTypeImplTest();
         runJUnitTest(__test, __test.test_isSubtypeOf_someElementOnLHSIsNotASubtypeOfAnyElementOnRHS);
       });
       _ut.test('test_isSubtypeOf_subtypeOfSomeElement', () {
         final __test = new UnionTypeImplTest();
         runJUnitTest(__test, __test.test_isSubtypeOf_subtypeOfSomeElement);
       });
       _ut.test('test_nestedUnionsCollapse', () {
         final __test = new UnionTypeImplTest();
         runJUnitTest(__test, __test.test_nestedUnionsCollapse);
       });
       _ut.test('test_noLossage', () {
         final __test = new UnionTypeImplTest();
         runJUnitTest(__test, __test.test_noLossage);
       });
+      _ut.test('test_substitute', () {
+        final __test = new UnionTypeImplTest();
+        runJUnitTest(__test, __test.test_substitute);
+      });
+      _ut.test('test_toString_pair', () {
+        final __test = new UnionTypeImplTest();
+        runJUnitTest(__test, __test.test_toString_pair);
+      });
       _ut.test('test_toString_singleton', () {
         final __test = new UnionTypeImplTest();
         runJUnitTest(__test, __test.test_toString_singleton);
       });
+      _ut.test('test_unionTypeIsLessSpecificThan_function', () {
+        final __test = new UnionTypeImplTest();
+        runJUnitTest(__test, __test.test_unionTypeIsLessSpecificThan_function);
+      });
+      _ut.test('test_unionTypeIsSuperTypeOf_function', () {
+        final __test = new UnionTypeImplTest();
+        runJUnitTest(__test, __test.test_unionTypeIsSuperTypeOf_function);
+      });
     });
   }
 }
 
 class VoidTypeImplTest extends EngineTestCase {
   /**
    * Reference {code VoidTypeImpl.getInstance()}.
    */
   DartType _voidType = VoidTypeImpl.instance;
 
@@ skipping 70 matching lines @@
   UnionTypeImplTest.dartSuite();
   VoidTypeImplTest.dartSuite();
   ClassElementImplTest.dartSuite();
   CompilationUnitElementImplTest.dartSuite();
   ElementLocationImplTest.dartSuite();
   ElementImplTest.dartSuite();
   HtmlElementImplTest.dartSuite();
   LibraryElementImplTest.dartSuite();
   MultiplyDefinedElementImplTest.dartSuite();
 }