Version 0.5.13.1 .

pkg/analyzer_experimental/test/generated/element_test.dart

 // 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 'dart:collection';
 import 'dart:io';
 import 'package:analyzer_experimental/src/generated/java_core.dart';
 import 'package:analyzer_experimental/src/generated/java_engine.dart';
 import 'package:analyzer_experimental/src/generated/java_engine_io.dart';
@@ skipping 155 matching lines @@
         runJUnitTest(__test, __test.test_isUpToDate);
       });
       _ut.test('test_setImports', () {
         final __test = new LibraryElementImplTest();
         runJUnitTest(__test, __test.test_setImports);
       });
     });
   }
 }
 class InterfaceTypeImplTest extends EngineTestCase {
+  
   /**
    * The type provider used to access the types.
    */
   TestTypeProvider _typeProvider;
   void setUp() {
     _typeProvider = new TestTypeProvider();
   }
   void test_computeLongestInheritancePathToObject_multipleInterfacePaths() {
     ClassElementImpl classA = ElementFactory.classElement2("A", []);
     ClassElementImpl classB = ElementFactory.classElement2("B", []);
@@ skipping 15 matching lines @@
     ClassElementImpl classE = ElementFactory.classElement("E", classB.type, []);
     classE.interfaces = <InterfaceType> [classD.type];
     JUnitTestCase.assertEquals(2, InterfaceTypeImpl.computeLongestInheritancePathToObject(classB.type));
     JUnitTestCase.assertEquals(4, InterfaceTypeImpl.computeLongestInheritancePathToObject(classE.type));
   }
   void test_computeLongestInheritancePathToObject_object() {
     ClassElement classA = ElementFactory.classElement2("A", []);
     InterfaceType object = classA.supertype;
     JUnitTestCase.assertEquals(0, InterfaceTypeImpl.computeLongestInheritancePathToObject(object));
   }
+  void test_computeLongestInheritancePathToObject_recursion() {
+    ClassElementImpl classA = ElementFactory.classElement2("A", []);
+    ClassElementImpl classB = ElementFactory.classElement("B", classA.type, []);
+    classA.supertype = classB.type;
+    JUnitTestCase.assertEquals(2, InterfaceTypeImpl.computeLongestInheritancePathToObject(classA.type));
+  }
   void test_computeLongestInheritancePathToObject_singleInterfacePath() {
     ClassElementImpl classA = ElementFactory.classElement2("A", []);
     ClassElementImpl classB = ElementFactory.classElement2("B", []);
     ClassElementImpl classC = ElementFactory.classElement2("C", []);
     classB.interfaces = <InterfaceType> [classA.type];
     classC.interfaces = <InterfaceType> [classB.type];
     JUnitTestCase.assertEquals(1, InterfaceTypeImpl.computeLongestInheritancePathToObject(classA.type));
     JUnitTestCase.assertEquals(2, InterfaceTypeImpl.computeLongestInheritancePathToObject(classB.type));
     JUnitTestCase.assertEquals(3, InterfaceTypeImpl.computeLongestInheritancePathToObject(classC.type));
   }
   void test_computeLongestInheritancePathToObject_singleSuperclassPath() {
     ClassElement classA = ElementFactory.classElement2("A", []);
     ClassElement classB = ElementFactory.classElement("B", classA.type, []);
     ClassElement classC = ElementFactory.classElement("C", classB.type, []);
     JUnitTestCase.assertEquals(1, InterfaceTypeImpl.computeLongestInheritancePathToObject(classA.type));
     JUnitTestCase.assertEquals(2, InterfaceTypeImpl.computeLongestInheritancePathToObject(classB.type));
     JUnitTestCase.assertEquals(3, InterfaceTypeImpl.computeLongestInheritancePathToObject(classC.type));
   }
   void test_computeSuperinterfaceSet_multipleInterfacePaths() {
     ClassElementImpl classA = ElementFactory.classElement2("A", []);
     ClassElementImpl classB = ElementFactory.classElement2("B", []);
     ClassElementImpl classC = ElementFactory.classElement2("C", []);
     ClassElementImpl classD = ElementFactory.classElement2("D", []);
     ClassElementImpl classE = ElementFactory.classElement2("E", []);
     classB.interfaces = <InterfaceType> [classA.type];
     classC.interfaces = <InterfaceType> [classA.type];
     classD.interfaces = <InterfaceType> [classC.type];
     classE.interfaces = <InterfaceType> [classB.type, classD.type];
     Set<InterfaceType> superinterfacesOfD = InterfaceTypeImpl.computeSuperinterfaceSet(classD.type);
-    JUnitTestCase.assertNotNull(superinterfacesOfD);
+    EngineTestCase.assertSize3(3, superinterfacesOfD);
     JUnitTestCase.assertTrue(superinterfacesOfD.contains(ElementFactory.object.type));
     JUnitTestCase.assertTrue(superinterfacesOfD.contains(classA.type));
     JUnitTestCase.assertTrue(superinterfacesOfD.contains(classC.type));
-    JUnitTestCase.assertEquals(3, superinterfacesOfD.length);
     Set<InterfaceType> superinterfacesOfE = InterfaceTypeImpl.computeSuperinterfaceSet(classE.type);
-    JUnitTestCase.assertNotNull(superinterfacesOfE);
+    EngineTestCase.assertSize3(5, superinterfacesOfE);
     JUnitTestCase.assertTrue(superinterfacesOfE.contains(ElementFactory.object.type));
     JUnitTestCase.assertTrue(superinterfacesOfE.contains(classA.type));
     JUnitTestCase.assertTrue(superinterfacesOfE.contains(classB.type));
     JUnitTestCase.assertTrue(superinterfacesOfE.contains(classC.type));
     JUnitTestCase.assertTrue(superinterfacesOfE.contains(classD.type));
-    JUnitTestCase.assertEquals(5, superinterfacesOfE.length);
   }
   void test_computeSuperinterfaceSet_multipleSuperclassPaths() {
     ClassElement classA = ElementFactory.classElement2("A", []);
     ClassElement classB = ElementFactory.classElement("B", classA.type, []);
     ClassElement classC = ElementFactory.classElement("C", classA.type, []);
     ClassElement classD = ElementFactory.classElement("D", classC.type, []);
     ClassElementImpl classE = ElementFactory.classElement("E", classB.type, []);
     classE.interfaces = <InterfaceType> [classD.type];
     Set<InterfaceType> superinterfacesOfD = InterfaceTypeImpl.computeSuperinterfaceSet(classD.type);
-    JUnitTestCase.assertNotNull(superinterfacesOfD);
+    EngineTestCase.assertSize3(3, superinterfacesOfD);
     JUnitTestCase.assertTrue(superinterfacesOfD.contains(ElementFactory.object.type));
     JUnitTestCase.assertTrue(superinterfacesOfD.contains(classA.type));
     JUnitTestCase.assertTrue(superinterfacesOfD.contains(classC.type));
-    JUnitTestCase.assertEquals(3, superinterfacesOfD.length);
     Set<InterfaceType> superinterfacesOfE = InterfaceTypeImpl.computeSuperinterfaceSet(classE.type);
-    JUnitTestCase.assertNotNull(superinterfacesOfE);
+    EngineTestCase.assertSize3(5, superinterfacesOfE);
     JUnitTestCase.assertTrue(superinterfacesOfE.contains(ElementFactory.object.type));
     JUnitTestCase.assertTrue(superinterfacesOfE.contains(classA.type));
     JUnitTestCase.assertTrue(superinterfacesOfE.contains(classB.type));
     JUnitTestCase.assertTrue(superinterfacesOfE.contains(classC.type));
     JUnitTestCase.assertTrue(superinterfacesOfE.contains(classD.type));
-    JUnitTestCase.assertEquals(5, superinterfacesOfE.length);
+  }
+  void test_computeSuperinterfaceSet_recursion() {
+    ClassElementImpl classA = ElementFactory.classElement2("A", []);
+    ClassElementImpl classB = ElementFactory.classElement("B", classA.type, []);
+    classA.supertype = classB.type;
+    Set<InterfaceType> superinterfacesOfB = InterfaceTypeImpl.computeSuperinterfaceSet(classB.type);
+    EngineTestCase.assertSize3(2, superinterfacesOfB);
   }
   void test_computeSuperinterfaceSet_singleInterfacePath() {
     ClassElementImpl classA = ElementFactory.classElement2("A", []);
     ClassElementImpl classB = ElementFactory.classElement2("B", []);
     ClassElementImpl classC = ElementFactory.classElement2("C", []);
     classB.interfaces = <InterfaceType> [classA.type];
     classC.interfaces = <InterfaceType> [classB.type];
     Set<InterfaceType> superinterfacesOfA = InterfaceTypeImpl.computeSuperinterfaceSet(classA.type);
-    JUnitTestCase.assertNotNull(superinterfacesOfA);
+    EngineTestCase.assertSize3(1, superinterfacesOfA);
     JUnitTestCase.assertTrue(superinterfacesOfA.contains(ElementFactory.object.type));
-    JUnitTestCase.assertEquals(1, superinterfacesOfA.length);
     Set<InterfaceType> superinterfacesOfB = InterfaceTypeImpl.computeSuperinterfaceSet(classB.type);
-    JUnitTestCase.assertNotNull(superinterfacesOfB);
+    EngineTestCase.assertSize3(2, superinterfacesOfB);
     JUnitTestCase.assertTrue(superinterfacesOfB.contains(ElementFactory.object.type));
     JUnitTestCase.assertTrue(superinterfacesOfB.contains(classA.type));
-    JUnitTestCase.assertEquals(2, superinterfacesOfB.length);
     Set<InterfaceType> superinterfacesOfC = InterfaceTypeImpl.computeSuperinterfaceSet(classC.type);
-    JUnitTestCase.assertNotNull(superinterfacesOfC);
+    EngineTestCase.assertSize3(3, superinterfacesOfC);
     JUnitTestCase.assertTrue(superinterfacesOfC.contains(ElementFactory.object.type));
     JUnitTestCase.assertTrue(superinterfacesOfC.contains(classA.type));
     JUnitTestCase.assertTrue(superinterfacesOfC.contains(classB.type));
-    JUnitTestCase.assertEquals(3, superinterfacesOfC.length);
   }
   void test_computeSuperinterfaceSet_singleSuperclassPath() {
     ClassElement classA = ElementFactory.classElement2("A", []);
     ClassElement classB = ElementFactory.classElement("B", classA.type, []);
     ClassElement classC = ElementFactory.classElement("C", classB.type, []);
     Set<InterfaceType> superinterfacesOfA = InterfaceTypeImpl.computeSuperinterfaceSet(classA.type);
-    JUnitTestCase.assertNotNull(superinterfacesOfA);
+    EngineTestCase.assertSize3(1, superinterfacesOfA);
     JUnitTestCase.assertTrue(superinterfacesOfA.contains(ElementFactory.object.type));
-    JUnitTestCase.assertEquals(1, superinterfacesOfA.length);
     Set<InterfaceType> superinterfacesOfB = InterfaceTypeImpl.computeSuperinterfaceSet(classB.type);
-    JUnitTestCase.assertNotNull(superinterfacesOfB);
+    EngineTestCase.assertSize3(2, superinterfacesOfB);
     JUnitTestCase.assertTrue(superinterfacesOfB.contains(ElementFactory.object.type));
     JUnitTestCase.assertTrue(superinterfacesOfB.contains(classA.type));
-    JUnitTestCase.assertEquals(2, superinterfacesOfB.length);
     Set<InterfaceType> superinterfacesOfC = InterfaceTypeImpl.computeSuperinterfaceSet(classC.type);
-    JUnitTestCase.assertNotNull(superinterfacesOfC);
+    EngineTestCase.assertSize3(3, superinterfacesOfC);
     JUnitTestCase.assertTrue(superinterfacesOfC.contains(ElementFactory.object.type));
     JUnitTestCase.assertTrue(superinterfacesOfC.contains(classA.type));
     JUnitTestCase.assertTrue(superinterfacesOfC.contains(classB.type));
-    JUnitTestCase.assertEquals(3, superinterfacesOfC.length);
   }
   void test_creation() {
     JUnitTestCase.assertNotNull(new InterfaceTypeImpl.con1(ElementFactory.classElement2("A", [])));
   }
   void test_getElement() {
     ClassElementImpl typeElement = ElementFactory.classElement2("A", []);
     InterfaceTypeImpl type = new InterfaceTypeImpl.con1(typeElement);
     JUnitTestCase.assertEquals(typeElement, type.element);
   }
   void test_getGetter_implemented() {
@@ skipping 211 matching lines @@
     InterfaceType typeA = classA.type;
     InterfaceType typeA2 = classA2.type;
     InterfaceType typeA3 = classA3.type;
     InterfaceType typeB = classB.type;
     InterfaceType typeC = classC.type;
     classB.interfaces = <InterfaceType> [typeA, typeA2];
     classC.interfaces = <InterfaceType> [typeA, typeA3];
     JUnitTestCase.assertEquals(typeA, typeB.getLeastUpperBound(typeC));
     JUnitTestCase.assertEquals(typeA, typeC.getLeastUpperBound(typeB));
   }
+  void test_getLeastUpperBound_twoComparables() {
+    InterfaceType string = _typeProvider.stringType;
+    InterfaceType num = _typeProvider.numType;
+    JUnitTestCase.assertEquals(_typeProvider.objectType, string.getLeastUpperBound(num));
+  }
   void test_getLeastUpperBound_typeParameters_different() {
     InterfaceType listType2 = _typeProvider.listType;
     InterfaceType intType2 = _typeProvider.intType;
     InterfaceType doubleType2 = _typeProvider.doubleType;
     InterfaceType listOfIntType = listType2.substitute5(<Type2> [intType2]);
     InterfaceType listOfDoubleType = listType2.substitute5(<Type2> [doubleType2]);
-    JUnitTestCase.assertEquals(listType2.substitute5(<Type2> [_typeProvider.numType]), listOfIntType.getLeastUpperBound(listOfDoubleType));
+    JUnitTestCase.assertEquals(listType2.substitute5(<Type2> [_typeProvider.dynamicType]), listOfIntType.getLeastUpperBound(listOfDoubleType));
   }
   void test_getLeastUpperBound_typeParameters_same() {
     InterfaceType listType2 = _typeProvider.listType;
     InterfaceType intType2 = _typeProvider.intType;
     InterfaceType listOfIntType = listType2.substitute5(<Type2> [intType2]);
     JUnitTestCase.assertEquals(listOfIntType, listOfIntType.getLeastUpperBound(listOfIntType));
   }
   void test_getMethod_implemented() {
     ClassElementImpl classA = ElementFactory.classElement2("A", []);
     String methodName = "m";
@@ skipping 161 matching lines @@
     ClassElement classB = ElementFactory.classElement("B", classA.type, []);
     InterfaceType typeA = classA.type;
     InterfaceType typeB = classB.type;
     JUnitTestCase.assertTrue(typeB.isMoreSpecificThan(typeA));
     JUnitTestCase.assertFalse(typeA.isMoreSpecificThan(typeB));
   }
   void test_isMoreSpecificThan_dynamic() {
     InterfaceType type2 = ElementFactory.classElement2("A", []).type;
     JUnitTestCase.assertTrue(type2.isMoreSpecificThan(DynamicTypeImpl.instance));
   }
-  void test_isMoreSpecificThan_indirectSupertype() {
+  void test_isMoreSpecificThan_self() {
+    InterfaceType type2 = ElementFactory.classElement2("A", []).type;
+    JUnitTestCase.assertTrue(type2.isMoreSpecificThan(type2));
+  }
+  void test_isMoreSpecificThan_transitive_interface() {
+    ClassElementImpl classA = ElementFactory.classElement2("A", []);
+    ClassElementImpl classB = ElementFactory.classElement("B", classA.type, []);
+    ClassElementImpl classC = ElementFactory.classElement2("C", []);
+    classC.interfaces = <InterfaceType> [classB.type];
+    InterfaceType typeA = classA.type;
+    InterfaceType typeC = classC.type;
+    JUnitTestCase.assertTrue(typeC.isMoreSpecificThan(typeA));
+  }
+  void test_isMoreSpecificThan_transitive_mixin() {
+    ClassElementImpl classA = ElementFactory.classElement2("A", []);
+    ClassElementImpl classB = ElementFactory.classElement("B", classA.type, []);
+    ClassElementImpl classC = ElementFactory.classElement2("C", []);
+    classC.mixins = <InterfaceType> [classB.type];
+    InterfaceType typeA = classA.type;
+    InterfaceType typeC = classC.type;
+    JUnitTestCase.assertTrue(typeC.isMoreSpecificThan(typeA));
+  }
+  void test_isMoreSpecificThan_transitive_recursive() {
+    ClassElementImpl classA = ElementFactory.classElement2("A", []);
+    ClassElementImpl classB = ElementFactory.classElement("B", classA.type, []);
+    ClassElementImpl classC = ElementFactory.classElement2("C", []);
+    InterfaceType typeA = classA.type;
+    InterfaceType typeC = classC.type;
+    classA.supertype = classB.type;
+    JUnitTestCase.assertFalse(typeA.isMoreSpecificThan(typeC));
+  }
+  void test_isMoreSpecificThan_transitive_superclass() {
     ClassElement classA = ElementFactory.classElement2("A", []);
     ClassElement classB = ElementFactory.classElement("B", classA.type, []);
     ClassElement classC = ElementFactory.classElement("C", classB.type, []);
     InterfaceType typeA = classA.type;
     InterfaceType typeC = classC.type;
     JUnitTestCase.assertTrue(typeC.isMoreSpecificThan(typeA));
   }
-  void test_isMoreSpecificThan_self() {
-    InterfaceType type2 = ElementFactory.classElement2("A", []).type;
-    JUnitTestCase.assertTrue(type2.isMoreSpecificThan(type2));
-  }
   void test_isSubtypeOf_directSubtype() {
     ClassElement classA = ElementFactory.classElement2("A", []);
     ClassElement classB = ElementFactory.classElement("B", classA.type, []);
     InterfaceType typeA = classA.type;
     InterfaceType typeB = classB.type;
     JUnitTestCase.assertTrue(typeB.isSubtypeOf(typeA));
     JUnitTestCase.assertFalse(typeA.isSubtypeOf(typeB));
   }
   void test_isSubtypeOf_dynamic() {
     ClassElement classA = ElementFactory.classElement2("A", []);
     InterfaceType typeA = classA.type;
     Type2 dynamicType = DynamicTypeImpl.instance;
     JUnitTestCase.assertFalse(dynamicType.isSubtypeOf(typeA));
     JUnitTestCase.assertTrue(typeA.isSubtypeOf(dynamicType));
   }
-  void test_isSubtypeOf_indirectSubtype() {
-    ClassElement classA = ElementFactory.classElement2("A", []);
-    ClassElement classB = ElementFactory.classElement("B", classA.type, []);
-    ClassElement classC = ElementFactory.classElement("C", classB.type, []);
-    InterfaceType typeA = classA.type;
-    InterfaceType typeC = classC.type;
-    JUnitTestCase.assertTrue(typeC.isSubtypeOf(typeA));
-    JUnitTestCase.assertFalse(typeA.isSubtypeOf(typeC));
-  }
   void test_isSubtypeOf_interface() {
     ClassElement classA = ElementFactory.classElement2("A", []);
     ClassElement classB = ElementFactory.classElement("B", classA.type, []);
     ClassElementImpl classC = ElementFactory.classElement2("C", []);
     InterfaceType typeObject = classA.supertype;
     InterfaceType typeA = classA.type;
     InterfaceType typeB = classB.type;
     InterfaceType typeC = classC.type;
     classC.interfaces = <InterfaceType> [typeB];
     JUnitTestCase.assertTrue(typeC.isSubtypeOf(typeB));
     JUnitTestCase.assertTrue(typeC.isSubtypeOf(typeObject));
     JUnitTestCase.assertTrue(typeC.isSubtypeOf(typeA));
     JUnitTestCase.assertFalse(typeA.isSubtypeOf(typeC));
   }
   void test_isSubtypeOf_mixins() {
     ClassElement classA = ElementFactory.classElement2("A", []);
     ClassElement classB = ElementFactory.classElement("B", classA.type, []);
     ClassElementImpl classC = ElementFactory.classElement2("C", []);
     InterfaceType typeObject = classA.supertype;
     InterfaceType typeA = classA.type;
     InterfaceType typeB = classB.type;
     InterfaceType typeC = classC.type;
     classC.mixins = <InterfaceType> [typeB];
     JUnitTestCase.assertTrue(typeC.isSubtypeOf(typeB));
     JUnitTestCase.assertTrue(typeC.isSubtypeOf(typeObject));
-    JUnitTestCase.assertFalse(typeC.isSubtypeOf(typeA));
+    JUnitTestCase.assertTrue(typeC.isSubtypeOf(typeA));
     JUnitTestCase.assertFalse(typeA.isSubtypeOf(typeC));
   }
   void test_isSubtypeOf_object() {
     ClassElement classA = ElementFactory.classElement2("A", []);
     InterfaceType typeA = classA.type;
     InterfaceType typeObject = classA.supertype;
     JUnitTestCase.assertTrue(typeA.isSubtypeOf(typeObject));
     JUnitTestCase.assertFalse(typeObject.isSubtypeOf(typeA));
   }
   void test_isSubtypeOf_self() {
     ClassElement classA = ElementFactory.classElement2("A", []);
     InterfaceType typeA = classA.type;
     JUnitTestCase.assertTrue(typeA.isSubtypeOf(typeA));
   }
+  void test_isSubtypeOf_transitive_recursive() {
+    ClassElementImpl classA = ElementFactory.classElement2("A", []);
+    ClassElementImpl classB = ElementFactory.classElement("B", classA.type, []);
+    ClassElementImpl classC = ElementFactory.classElement2("C", []);
+    InterfaceType typeA = classA.type;
+    InterfaceType typeC = classC.type;
+    classA.supertype = classB.type;
+    JUnitTestCase.assertFalse(typeA.isSubtypeOf(typeC));
+  }
+  void test_isSubtypeOf_transitive_superclass() {
+    ClassElement classA = ElementFactory.classElement2("A", []);
+    ClassElement classB = ElementFactory.classElement("B", classA.type, []);
+    ClassElement classC = ElementFactory.classElement("C", classB.type, []);
+    InterfaceType typeA = classA.type;
+    InterfaceType typeC = classC.type;
+    JUnitTestCase.assertTrue(typeC.isSubtypeOf(typeA));
+    JUnitTestCase.assertFalse(typeA.isSubtypeOf(typeC));
+  }
   void test_isSubtypeOf_typeArguments() {
     ClassElement classA = ElementFactory.classElement2("A", ["E"]);
     ClassElement classI = ElementFactory.classElement2("I", []);
     ClassElement classJ = ElementFactory.classElement("J", classI.type, []);
     ClassElement classK = ElementFactory.classElement2("K", []);
     InterfaceType typeA = classA.type;
     InterfaceTypeImpl typeAI = new InterfaceTypeImpl.con1(classA);
     InterfaceTypeImpl typeAJ = new InterfaceTypeImpl.con1(classA);
     InterfaceTypeImpl typeAK = new InterfaceTypeImpl.con1(classA);
     typeAI.typeArguments = <Type2> [classI.type];
@@ skipping 51 matching lines @@
     ClassElement classA = ElementFactory.classElement2("A", []);
     ClassElement classB = ElementFactory.classElement("B", classA.type, []);
     ClassElementImpl classC = ElementFactory.classElement2("C", []);
     InterfaceType typeObject = classA.supertype;
     InterfaceType typeA = classA.type;
     InterfaceType typeB = classB.type;
     InterfaceType typeC = classC.type;
     classC.mixins = <InterfaceType> [typeB];
     JUnitTestCase.assertTrue(typeB.isSupertypeOf(typeC));
     JUnitTestCase.assertTrue(typeObject.isSupertypeOf(typeC));
-    JUnitTestCase.assertFalse(typeA.isSupertypeOf(typeC));
+    JUnitTestCase.assertTrue(typeA.isSupertypeOf(typeC));
     JUnitTestCase.assertFalse(typeC.isSupertypeOf(typeA));
   }
   void test_isSupertypeOf_object() {
     ClassElement classA = ElementFactory.classElement2("A", []);
     InterfaceType typeA = classA.type;
     InterfaceType typeObject = classA.supertype;
     JUnitTestCase.assertFalse(typeA.isSupertypeOf(typeObject));
     JUnitTestCase.assertTrue(typeObject.isSupertypeOf(typeA));
   }
   void test_isSupertypeOf_self() {
@@ skipping 17 matching lines @@
     String getterName = "g";
     PropertyAccessorElement getterG = ElementFactory.getterElement(getterName, false, null);
     classA.accessors = <PropertyAccessorElement> [getterG];
     ClassElementImpl classB = ElementFactory.classElement("B", classA.type, []);
     InterfaceType typeB = classB.type;
     LibraryElementImpl library2 = ElementFactory.library(createAnalysisContext(), "lib");
     CompilationUnitElement unit = library2.definingCompilationUnit;
     ((unit as CompilationUnitElementImpl)).types = <ClassElement> [classA, classB];
     JUnitTestCase.assertSame(getterG, typeB.lookUpGetter(getterName, library2));
   }
+  void test_lookUpGetter_recursive() {
+    ClassElementImpl classA = ElementFactory.classElement2("A", []);
+    InterfaceType typeA = classA.type;
+    ClassElementImpl classB = ElementFactory.classElement("B", typeA, []);
+    classA.supertype = classB.type;
+    LibraryElementImpl library2 = ElementFactory.library(createAnalysisContext(), "lib");
+    CompilationUnitElement unit = library2.definingCompilationUnit;
+    ((unit as CompilationUnitElementImpl)).types = <ClassElement> [classA, classB];
+    JUnitTestCase.assertNull(typeA.lookUpGetter("g", library2));
+  }
   void test_lookUpGetter_unimplemented() {
     ClassElementImpl classA = ElementFactory.classElement2("A", []);
     InterfaceType typeA = classA.type;
     LibraryElementImpl library2 = ElementFactory.library(createAnalysisContext(), "lib");
     CompilationUnitElement unit = library2.definingCompilationUnit;
     ((unit as CompilationUnitElementImpl)).types = <ClassElement> [classA];
     JUnitTestCase.assertNull(typeA.lookUpGetter("g", library2));
   }
   void test_lookUpMethod_implemented() {
     ClassElementImpl classA = ElementFactory.classElement2("A", []);
@@ skipping 36 matching lines @@
     InterfaceTypeImpl typeBI = new InterfaceTypeImpl.con1(classB);
     typeBI.typeArguments = <Type2> [typeI];
     MethodElement method = typeBI.lookUpMethod(methodName, library2);
     JUnitTestCase.assertNotNull(method);
     FunctionType methodType = method.type;
     JUnitTestCase.assertSame(typeI, methodType.returnType);
     List<Type2> parameterTypes = methodType.normalParameterTypes;
     EngineTestCase.assertLength(1, parameterTypes);
     JUnitTestCase.assertSame(typeI, parameterTypes[0]);
   }
+  void test_lookUpMethod_recursive() {
+    ClassElementImpl classA = ElementFactory.classElement2("A", []);
+    InterfaceType typeA = classA.type;
+    ClassElementImpl classB = ElementFactory.classElement("B", typeA, []);
+    classA.supertype = classB.type;
+    LibraryElementImpl library2 = ElementFactory.library(createAnalysisContext(), "lib");
+    CompilationUnitElement unit = library2.definingCompilationUnit;
+    ((unit as CompilationUnitElementImpl)).types = <ClassElement> [classA, classB];
+    JUnitTestCase.assertNull(typeA.lookUpMethod("m", library2));
+  }
   void test_lookUpMethod_unimplemented() {
     ClassElementImpl classA = ElementFactory.classElement2("A", []);
     InterfaceType typeA = classA.type;
     LibraryElementImpl library2 = ElementFactory.library(createAnalysisContext(), "lib");
     CompilationUnitElement unit = library2.definingCompilationUnit;
     ((unit as CompilationUnitElementImpl)).types = <ClassElement> [classA];
     JUnitTestCase.assertNull(typeA.lookUpMethod("m", library2));
   }
   void test_lookUpSetter_implemented() {
     ClassElementImpl classA = ElementFactory.classElement2("A", []);
@@ skipping 11 matching lines @@
     String setterName = "g";
     PropertyAccessorElement setterS = ElementFactory.setterElement(setterName, false, null);
     classA.accessors = <PropertyAccessorElement> [setterS];
     ClassElementImpl classB = ElementFactory.classElement("B", classA.type, []);
     InterfaceType typeB = classB.type;
     LibraryElementImpl library2 = ElementFactory.library(createAnalysisContext(), "lib");
     CompilationUnitElement unit = library2.definingCompilationUnit;
     ((unit as CompilationUnitElementImpl)).types = <ClassElement> [classA, classB];
     JUnitTestCase.assertSame(setterS, typeB.lookUpSetter(setterName, library2));
   }
+  void test_lookUpSetter_recursive() {
+    ClassElementImpl classA = ElementFactory.classElement2("A", []);
+    InterfaceType typeA = classA.type;
+    ClassElementImpl classB = ElementFactory.classElement("B", typeA, []);
+    classA.supertype = classB.type;
+    LibraryElementImpl library2 = ElementFactory.library(createAnalysisContext(), "lib");
+    CompilationUnitElement unit = library2.definingCompilationUnit;
+    ((unit as CompilationUnitElementImpl)).types = <ClassElement> [classA, classB];
+    JUnitTestCase.assertNull(typeA.lookUpSetter("s", library2));
+  }
   void test_lookUpSetter_unimplemented() {
     ClassElementImpl classA = ElementFactory.classElement2("A", []);
     InterfaceType typeA = classA.type;
     LibraryElementImpl library2 = ElementFactory.library(createAnalysisContext(), "lib");
     CompilationUnitElement unit = library2.definingCompilationUnit;
     ((unit as CompilationUnitElementImpl)).types = <ClassElement> [classA];
     JUnitTestCase.assertNull(typeA.lookUpSetter("s", library2));
   }
   void test_setTypeArguments() {
     InterfaceTypeImpl type2 = ElementFactory.classElement2("A", []).type as InterfaceTypeImpl;
@@ skipping 35 matching lines @@
         runJUnitTest(__test, __test.test_computeLongestInheritancePathToObject_multipleInterfacePaths);
       });
       _ut.test('test_computeLongestInheritancePathToObject_multipleSuperclassPaths', () {
         final __test = new InterfaceTypeImplTest();
         runJUnitTest(__test, __test.test_computeLongestInheritancePathToObject_multipleSuperclassPaths);
       });
       _ut.test('test_computeLongestInheritancePathToObject_object', () {
         final __test = new InterfaceTypeImplTest();
         runJUnitTest(__test, __test.test_computeLongestInheritancePathToObject_object);
       });
+      _ut.test('test_computeLongestInheritancePathToObject_recursion', () {
+        final __test = new InterfaceTypeImplTest();
+        runJUnitTest(__test, __test.test_computeLongestInheritancePathToObject_recursion);
+      });
       _ut.test('test_computeLongestInheritancePathToObject_singleInterfacePath', () {
         final __test = new InterfaceTypeImplTest();
         runJUnitTest(__test, __test.test_computeLongestInheritancePathToObject_singleInterfacePath);
       });
       _ut.test('test_computeLongestInheritancePathToObject_singleSuperclassPath', () {
         final __test = new InterfaceTypeImplTest();
         runJUnitTest(__test, __test.test_computeLongestInheritancePathToObject_singleSuperclassPath);
       });
       _ut.test('test_computeSuperinterfaceSet_multipleInterfacePaths', () {
         final __test = new InterfaceTypeImplTest();
         runJUnitTest(__test, __test.test_computeSuperinterfaceSet_multipleInterfacePaths);
       });
       _ut.test('test_computeSuperinterfaceSet_multipleSuperclassPaths', () {
         final __test = new InterfaceTypeImplTest();
         runJUnitTest(__test, __test.test_computeSuperinterfaceSet_multipleSuperclassPaths);
       });
+      _ut.test('test_computeSuperinterfaceSet_recursion', () {
+        final __test = new InterfaceTypeImplTest();
+        runJUnitTest(__test, __test.test_computeSuperinterfaceSet_recursion);
+      });
       _ut.test('test_computeSuperinterfaceSet_singleInterfacePath', () {
         final __test = new InterfaceTypeImplTest();
         runJUnitTest(__test, __test.test_computeSuperinterfaceSet_singleInterfacePath);
       });
       _ut.test('test_computeSuperinterfaceSet_singleSuperclassPath', () {
         final __test = new InterfaceTypeImplTest();
         runJUnitTest(__test, __test.test_computeSuperinterfaceSet_singleSuperclassPath);
       });
       _ut.test('test_creation', () {
         final __test = new InterfaceTypeImplTest();
@@ skipping 76 matching lines @@
         runJUnitTest(__test, __test.test_getLeastUpperBound_sharedSuperinterface2);
       });
       _ut.test('test_getLeastUpperBound_sharedSuperinterface3', () {
         final __test = new InterfaceTypeImplTest();
         runJUnitTest(__test, __test.test_getLeastUpperBound_sharedSuperinterface3);
       });
       _ut.test('test_getLeastUpperBound_sharedSuperinterface4', () {
         final __test = new InterfaceTypeImplTest();
         runJUnitTest(__test, __test.test_getLeastUpperBound_sharedSuperinterface4);
       });
+      _ut.test('test_getLeastUpperBound_twoComparables', () {
+        final __test = new InterfaceTypeImplTest();
+        runJUnitTest(__test, __test.test_getLeastUpperBound_twoComparables);
+      });
       _ut.test('test_getLeastUpperBound_typeParameters_different', () {
         final __test = new InterfaceTypeImplTest();
         runJUnitTest(__test, __test.test_getLeastUpperBound_typeParameters_different);
       });
       _ut.test('test_getLeastUpperBound_typeParameters_same', () {
         final __test = new InterfaceTypeImplTest();
         runJUnitTest(__test, __test.test_getLeastUpperBound_typeParameters_same);
       });
       _ut.test('test_getMethod_implemented', () {
         final __test = new InterfaceTypeImplTest();
@@ skipping 64 matching lines @@
         runJUnitTest(__test, __test.test_isMoreSpecificThan_covariance);
       });
       _ut.test('test_isMoreSpecificThan_directSupertype', () {
         final __test = new InterfaceTypeImplTest();
         runJUnitTest(__test, __test.test_isMoreSpecificThan_directSupertype);
       });
       _ut.test('test_isMoreSpecificThan_dynamic', () {
         final __test = new InterfaceTypeImplTest();
         runJUnitTest(__test, __test.test_isMoreSpecificThan_dynamic);
       });
-      _ut.test('test_isMoreSpecificThan_indirectSupertype', () {
-        final __test = new InterfaceTypeImplTest();
-        runJUnitTest(__test, __test.test_isMoreSpecificThan_indirectSupertype);
-      });
       _ut.test('test_isMoreSpecificThan_self', () {
         final __test = new InterfaceTypeImplTest();
         runJUnitTest(__test, __test.test_isMoreSpecificThan_self);
       });
+      _ut.test('test_isMoreSpecificThan_transitive_interface', () {
+        final __test = new InterfaceTypeImplTest();
+        runJUnitTest(__test, __test.test_isMoreSpecificThan_transitive_interface);
+      });
+      _ut.test('test_isMoreSpecificThan_transitive_mixin', () {
+        final __test = new InterfaceTypeImplTest();
+        runJUnitTest(__test, __test.test_isMoreSpecificThan_transitive_mixin);
+      });
+      _ut.test('test_isMoreSpecificThan_transitive_recursive', () {
+        final __test = new InterfaceTypeImplTest();
+        runJUnitTest(__test, __test.test_isMoreSpecificThan_transitive_recursive);
+      });
+      _ut.test('test_isMoreSpecificThan_transitive_superclass', () {
+        final __test = new InterfaceTypeImplTest();
+        runJUnitTest(__test, __test.test_isMoreSpecificThan_transitive_superclass);
+      });
       _ut.test('test_isSubtypeOf_directSubtype', () {
         final __test = new InterfaceTypeImplTest();
         runJUnitTest(__test, __test.test_isSubtypeOf_directSubtype);
       });
       _ut.test('test_isSubtypeOf_dynamic', () {
         final __test = new InterfaceTypeImplTest();
         runJUnitTest(__test, __test.test_isSubtypeOf_dynamic);
       });
-      _ut.test('test_isSubtypeOf_indirectSubtype', () {
-        final __test = new InterfaceTypeImplTest();
-        runJUnitTest(__test, __test.test_isSubtypeOf_indirectSubtype);
-      });
       _ut.test('test_isSubtypeOf_interface', () {
         final __test = new InterfaceTypeImplTest();
         runJUnitTest(__test, __test.test_isSubtypeOf_interface);
       });
       _ut.test('test_isSubtypeOf_mixins', () {
         final __test = new InterfaceTypeImplTest();
         runJUnitTest(__test, __test.test_isSubtypeOf_mixins);
       });
       _ut.test('test_isSubtypeOf_object', () {
         final __test = new InterfaceTypeImplTest();
         runJUnitTest(__test, __test.test_isSubtypeOf_object);
       });
       _ut.test('test_isSubtypeOf_self', () {
         final __test = new InterfaceTypeImplTest();
         runJUnitTest(__test, __test.test_isSubtypeOf_self);
       });
+      _ut.test('test_isSubtypeOf_transitive_recursive', () {
+        final __test = new InterfaceTypeImplTest();
+        runJUnitTest(__test, __test.test_isSubtypeOf_transitive_recursive);
+      });
+      _ut.test('test_isSubtypeOf_transitive_superclass', () {
+        final __test = new InterfaceTypeImplTest();
+        runJUnitTest(__test, __test.test_isSubtypeOf_transitive_superclass);
+      });
       _ut.test('test_isSubtypeOf_typeArguments', () {
         final __test = new InterfaceTypeImplTest();
         runJUnitTest(__test, __test.test_isSubtypeOf_typeArguments);
       });
       _ut.test('test_isSupertypeOf_directSupertype', () {
         final __test = new InterfaceTypeImplTest();
         runJUnitTest(__test, __test.test_isSupertypeOf_directSupertype);
       });
       _ut.test('test_isSupertypeOf_dynamic', () {
         final __test = new InterfaceTypeImplTest();
@@ skipping 20 matching lines @@
         runJUnitTest(__test, __test.test_isSupertypeOf_self);
       });
       _ut.test('test_lookUpGetter_implemented', () {
         final __test = new InterfaceTypeImplTest();
         runJUnitTest(__test, __test.test_lookUpGetter_implemented);
       });
       _ut.test('test_lookUpGetter_inherited', () {
         final __test = new InterfaceTypeImplTest();
         runJUnitTest(__test, __test.test_lookUpGetter_inherited);
       });
+      _ut.test('test_lookUpGetter_recursive', () {
+        final __test = new InterfaceTypeImplTest();
+        runJUnitTest(__test, __test.test_lookUpGetter_recursive);
+      });
       _ut.test('test_lookUpGetter_unimplemented', () {
         final __test = new InterfaceTypeImplTest();
         runJUnitTest(__test, __test.test_lookUpGetter_unimplemented);
       });
       _ut.test('test_lookUpMethod_implemented', () {
         final __test = new InterfaceTypeImplTest();
         runJUnitTest(__test, __test.test_lookUpMethod_implemented);
       });
       _ut.test('test_lookUpMethod_inherited', () {
         final __test = new InterfaceTypeImplTest();
         runJUnitTest(__test, __test.test_lookUpMethod_inherited);
       });
       _ut.test('test_lookUpMethod_parameterized', () {
         final __test = new InterfaceTypeImplTest();
         runJUnitTest(__test, __test.test_lookUpMethod_parameterized);
       });
+      _ut.test('test_lookUpMethod_recursive', () {
+        final __test = new InterfaceTypeImplTest();
+        runJUnitTest(__test, __test.test_lookUpMethod_recursive);
+      });
       _ut.test('test_lookUpMethod_unimplemented', () {
         final __test = new InterfaceTypeImplTest();
         runJUnitTest(__test, __test.test_lookUpMethod_unimplemented);
       });
       _ut.test('test_lookUpSetter_implemented', () {
         final __test = new InterfaceTypeImplTest();
         runJUnitTest(__test, __test.test_lookUpSetter_implemented);
       });
       _ut.test('test_lookUpSetter_inherited', () {
         final __test = new InterfaceTypeImplTest();
         runJUnitTest(__test, __test.test_lookUpSetter_inherited);
       });
+      _ut.test('test_lookUpSetter_recursive', () {
+        final __test = new InterfaceTypeImplTest();
+        runJUnitTest(__test, __test.test_lookUpSetter_recursive);
+      });
       _ut.test('test_lookUpSetter_unimplemented', () {
         final __test = new InterfaceTypeImplTest();
         runJUnitTest(__test, __test.test_lookUpSetter_unimplemented);
       });
       _ut.test('test_setTypeArguments', () {
         final __test = new InterfaceTypeImplTest();
         runJUnitTest(__test, __test.test_setTypeArguments);
       });
       _ut.test('test_substitute_equal', () {
         final __test = new InterfaceTypeImplTest();
@@ skipping 42 matching lines @@
         final __test = new TypeVariableTypeImplTest();
         runJUnitTest(__test, __test.test_substitute_equal);
       });
       _ut.test('test_substitute_notEqual', () {
         final __test = new TypeVariableTypeImplTest();
         runJUnitTest(__test, __test.test_substitute_notEqual);
       });
     });
   }
 }
+
 /**
  * The class {@code ElementFactory} defines utility methods used to create elements for testing
  * purposes. The elements that are created are complete in the sense that as much of the element
  * model as can be created, given the provided information, has been created.
  */
 class ElementFactory {
+  
   /**
    * The element representing the class 'Object'.
    */
   static ClassElementImpl _objectElement;
   static ClassElementImpl classElement(String typeName, InterfaceType superclassType, List<String> parameterNames) {
     ClassElementImpl element = new ClassElementImpl(ASTFactory.identifier3(typeName));
     element.supertype = superclassType;
     InterfaceTypeImpl type = new InterfaceTypeImpl.con1(element);
     element.type = type;
     int count = parameterNames.length;
     if (count > 0) {
       List<TypeVariableElementImpl> typeVariables = new List<TypeVariableElementImpl>(count);
       List<TypeVariableTypeImpl> typeArguments = new List<TypeVariableTypeImpl>(count);
       for (int i = 0; i < count; i++) {
         TypeVariableElementImpl variable = new TypeVariableElementImpl(ASTFactory.identifier3(parameterNames[i]));
         typeVariables[i] = variable;
         typeArguments[i] = new TypeVariableTypeImpl(variable);
         variable.type = typeArguments[i];
       }
       element.typeVariables = typeVariables;
       type.typeArguments = typeArguments;
     }
     return element;
   }
   static ClassElementImpl classElement2(String typeName, List<String> parameterNames) => classElement(typeName, object.type, parameterNames);
-  static ConstructorElementImpl constructorElement(String name) => new ConstructorElementImpl(name == null ? null : ASTFactory.identifier3(name));
+  static ConstructorElementImpl constructorElement(ClassElement clazz, String name) {
+    Type2 type2 = clazz.type;
+    ConstructorElementImpl constructor = new ConstructorElementImpl(name == null ? null : ASTFactory.identifier3(name));
+    FunctionTypeImpl constructorType = new FunctionTypeImpl.con1(constructor);
+    constructorType.normalParameterTypes = <Type2> [type2];
+    constructorType.returnType = type2;
+    constructor.type = constructorType;
+    return constructor;
+  }
   static ExportElementImpl exportFor(LibraryElement exportedLibrary2, List<NamespaceCombinator> combinators2) {
     ExportElementImpl spec = new ExportElementImpl();
     spec.exportedLibrary = exportedLibrary2;
     spec.combinators = combinators2;
     return spec;
   }
   static FieldElementImpl fieldElement(String name, bool isStatic, bool isFinal, bool isConst, Type2 type2) {
     FieldElementImpl field = new FieldElementImpl.con1(ASTFactory.identifier3(name));
     field.const3 = isConst;
     field.final2 = isFinal;
     field.static = isStatic;
     field.type = type2;
     PropertyAccessorElementImpl getter = new PropertyAccessorElementImpl.con2(field);
     getter.getter = true;
+    getter.static = isStatic;
     getter.synthetic = true;
+    getter.variable = field;
     field.getter = getter;
     FunctionTypeImpl getterType = new FunctionTypeImpl.con1(getter);
     getterType.returnType = type2;
     getter.type = getterType;
     if (!isConst && !isFinal) {
       PropertyAccessorElementImpl setter = new PropertyAccessorElementImpl.con2(field);
       setter.setter = true;
+      setter.static = isStatic;
       setter.synthetic = true;
+      setter.variable = field;
       field.setter = setter;
       FunctionTypeImpl setterType = new FunctionTypeImpl.con1(getter);
       setterType.normalParameterTypes = <Type2> [type2];
       setterType.returnType = VoidTypeImpl.instance;
       setter.type = setterType;
     }
     return field;
   }
   static FieldFormalParameterElementImpl fieldFormalParameter(Identifier name) => new FieldFormalParameterElementImpl(name);
   static FunctionElementImpl functionElement(String functionName) => functionElement4(functionName, null, null, null, null);
   static FunctionElementImpl functionElement2(String functionName, ClassElement returnElement) => functionElement3(functionName, returnElement, null, null);
   static FunctionElementImpl functionElement3(String functionName, ClassElement returnElement, List<ClassElement> normalParameters, List<ClassElement> optionalParameters) {
     FunctionElementImpl functionElement = new FunctionElementImpl.con1(ASTFactory.identifier3(functionName));
     FunctionTypeImpl functionType = new FunctionTypeImpl.con1(functionElement);
     functionElement.type = functionType;
     if (returnElement != null) {
       functionType.returnType = returnElement.type;
     }
-    int count = normalParameters == null ? 0 : normalParameters.length;
-    if (count > 0) {
-      List<InterfaceType> normalParameterTypes = new List<InterfaceType>(count);
-      for (int i = 0; i < count; i++) {
+    int normalCount = normalParameters == null ? 0 : normalParameters.length;
+    if (normalCount > 0) {
+      List<InterfaceType> normalParameterTypes = new List<InterfaceType>(normalCount);
+      for (int i = 0; i < normalCount; i++) {
         normalParameterTypes[i] = normalParameters[i].type;
       }
       functionType.normalParameterTypes = normalParameterTypes;
     }
-    count = optionalParameters == null ? 0 : optionalParameters.length;
-    if (count > 0) {
-      List<InterfaceType> optionalParameterTypes = new List<InterfaceType>(count);
-      for (int i = 0; i < count; i++) {
+    int optionalCount = optionalParameters == null ? 0 : optionalParameters.length;
+    if (optionalCount > 0) {
+      List<InterfaceType> optionalParameterTypes = new List<InterfaceType>(optionalCount);
+      for (int i = 0; i < optionalCount; i++) {
         optionalParameterTypes[i] = optionalParameters[i].type;
       }
       functionType.optionalParameterTypes = optionalParameterTypes;
     }
+    int totalCount = normalCount + optionalCount;
+    List<ParameterElement> parameters = new List<ParameterElement>(totalCount);
+    for (int i = 0; i < totalCount; i++) {
+      ParameterElementImpl parameter = new ParameterElementImpl(ASTFactory.identifier3("a${i}"));
+      if (i < normalCount) {
+        parameter.type = normalParameters[i].type;
+        parameter.parameterKind = ParameterKind.REQUIRED;
+      } else {
+        parameter.type = optionalParameters[i - normalCount].type;
+        parameter.parameterKind = ParameterKind.POSITIONAL;
+      }
+      parameters[i] = parameter;
+    }
+    functionElement.parameters = parameters;
     return functionElement;
   }
   static FunctionElementImpl functionElement4(String functionName, ClassElement returnElement, List<ClassElement> normalParameters, List<String> names, List<ClassElement> namedParameters) {
     FunctionElementImpl functionElement = new FunctionElementImpl.con1(ASTFactory.identifier3(functionName));
     FunctionTypeImpl functionType = new FunctionTypeImpl.con1(functionElement);
     functionElement.type = functionType;
     if (returnElement != null) {
       functionType.returnType = returnElement.type;
     }
     int count = normalParameters == null ? 0 : normalParameters.length;
@@ skipping 24 matching lines @@
     }
     return _objectElement;
   }
   static PropertyAccessorElementImpl getterElement(String name, bool isStatic, Type2 type2) {
     FieldElementImpl field = new FieldElementImpl.con1(ASTFactory.identifier3(name));
     field.static = isStatic;
     field.synthetic = true;
     field.type = type2;
     PropertyAccessorElementImpl getter = new PropertyAccessorElementImpl.con2(field);
     getter.getter = true;
+    getter.static = isStatic;
+    getter.variable = field;
     field.getter = getter;
     FunctionTypeImpl getterType = new FunctionTypeImpl.con1(getter);
     getterType.returnType = type2;
     getter.type = getterType;
     return getter;
   }
   static ImportElementImpl importFor(LibraryElement importedLibrary2, PrefixElement prefix2, List<NamespaceCombinator> combinators2) {
     ImportElementImpl spec = new ImportElementImpl();
     spec.importedLibrary = importedLibrary2;
     spec.prefix = prefix2;
@@ skipping 44 matching lines @@
     parameter.parameterKind = ParameterKind.REQUIRED;
     return parameter;
   }
   static PropertyAccessorElementImpl setterElement(String name, bool isStatic, Type2 type2) {
     FieldElementImpl field = new FieldElementImpl.con1(ASTFactory.identifier3(name));
     field.static = isStatic;
     field.synthetic = true;
     field.type = type2;
     PropertyAccessorElementImpl getter = new PropertyAccessorElementImpl.con2(field);
     getter.getter = true;
+    getter.static = isStatic;
+    getter.variable = field;
     field.getter = getter;
     FunctionTypeImpl getterType = new FunctionTypeImpl.con1(getter);
     getterType.returnType = type2;
     getter.type = getterType;
     PropertyAccessorElementImpl setter = new PropertyAccessorElementImpl.con2(field);
     setter.setter = true;
+    setter.static = isStatic;
     setter.synthetic = true;
+    setter.variable = field;
     field.setter = setter;
     FunctionTypeImpl setterType = new FunctionTypeImpl.con1(getter);
     setterType.normalParameterTypes = <Type2> [type2];
     setterType.returnType = VoidTypeImpl.instance;
     setter.type = setterType;
     return setter;
   }
   static TopLevelVariableElementImpl topLevelVariableElement(Identifier name) => new TopLevelVariableElementImpl.con1(name);
   static TopLevelVariableElementImpl topLevelVariableElement2(String name) => new TopLevelVariableElementImpl.con2(name);
-  /**
-   * Prevent the creation of instances of this class.
-   */
-  ElementFactory() {
+  static TopLevelVariableElementImpl topLevelVariableElement3(String name, bool isFinal, Type2 type2) {
+    TopLevelVariableElementImpl variable = new TopLevelVariableElementImpl.con2(name);
+    variable.final2 = isFinal;
+    PropertyAccessorElementImpl getter = new PropertyAccessorElementImpl.con2(variable);
+    getter.getter = true;
+    getter.static = true;
+    getter.synthetic = true;
+    getter.variable = variable;
+    variable.getter = getter;
+    FunctionTypeImpl getterType = new FunctionTypeImpl.con1(getter);
+    getterType.returnType = type2;
+    getter.type = getterType;
+    if (!isFinal) {
+      PropertyAccessorElementImpl setter = new PropertyAccessorElementImpl.con2(variable);
+      setter.setter = true;
+      setter.static = true;
+      setter.synthetic = true;
+      setter.variable = variable;
+      variable.setter = setter;
+      FunctionTypeImpl setterType = new FunctionTypeImpl.con1(getter);
+      setterType.normalParameterTypes = <Type2> [type2];
+      setterType.returnType = VoidTypeImpl.instance;
+      setter.type = setterType;
+    }
+    return variable;
   }
 }
 class ElementKindTest extends EngineTestCase {
   void test_of_nonNull() {
     JUnitTestCase.assertSame(ElementKind.CLASS, ElementKind.of(ElementFactory.classElement2("A", [])));
   }
   void test_of_null() {
     JUnitTestCase.assertSame(ElementKind.ERROR, ElementKind.of(null));
   }
   static dartSuite() {
@@ skipping 37 matching lines @@
     InterfaceType typeC = classC.type;
     classC.mixins = <InterfaceType> [typeB];
     List<InterfaceType> supers = classC.allSupertypes;
     List<InterfaceType> types = new List<InterfaceType>();
     types.addAll(supers);
     JUnitTestCase.assertFalse(types.contains(typeA));
     JUnitTestCase.assertTrue(types.contains(typeB));
     JUnitTestCase.assertTrue(types.contains(typeObject));
     JUnitTestCase.assertFalse(types.contains(typeC));
   }
+  void test_getAllSupertypes_recursive() {
+    ClassElementImpl classA = ElementFactory.classElement2("A", []);
+    ClassElementImpl classB = ElementFactory.classElement("B", classA.type, []);
+    classA.supertype = classB.type;
+    List<InterfaceType> supers = classB.allSupertypes;
+    EngineTestCase.assertLength(1, supers);
+  }
   void test_getMethod_declared() {
     ClassElementImpl classA = ElementFactory.classElement2("A", []);
     String methodName = "m";
     MethodElement method = ElementFactory.methodElement(methodName, null, []);
     classA.methods = <MethodElement> [method];
     JUnitTestCase.assertSame(method, classA.getMethod(methodName));
-    JUnitTestCase.assertSame(method, classA.getExecutable(methodName));
   }
   void test_getMethod_undeclared() {
     ClassElementImpl classA = ElementFactory.classElement2("A", []);
     String methodName = "m";
     MethodElement method = ElementFactory.methodElement(methodName, null, []);
     classA.methods = <MethodElement> [method];
     JUnitTestCase.assertNull(classA.getMethod("${methodName}x"));
-    JUnitTestCase.assertNull(classA.getExecutable("${methodName}x"));
+  }
+  void test_hasNonFinalField_false_const() {
+    ClassElementImpl classA = ElementFactory.classElement2("A", []);
+    classA.fields = <FieldElement> [ElementFactory.fieldElement("f", false, false, true, classA.type)];
+    JUnitTestCase.assertFalse(classA.hasNonFinalField());
+  }
+  void test_hasNonFinalField_false_final() {
+    ClassElementImpl classA = ElementFactory.classElement2("A", []);
+    classA.fields = <FieldElement> [ElementFactory.fieldElement("f", false, true, false, classA.type)];
+    JUnitTestCase.assertFalse(classA.hasNonFinalField());
+  }
+  void test_hasNonFinalField_false_recursive() {
+    ClassElementImpl classA = ElementFactory.classElement2("A", []);
+    ClassElementImpl classB = ElementFactory.classElement("B", classA.type, []);
+    classA.supertype = classB.type;
+    JUnitTestCase.assertFalse(classA.hasNonFinalField());
+  }
+  void test_hasNonFinalField_true_immediate() {
+    ClassElementImpl classA = ElementFactory.classElement2("A", []);
+    classA.fields = <FieldElement> [ElementFactory.fieldElement("f", false, false, false, classA.type)];
+    JUnitTestCase.assertTrue(classA.hasNonFinalField());
+  }
+  void test_hasNonFinalField_true_inherited() {
+    ClassElementImpl classA = ElementFactory.classElement2("A", []);
+    ClassElementImpl classB = ElementFactory.classElement("B", classA.type, []);
+    classA.fields = <FieldElement> [ElementFactory.fieldElement("f", false, false, false, classA.type)];
+    JUnitTestCase.assertTrue(classB.hasNonFinalField());
   }
   void test_lookUpGetter_declared() {
     LibraryElementImpl library2 = ElementFactory.library(createAnalysisContext(), "lib");
     ClassElementImpl classA = ElementFactory.classElement2("A", []);
     String getterName = "g";
     PropertyAccessorElement getter = ElementFactory.getterElement(getterName, false, null);
     classA.accessors = <PropertyAccessorElement> [getter];
     ((library2.definingCompilationUnit as CompilationUnitElementImpl)).types = <ClassElement> [classA];
     JUnitTestCase.assertSame(getter, classA.lookUpGetter(getterName, library2));
-    JUnitTestCase.assertSame(getter, classA.lookUpExecutable(getterName, library2));
   }
   void test_lookUpGetter_inherited() {
     LibraryElementImpl library2 = ElementFactory.library(createAnalysisContext(), "lib");
     ClassElementImpl classA = ElementFactory.classElement2("A", []);
     String getterName = "g";
     PropertyAccessorElement getter = ElementFactory.getterElement(getterName, false, null);
     classA.accessors = <PropertyAccessorElement> [getter];
     ClassElementImpl classB = ElementFactory.classElement("B", classA.type, []);
     ((library2.definingCompilationUnit as CompilationUnitElementImpl)).types = <ClassElement> [classA, classB];
     JUnitTestCase.assertSame(getter, classB.lookUpGetter(getterName, library2));
-    JUnitTestCase.assertSame(getter, classB.lookUpExecutable(getterName, library2));
   }
   void test_lookUpGetter_undeclared() {
     LibraryElementImpl library2 = ElementFactory.library(createAnalysisContext(), "lib");
     ClassElementImpl classA = ElementFactory.classElement2("A", []);
     ((library2.definingCompilationUnit as CompilationUnitElementImpl)).types = <ClassElement> [classA];
     JUnitTestCase.assertNull(classA.lookUpGetter("g", library2));
-    JUnitTestCase.assertNull(classA.lookUpExecutable("g", library2));
+  }
+  void test_lookUpGetter_undeclared_recursive() {
+    LibraryElementImpl library2 = ElementFactory.library(createAnalysisContext(), "lib");
+    ClassElementImpl classA = ElementFactory.classElement2("A", []);
+    ClassElementImpl classB = ElementFactory.classElement("B", classA.type, []);
+    classA.supertype = classB.type;
+    ((library2.definingCompilationUnit as CompilationUnitElementImpl)).types = <ClassElement> [classA, classB];
+    JUnitTestCase.assertNull(classA.lookUpGetter("g", library2));
   }
   void test_lookUpMethod_declared() {
     LibraryElementImpl library2 = ElementFactory.library(createAnalysisContext(), "lib");
     ClassElementImpl classA = ElementFactory.classElement2("A", []);
     String methodName = "m";
     MethodElement method = ElementFactory.methodElement(methodName, null, []);
     classA.methods = <MethodElement> [method];
     ((library2.definingCompilationUnit as CompilationUnitElementImpl)).types = <ClassElement> [classA];
     JUnitTestCase.assertSame(method, classA.lookUpMethod(methodName, library2));
-    JUnitTestCase.assertSame(method, classA.lookUpExecutable(methodName, library2));
   }
   void test_lookUpMethod_inherited() {
     LibraryElementImpl library2 = ElementFactory.library(createAnalysisContext(), "lib");
     ClassElementImpl classA = ElementFactory.classElement2("A", []);
     String methodName = "m";
     MethodElement method = ElementFactory.methodElement(methodName, null, []);
     classA.methods = <MethodElement> [method];
     ClassElementImpl classB = ElementFactory.classElement("B", classA.type, []);
     ((library2.definingCompilationUnit as CompilationUnitElementImpl)).types = <ClassElement> [classA, classB];
     JUnitTestCase.assertSame(method, classB.lookUpMethod(methodName, library2));
-    JUnitTestCase.assertSame(method, classB.lookUpExecutable(methodName, library2));
   }
   void test_lookUpMethod_undeclared() {
     LibraryElementImpl library2 = ElementFactory.library(createAnalysisContext(), "lib");
     ClassElementImpl classA = ElementFactory.classElement2("A", []);
     ((library2.definingCompilationUnit as CompilationUnitElementImpl)).types = <ClassElement> [classA];
     JUnitTestCase.assertNull(classA.lookUpMethod("m", library2));
-    JUnitTestCase.assertNull(classA.lookUpExecutable("m", library2));
+  }
+  void test_lookUpMethod_undeclared_recursive() {
+    LibraryElementImpl library2 = ElementFactory.library(createAnalysisContext(), "lib");
+    ClassElementImpl classA = ElementFactory.classElement2("A", []);
+    ClassElementImpl classB = ElementFactory.classElement("B", classA.type, []);
+    classA.supertype = classB.type;
+    ((library2.definingCompilationUnit as CompilationUnitElementImpl)).types = <ClassElement> [classA, classB];
+    JUnitTestCase.assertNull(classA.lookUpMethod("m", library2));
   }
   void test_lookUpSetter_declared() {
     LibraryElementImpl library2 = ElementFactory.library(createAnalysisContext(), "lib");
     ClassElementImpl classA = ElementFactory.classElement2("A", []);
     String setterName = "s";
     PropertyAccessorElement setter = ElementFactory.setterElement(setterName, false, null);
     classA.accessors = <PropertyAccessorElement> [setter];
     ((library2.definingCompilationUnit as CompilationUnitElementImpl)).types = <ClassElement> [classA];
     JUnitTestCase.assertSame(setter, classA.lookUpSetter(setterName, library2));
-    JUnitTestCase.assertSame(setter, classA.lookUpExecutable(setterName, library2));
   }
   void test_lookUpSetter_inherited() {
     LibraryElementImpl library2 = ElementFactory.library(createAnalysisContext(), "lib");
     ClassElementImpl classA = ElementFactory.classElement2("A", []);
     String setterName = "s";
     PropertyAccessorElement setter = ElementFactory.setterElement(setterName, false, null);
     classA.accessors = <PropertyAccessorElement> [setter];
     ClassElementImpl classB = ElementFactory.classElement("B", classA.type, []);
     ((library2.definingCompilationUnit as CompilationUnitElementImpl)).types = <ClassElement> [classA, classB];
     JUnitTestCase.assertSame(setter, classB.lookUpSetter(setterName, library2));
-    JUnitTestCase.assertSame(setter, classB.lookUpExecutable(setterName, library2));
   }
   void test_lookUpSetter_undeclared() {
     LibraryElementImpl library2 = ElementFactory.library(createAnalysisContext(), "lib");
     ClassElementImpl classA = ElementFactory.classElement2("A", []);
     ((library2.definingCompilationUnit as CompilationUnitElementImpl)).types = <ClassElement> [classA];
     JUnitTestCase.assertNull(classA.lookUpSetter("s", library2));
-    JUnitTestCase.assertNull(classA.lookUpExecutable("s", library2));
+  }
+  void test_lookUpSetter_undeclared_recursive() {
+    LibraryElementImpl library2 = ElementFactory.library(createAnalysisContext(), "lib");
+    ClassElementImpl classA = ElementFactory.classElement2("A", []);
+    ClassElementImpl classB = ElementFactory.classElement("B", classA.type, []);
+    classA.supertype = classB.type;
+    ((library2.definingCompilationUnit as CompilationUnitElementImpl)).types = <ClassElement> [classA, classB];
+    JUnitTestCase.assertNull(classA.lookUpSetter("s", library2));
   }
   static dartSuite() {
     _ut.group('ClassElementImplTest', () {
       _ut.test('test_getAllSupertypes_interface', () {
         final __test = new ClassElementImplTest();
         runJUnitTest(__test, __test.test_getAllSupertypes_interface);
       });
       _ut.test('test_getAllSupertypes_mixins', () {
         final __test = new ClassElementImplTest();
         runJUnitTest(__test, __test.test_getAllSupertypes_mixins);
       });
+      _ut.test('test_getAllSupertypes_recursive', () {
+        final __test = new ClassElementImplTest();
+        runJUnitTest(__test, __test.test_getAllSupertypes_recursive);
+      });
       _ut.test('test_getMethod_declared', () {
         final __test = new ClassElementImplTest();
         runJUnitTest(__test, __test.test_getMethod_declared);
       });
       _ut.test('test_getMethod_undeclared', () {
         final __test = new ClassElementImplTest();
         runJUnitTest(__test, __test.test_getMethod_undeclared);
       });
+      _ut.test('test_hasNonFinalField_false_const', () {
+        final __test = new ClassElementImplTest();
+        runJUnitTest(__test, __test.test_hasNonFinalField_false_const);
+      });
+      _ut.test('test_hasNonFinalField_false_final', () {
+        final __test = new ClassElementImplTest();
+        runJUnitTest(__test, __test.test_hasNonFinalField_false_final);
+      });
+      _ut.test('test_hasNonFinalField_false_recursive', () {
+        final __test = new ClassElementImplTest();
+        runJUnitTest(__test, __test.test_hasNonFinalField_false_recursive);
+      });
+      _ut.test('test_hasNonFinalField_true_immediate', () {
+        final __test = new ClassElementImplTest();
+        runJUnitTest(__test, __test.test_hasNonFinalField_true_immediate);
+      });
+      _ut.test('test_hasNonFinalField_true_inherited', () {
+        final __test = new ClassElementImplTest();
+        runJUnitTest(__test, __test.test_hasNonFinalField_true_inherited);
+      });
       _ut.test('test_lookUpGetter_declared', () {
         final __test = new ClassElementImplTest();
         runJUnitTest(__test, __test.test_lookUpGetter_declared);
       });
       _ut.test('test_lookUpGetter_inherited', () {
         final __test = new ClassElementImplTest();
         runJUnitTest(__test, __test.test_lookUpGetter_inherited);
       });
       _ut.test('test_lookUpGetter_undeclared', () {
         final __test = new ClassElementImplTest();
         runJUnitTest(__test, __test.test_lookUpGetter_undeclared);
       });
+      _ut.test('test_lookUpGetter_undeclared_recursive', () {
+        final __test = new ClassElementImplTest();
+        runJUnitTest(__test, __test.test_lookUpGetter_undeclared_recursive);
+      });
       _ut.test('test_lookUpMethod_declared', () {
         final __test = new ClassElementImplTest();
         runJUnitTest(__test, __test.test_lookUpMethod_declared);
       });
       _ut.test('test_lookUpMethod_inherited', () {
         final __test = new ClassElementImplTest();
         runJUnitTest(__test, __test.test_lookUpMethod_inherited);
       });
       _ut.test('test_lookUpMethod_undeclared', () {
         final __test = new ClassElementImplTest();
         runJUnitTest(__test, __test.test_lookUpMethod_undeclared);
       });
+      _ut.test('test_lookUpMethod_undeclared_recursive', () {
+        final __test = new ClassElementImplTest();
+        runJUnitTest(__test, __test.test_lookUpMethod_undeclared_recursive);
+      });
       _ut.test('test_lookUpSetter_declared', () {
         final __test = new ClassElementImplTest();
         runJUnitTest(__test, __test.test_lookUpSetter_declared);
       });
       _ut.test('test_lookUpSetter_inherited', () {
         final __test = new ClassElementImplTest();
         runJUnitTest(__test, __test.test_lookUpSetter_inherited);
       });
       _ut.test('test_lookUpSetter_undeclared', () {
         final __test = new ClassElementImplTest();
         runJUnitTest(__test, __test.test_lookUpSetter_undeclared);
       });
+      _ut.test('test_lookUpSetter_undeclared_recursive', () {
+        final __test = new ClassElementImplTest();
+        runJUnitTest(__test, __test.test_lookUpSetter_undeclared_recursive);
+      });
     });
   }
 }
 class ElementImplTest extends EngineTestCase {
   void test_equals() {
     LibraryElementImpl library2 = ElementFactory.library(createAnalysisContext(), "lib");
     ClassElementImpl classElement = ElementFactory.classElement2("C", []);
     ((library2.definingCompilationUnit as CompilationUnitElementImpl)).types = <ClassElement> [classElement];
     FieldElement field = ElementFactory.fieldElement("next", false, false, false, classElement.type);
     classElement.fields = <FieldElement> [field];
@@ skipping 87 matching lines @@
   void test_hashCode_element() {
     FunctionTypeImpl type = new FunctionTypeImpl.con1(new FunctionElementImpl.con1(ASTFactory.identifier3("f")));
     type.hashCode;
   }
   void test_hashCode_noElement() {
     FunctionTypeImpl type = new FunctionTypeImpl.con1((null as ExecutableElement));
     type.hashCode;
   }
   void test_isSubtypeOf_baseCase_classFunction() {
     ClassElementImpl functionElement = ElementFactory.classElement2("Function", []);
-    InterfaceTypeImpl functionType = new InterfaceTypeImpl_18(functionElement);
+    InterfaceTypeImpl functionType = new InterfaceTypeImpl_19(functionElement);
     FunctionType f = ElementFactory.functionElement("f").type;
     JUnitTestCase.assertTrue(f.isSubtypeOf(functionType));
   }
   void test_isSubtypeOf_baseCase_notFunctionType() {
     FunctionType f = ElementFactory.functionElement("f").type;
     InterfaceType t = ElementFactory.classElement2("C", []).type;
     JUnitTestCase.assertFalse(f.isSubtypeOf(t));
   }
   void test_isSubtypeOf_baseCase_null() {
     FunctionType f = ElementFactory.functionElement("f").type;
@@ skipping 79 matching lines @@
     FunctionType s = ElementFactory.functionElement5("s", <ClassElement> [b, b]).type;
     JUnitTestCase.assertFalse(t.isSubtypeOf(s));
   }
   void test_isSubtypeOf_normalParameters_tHasMoreParams() {
     ClassElement a = ElementFactory.classElement2("A", []);
     ClassElement b = ElementFactory.classElement("B", a.type, []);
     FunctionType t = ElementFactory.functionElement5("t", <ClassElement> [a, a]).type;
     FunctionType s = ElementFactory.functionElement5("s", <ClassElement> [b]).type;
     JUnitTestCase.assertFalse(t.isSubtypeOf(s));
   }
+  void test_isSubtypeOf_Object() {
+    FunctionType f = ElementFactory.functionElement("f").type;
+    InterfaceType t = ElementFactory.object.type;
+    JUnitTestCase.assertTrue(f.isSubtypeOf(t));
+  }
   void test_isSubtypeOf_optionalParameters_isAssignable() {
     ClassElement a = ElementFactory.classElement2("A", []);
     ClassElement b = ElementFactory.classElement("B", a.type, []);
     FunctionType t = ElementFactory.functionElement6("t", null, <ClassElement> [a]).type;
     FunctionType s = ElementFactory.functionElement6("s", null, <ClassElement> [b]).type;
     JUnitTestCase.assertTrue(t.isSubtypeOf(s));
     JUnitTestCase.assertTrue(s.isSubtypeOf(t));
   }
   void test_isSubtypeOf_optionalParameters_isNotAssignable() {
     FunctionType t = ElementFactory.functionElement6("t", null, <ClassElement> [ElementFactory.classElement2("A", [])]).type;
@@ skipping 161 matching lines @@
         runJUnitTest(__test, __test.test_getTypeArguments);
       });
       _ut.test('test_hashCode_element', () {
         final __test = new FunctionTypeImplTest();
         runJUnitTest(__test, __test.test_hashCode_element);
       });
       _ut.test('test_hashCode_noElement', () {
         final __test = new FunctionTypeImplTest();
         runJUnitTest(__test, __test.test_hashCode_noElement);
       });
+      _ut.test('test_isSubtypeOf_Object', () {
+        final __test = new FunctionTypeImplTest();
+        runJUnitTest(__test, __test.test_isSubtypeOf_Object);
+      });
       _ut.test('test_isSubtypeOf_baseCase_classFunction', () {
         final __test = new FunctionTypeImplTest();
         runJUnitTest(__test, __test.test_isSubtypeOf_baseCase_classFunction);
       });
       _ut.test('test_isSubtypeOf_baseCase_notFunctionType', () {
         final __test = new FunctionTypeImplTest();
         runJUnitTest(__test, __test.test_isSubtypeOf_baseCase_notFunctionType);
       });
       _ut.test('test_isSubtypeOf_baseCase_null', () {
         final __test = new FunctionTypeImplTest();
@@ skipping 111 matching lines @@
         final __test = new FunctionTypeImplTest();
         runJUnitTest(__test, __test.test_substitute2_equal);
       });
       _ut.test('test_substitute2_notEqual', () {
         final __test = new FunctionTypeImplTest();
         runJUnitTest(__test, __test.test_substitute2_notEqual);
       });
     });
   }
 }
-class InterfaceTypeImpl_18 extends InterfaceTypeImpl {
-  InterfaceTypeImpl_18(ClassElement arg0) : super.con1(arg0);
+class InterfaceTypeImpl_19 extends InterfaceTypeImpl {
+  InterfaceTypeImpl_19(ClassElement arg0) : super.con1(arg0);
   bool isDartCoreFunction() => true;
 }
 main() {
   ElementKindTest.dartSuite();
   FunctionTypeImplTest.dartSuite();
   InterfaceTypeImplTest.dartSuite();
   TypeVariableTypeImplTest.dartSuite();
   ClassElementImplTest.dartSuite();
   ElementLocationImplTest.dartSuite();
   ElementImplTest.dartSuite();
   LibraryElementImplTest.dartSuite();
 }