New analyzer_experimental snapshot.

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 'package:analyzer_experimental/src/generated/java_core.dart';
 import 'package:analyzer_experimental/src/generated/java_engine_io.dart';
 import 'package:analyzer_experimental/src/generated/java_junit.dart';
 import 'package:analyzer_experimental/src/generated/source_io.dart';
 import 'package:analyzer_experimental/src/generated/utilities_dart.dart';
 import 'package:analyzer_experimental/src/generated/ast.dart';
 import 'package:analyzer_experimental/src/generated/element.dart';
@@ skipping 186 matching lines @@
         final __test = new LibraryElementImplTest();
         runJUnitTest(__test, __test.test_isUpToDate);
       });
       _ut.test('test_setImports', () {
         final __test = new LibraryElementImplTest();
         runJUnitTest(__test, __test.test_setImports);
       });
     });
   }
 }
+class TypeParameterTypeImplTest extends EngineTestCase {
+  void fail_isMoreSpecificThan_typeArguments_object() {
+    TypeParameterElementImpl element = new TypeParameterElementImpl(ASTFactory.identifier3("E"));
+    TypeParameterTypeImpl type = new TypeParameterTypeImpl(element);
+    JUnitTestCase.assertTrue(type.isMoreSpecificThan(ElementFactory.object.type));
+  }
+  void fail_isMoreSpecificThan_typeArguments_self() {
+    TypeParameterElementImpl element = new TypeParameterElementImpl(ASTFactory.identifier3("E"));
+    TypeParameterTypeImpl type = new TypeParameterTypeImpl(element);
+    JUnitTestCase.assertTrue(type.isMoreSpecificThan(type));
+  }
+  void test_creation() {
+    JUnitTestCase.assertNotNull(new TypeParameterTypeImpl(new TypeParameterElementImpl(ASTFactory.identifier3("E"))));
+  }
+  void test_getElement() {
+    TypeParameterElementImpl element = new TypeParameterElementImpl(ASTFactory.identifier3("E"));
+    TypeParameterTypeImpl type = new TypeParameterTypeImpl(element);
+    JUnitTestCase.assertEquals(element, type.element);
+  }
+  void test_isMoreSpecificThan_typeArguments_upperBound() {
+    ClassElementImpl classS = ElementFactory.classElement2("A", []);
+    TypeParameterElementImpl typeParameterT = new TypeParameterElementImpl(ASTFactory.identifier3("T"));
+    typeParameterT.bound = classS.type;
+    TypeParameterTypeImpl typeParameterTypeT = new TypeParameterTypeImpl(typeParameterT);
+    JUnitTestCase.assertTrue(typeParameterTypeT.isMoreSpecificThan(classS.type));
+  }
+  void test_substitute_equal() {
+    TypeParameterElementImpl element = new TypeParameterElementImpl(ASTFactory.identifier3("E"));
+    TypeParameterTypeImpl type = new TypeParameterTypeImpl(element);
+    InterfaceTypeImpl argument = new InterfaceTypeImpl.con1(new ClassElementImpl(ASTFactory.identifier3("A")));
+    TypeParameterTypeImpl parameter = new TypeParameterTypeImpl(element);
+    JUnitTestCase.assertSame(argument, type.substitute2(<Type2> [argument], <Type2> [parameter]));
+  }
+  void test_substitute_notEqual() {
+    TypeParameterTypeImpl type = new TypeParameterTypeImpl(new TypeParameterElementImpl(ASTFactory.identifier3("E")));
+    InterfaceTypeImpl argument = new InterfaceTypeImpl.con1(new ClassElementImpl(ASTFactory.identifier3("A")));
+    TypeParameterTypeImpl parameter = new TypeParameterTypeImpl(new TypeParameterElementImpl(ASTFactory.identifier3("F")));
+    JUnitTestCase.assertSame(type, type.substitute2(<Type2> [argument], <Type2> [parameter]));
+  }
+  static dartSuite() {
+    _ut.group('TypeParameterTypeImplTest', () {
+      _ut.test('test_creation', () {
+        final __test = new TypeParameterTypeImplTest();
+        runJUnitTest(__test, __test.test_creation);
+      });
+      _ut.test('test_getElement', () {
+        final __test = new TypeParameterTypeImplTest();
+        runJUnitTest(__test, __test.test_getElement);
+      });
+      _ut.test('test_isMoreSpecificThan_typeArguments_upperBound', () {
+        final __test = new TypeParameterTypeImplTest();
+        runJUnitTest(__test, __test.test_isMoreSpecificThan_typeArguments_upperBound);
+      });
+      _ut.test('test_substitute_equal', () {
+        final __test = new TypeParameterTypeImplTest();
+        runJUnitTest(__test, __test.test_substitute_equal);
+      });
+      _ut.test('test_substitute_notEqual', () {
+        final __test = new TypeParameterTypeImplTest();
+        runJUnitTest(__test, __test.test_substitute_notEqual);
+      });
+    });
+  }
+}
 class InterfaceTypeImplTest extends EngineTestCase {
 
   /**
    * The type provider used to access the types.
    */
   TestTypeProvider _typeProvider;
   void setUp() {
     _typeProvider = new TestTypeProvider();
   }
   void test_computeLongestInheritancePathToObject_multipleInterfacePaths() {
@@ skipping 952 matching lines @@
   void test_setTypeArguments() {
     InterfaceTypeImpl type = ElementFactory.classElement2("A", []).type as InterfaceTypeImpl;
     List<Type2> typeArguments = <Type2> [
         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", []);
-    TypeVariableElementImpl parameterElement = new TypeVariableElementImpl(ASTFactory.identifier3("E"));
+    TypeParameterElementImpl parameterElement = new TypeParameterElementImpl(ASTFactory.identifier3("E"));
     InterfaceTypeImpl type = new InterfaceTypeImpl.con1(classA);
-    TypeVariableTypeImpl parameter = new TypeVariableTypeImpl(parameterElement);
+    TypeParameterTypeImpl parameter = new TypeParameterTypeImpl(parameterElement);
     type.typeArguments = <Type2> [parameter];
     InterfaceType argumentType = ElementFactory.classElement2("B", []).type;
     InterfaceType result = type.substitute2(<Type2> [argumentType], <Type2> [parameter]);
     JUnitTestCase.assertEquals(classA, result.element);
     List<Type2> resultArguments = result.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(<Type2> [argumentType], <Type2> []);
       JUnitTestCase.fail("Expected to encounter exception, argument and parameter type array lengths not equal.");
     } catch (e) {
     }
   }
   void test_substitute_notEqual() {
     ClassElementImpl classA = ElementFactory.classElement2("A", []);
-    TypeVariableElementImpl parameterElement = new TypeVariableElementImpl(ASTFactory.identifier3("E"));
+    TypeParameterElementImpl parameterElement = new TypeParameterElementImpl(ASTFactory.identifier3("E"));
     InterfaceTypeImpl type = new InterfaceTypeImpl.con1(classA);
-    TypeVariableTypeImpl parameter = new TypeVariableTypeImpl(parameterElement);
+    TypeParameterTypeImpl parameter = new TypeParameterTypeImpl(parameterElement);
     type.typeArguments = <Type2> [parameter];
     InterfaceType argumentType = ElementFactory.classElement2("B", []).type;
-    TypeVariableTypeImpl parameterType = new TypeVariableTypeImpl(new TypeVariableElementImpl(ASTFactory.identifier3("F")));
+    TypeParameterTypeImpl parameterType = new TypeParameterTypeImpl(new TypeParameterElementImpl(ASTFactory.identifier3("F")));
     InterfaceType result = type.substitute2(<Type2> [argumentType], <Type2> [parameterType]);
     JUnitTestCase.assertEquals(classA, result.element);
     List<Type2> resultArguments = result.typeArguments;
     EngineTestCase.assertLength(1, resultArguments);
     JUnitTestCase.assertEquals(parameter, resultArguments[0]);
   }
   static dartSuite() {
     _ut.group('InterfaceTypeImplTest', () {
       _ut.test('test_computeLongestInheritancePathToObject_multipleInterfacePaths', () {
         final __test = new InterfaceTypeImplTest();
@@ skipping 387 matching lines @@
         final __test = new InterfaceTypeImplTest();
         runJUnitTest(__test, __test.test_substitute_exception);
       });
       _ut.test('test_substitute_notEqual', () {
         final __test = new InterfaceTypeImplTest();
         runJUnitTest(__test, __test.test_substitute_notEqual);
       });
     });
   }
 }
-class TypeVariableTypeImplTest extends EngineTestCase {
-  void fail_isMoreSpecificThan_typeArguments_object() {
-    TypeVariableElementImpl element = new TypeVariableElementImpl(ASTFactory.identifier3("E"));
-    TypeVariableTypeImpl type = new TypeVariableTypeImpl(element);
-    JUnitTestCase.assertTrue(type.isMoreSpecificThan(ElementFactory.object.type));
-  }
-  void fail_isMoreSpecificThan_typeArguments_self() {
-    TypeVariableElementImpl element = new TypeVariableElementImpl(ASTFactory.identifier3("E"));
-    TypeVariableTypeImpl type = new TypeVariableTypeImpl(element);
-    JUnitTestCase.assertTrue(type.isMoreSpecificThan(type));
-  }
-  void test_creation() {
-    JUnitTestCase.assertNotNull(new TypeVariableTypeImpl(new TypeVariableElementImpl(ASTFactory.identifier3("E"))));
-  }
-  void test_getElement() {
-    TypeVariableElementImpl element = new TypeVariableElementImpl(ASTFactory.identifier3("E"));
-    TypeVariableTypeImpl type = new TypeVariableTypeImpl(element);
-    JUnitTestCase.assertEquals(element, type.element);
-  }
-  void test_isMoreSpecificThan_typeArguments_upperBound() {
-    ClassElementImpl classS = ElementFactory.classElement2("A", []);
-    TypeVariableElementImpl typeVarT = new TypeVariableElementImpl(ASTFactory.identifier3("T"));
-    typeVarT.bound = classS.type;
-    TypeVariableTypeImpl typeVarTypeT = new TypeVariableTypeImpl(typeVarT);
-    JUnitTestCase.assertTrue(typeVarTypeT.isMoreSpecificThan(classS.type));
-  }
-  void test_substitute_equal() {
-    TypeVariableElementImpl element = new TypeVariableElementImpl(ASTFactory.identifier3("E"));
-    TypeVariableTypeImpl type = new TypeVariableTypeImpl(element);
-    InterfaceTypeImpl argument = new InterfaceTypeImpl.con1(new ClassElementImpl(ASTFactory.identifier3("A")));
-    TypeVariableTypeImpl parameter = new TypeVariableTypeImpl(element);
-    JUnitTestCase.assertSame(argument, type.substitute2(<Type2> [argument], <Type2> [parameter]));
-  }
-  void test_substitute_notEqual() {
-    TypeVariableTypeImpl type = new TypeVariableTypeImpl(new TypeVariableElementImpl(ASTFactory.identifier3("E")));
-    InterfaceTypeImpl argument = new InterfaceTypeImpl.con1(new ClassElementImpl(ASTFactory.identifier3("A")));
-    TypeVariableTypeImpl parameter = new TypeVariableTypeImpl(new TypeVariableElementImpl(ASTFactory.identifier3("F")));
-    JUnitTestCase.assertSame(type, type.substitute2(<Type2> [argument], <Type2> [parameter]));
-  }
-  static dartSuite() {
-    _ut.group('TypeVariableTypeImplTest', () {
-      _ut.test('test_creation', () {
-        final __test = new TypeVariableTypeImplTest();
-        runJUnitTest(__test, __test.test_creation);
-      });
-      _ut.test('test_getElement', () {
-        final __test = new TypeVariableTypeImplTest();
-        runJUnitTest(__test, __test.test_getElement);
-      });
-      _ut.test('test_isMoreSpecificThan_typeArguments_upperBound', () {
-        final __test = new TypeVariableTypeImplTest();
-        runJUnitTest(__test, __test.test_isMoreSpecificThan_typeArguments_upperBound);
-      });
-      _ut.test('test_substitute_equal', () {
-        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 `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);
+      List<TypeParameterElementImpl> typeParameters = new List<TypeParameterElementImpl>(count);
+      List<TypeParameterTypeImpl> typeParameterTypes = new List<TypeParameterTypeImpl>(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];
+        TypeParameterElementImpl typeParameter = new TypeParameterElementImpl(ASTFactory.identifier3(parameterNames[i]));
+        typeParameters[i] = typeParameter;
+        typeParameterTypes[i] = new TypeParameterTypeImpl(typeParameter);
+        typeParameter.type = typeParameterTypes[i];
       }
-      element.typeVariables = typeVariables;
-      type.typeArguments = typeArguments;
+      element.typeParameters = typeParameters;
+      type.typeArguments = typeParameterTypes;
     }
     return element;
   }
   static ClassElementImpl classElement2(String typeName, List<String> parameterNames) => classElement(typeName, object.type, parameterNames);
   static ConstructorElementImpl constructorElement(ClassElement definingClass, String name) {
     Type2 type = definingClass.type;
     ConstructorElementImpl constructor = new ConstructorElementImpl(name == null ? null : ASTFactory.identifier3(name));
     constructor.returnType = type;
     FunctionTypeImpl constructorType = new FunctionTypeImpl.con1(constructor);
     constructor.type = constructorType;
@@ skipping 121 matching lines @@
     return getter;
   }
   static ImportElementImpl importFor(LibraryElement importedLibrary2, PrefixElement prefix2, List<NamespaceCombinator> combinators2) {
     ImportElementImpl spec = new ImportElementImpl();
     spec.importedLibrary = importedLibrary2;
     spec.prefix = prefix2;
     spec.combinators = combinators2;
     return spec;
   }
   static LibraryElementImpl library(AnalysisContext context, String libraryName) {
-    String fileName = "${libraryName}.dart";
+    String fileName = "/${libraryName}.dart";
     FileBasedSource source = new FileBasedSource.con1(context.sourceFactory.contentCache, FileUtilities2.createFile(fileName));
     CompilationUnitElementImpl unit = new CompilationUnitElementImpl(fileName);
     unit.source = source;
     LibraryElementImpl library = new LibraryElementImpl(context, ASTFactory.libraryIdentifier2([libraryName]));
     library.definingCompilationUnit = unit;
     return library;
   }
   static LocalVariableElementImpl localVariableElement(Identifier name) => new LocalVariableElementImpl(name);
   static LocalVariableElementImpl localVariableElement2(String name) => new LocalVariableElementImpl(ASTFactory.identifier3(name));
   static MethodElementImpl methodElement(String methodName, Type2 returnType2, List<Type2> argumentTypes) {
@@ skipping 516 matching lines @@
     ClassElement a = ElementFactory.classElement2("A", []);
     FunctionType t = ElementFactory.functionElement6("t", null, <ClassElement> [a]).type;
     FunctionType s = ElementFactory.functionElement5("s", <ClassElement> [a]).type;
     JUnitTestCase.assertTrue(t.isSubtypeOf(s));
     JUnitTestCase.assertFalse(s.isSubtypeOf(t));
     JUnitTestCase.assertTrue(t.isAssignableTo(s));
     JUnitTestCase.assertFalse(s.isAssignableTo(t));
   }
   void test_isSubtypeOf_baseCase_classFunction() {
     ClassElementImpl functionElement = ElementFactory.classElement2("Function", []);
-    InterfaceTypeImpl functionType = new InterfaceTypeImpl_25(functionElement);
+    InterfaceTypeImpl functionType = new InterfaceTypeImpl_22(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 166 matching lines @@
   }
   void test_isSubtypeOf_returnType_tNotAssignableToS() {
     FunctionType t = ElementFactory.functionElement2("t", ElementFactory.classElement2("A", [])).type;
     FunctionType s = ElementFactory.functionElement2("s", ElementFactory.classElement2("B", [])).type;
     JUnitTestCase.assertFalse(t.isSubtypeOf(s));
   }
   void test_isSubtypeOf_typeParameters_matchesBounds() {
     TestTypeProvider provider = new TestTypeProvider();
     InterfaceType boolType = provider.boolType;
     InterfaceType stringType = provider.stringType;
-    TypeVariableElementImpl variableB = new TypeVariableElementImpl(ASTFactory.identifier3("B"));
-    variableB.bound = boolType;
-    TypeVariableTypeImpl typeB = new TypeVariableTypeImpl(variableB);
-    TypeVariableElementImpl variableS = new TypeVariableElementImpl(ASTFactory.identifier3("S"));
-    variableS.bound = stringType;
-    TypeVariableTypeImpl typeS = new TypeVariableTypeImpl(variableS);
+    TypeParameterElementImpl parameterB = new TypeParameterElementImpl(ASTFactory.identifier3("B"));
+    parameterB.bound = boolType;
+    TypeParameterTypeImpl typeB = new TypeParameterTypeImpl(parameterB);
+    TypeParameterElementImpl parameterS = new TypeParameterElementImpl(ASTFactory.identifier3("S"));
+    parameterS.bound = stringType;
+    TypeParameterTypeImpl typeS = new TypeParameterTypeImpl(parameterS);
     FunctionElementImpl functionAliasElement = new FunctionElementImpl.con1(ASTFactory.identifier3("func"));
     functionAliasElement.parameters = <ParameterElement> [
         ElementFactory.requiredParameter2("a", typeB),
         ElementFactory.positionalParameter2("b", typeS)];
     functionAliasElement.returnType = stringType;
     FunctionTypeImpl functionAliasType = new FunctionTypeImpl.con1(functionAliasElement);
     functionAliasElement.type = functionAliasType;
     FunctionElementImpl functionElement = new FunctionElementImpl.con1(ASTFactory.identifier3("f"));
     functionElement.parameters = <ParameterElement> [
         ElementFactory.requiredParameter2("c", boolType),
@@ skipping 15 matching lines @@
     FunctionType t = ElementFactory.functionElement6("t", null, <ClassElement> [a]).type;
     FunctionType s = ElementFactory.functionElement7("s", null, <String> ["name"], <ClassElement> [a]).type;
     JUnitTestCase.assertFalse(t.isSubtypeOf(s));
     JUnitTestCase.assertFalse(s.isSubtypeOf(t));
   }
   void test_setTypeArguments() {
     ClassElementImpl enclosingClass = ElementFactory.classElement2("C", ["E"]);
     MethodElementImpl methodElement = new MethodElementImpl.con1(ASTFactory.identifier3("m"));
     enclosingClass.methods = <MethodElement> [methodElement];
     FunctionTypeImpl type = new FunctionTypeImpl.con1(methodElement);
-    Type2 expectedType = enclosingClass.typeVariables[0].type;
+    Type2 expectedType = enclosingClass.typeParameters[0].type;
     type.typeArguments = <Type2> [expectedType];
     List<Type2> arguments = type.typeArguments;
     EngineTestCase.assertLength(1, arguments);
     JUnitTestCase.assertEquals(expectedType, arguments[0]);
   }
   void test_substitute2_equal() {
     ClassElementImpl definingClass = ElementFactory.classElement2("C", ["E"]);
-    TypeVariableType parameterType = definingClass.typeVariables[0].type;
+    TypeParameterType parameterType = definingClass.typeParameters[0].type;
     MethodElementImpl functionElement = new MethodElementImpl.con1(ASTFactory.identifier3("m"));
     String namedParameterName = "c";
     functionElement.parameters = <ParameterElement> [
         ElementFactory.requiredParameter2("a", parameterType),
         ElementFactory.positionalParameter2("b", parameterType),
         ElementFactory.namedParameter2(namedParameterName, parameterType)];
     functionElement.returnType = parameterType;
     definingClass.methods = <MethodElement> [functionElement];
     FunctionTypeImpl functionType = new FunctionTypeImpl.con1(functionElement);
     functionType.typeArguments = <Type2> [parameterType];
@@ skipping 17 matching lines @@
     Type2 namedParameterType = new InterfaceTypeImpl.con1(new ClassElementImpl(ASTFactory.identifier3("C")));
     FunctionElementImpl functionElement = new FunctionElementImpl.con1(ASTFactory.identifier3("f"));
     String namedParameterName = "c";
     functionElement.parameters = <ParameterElement> [
         ElementFactory.requiredParameter2("a", normalParameterType),
         ElementFactory.positionalParameter2("b", optionalParameterType),
         ElementFactory.namedParameter2(namedParameterName, namedParameterType)];
     functionElement.returnType = returnType;
     FunctionTypeImpl functionType = new FunctionTypeImpl.con1(functionElement);
     InterfaceTypeImpl argumentType = new InterfaceTypeImpl.con1(new ClassElementImpl(ASTFactory.identifier3("D")));
-    TypeVariableTypeImpl parameterType = new TypeVariableTypeImpl(new TypeVariableElementImpl(ASTFactory.identifier3("E")));
+    TypeParameterTypeImpl parameterType = new TypeParameterTypeImpl(new TypeParameterElementImpl(ASTFactory.identifier3("E")));
     FunctionType result = functionType.substitute2(<Type2> [argumentType], <Type2> [parameterType]);
     JUnitTestCase.assertEquals(returnType, result.returnType);
     List<Type2> normalParameters = result.normalParameterTypes;
     EngineTestCase.assertLength(1, normalParameters);
     JUnitTestCase.assertEquals(normalParameterType, normalParameters[0]);
     List<Type2> optionalParameters = result.optionalParameterTypes;
     EngineTestCase.assertLength(1, optionalParameters);
     JUnitTestCase.assertEquals(optionalParameterType, optionalParameters[0]);
     Map<String, Type2> namedParameters = result.namedParameterTypes;
     EngineTestCase.assertSize2(1, namedParameters);
@@ skipping 169 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_25 extends InterfaceTypeImpl {
-  InterfaceTypeImpl_25(ClassElement arg0) : super.con1(arg0);
+class InterfaceTypeImpl_22 extends InterfaceTypeImpl {
+  InterfaceTypeImpl_22(ClassElement arg0) : super.con1(arg0);
   bool get isDartCoreFunction => true;
 }
 main() {
   ElementKindTest.dartSuite();
   FunctionTypeImplTest.dartSuite();
   InterfaceTypeImplTest.dartSuite();
-  TypeVariableTypeImplTest.dartSuite();
+  TypeParameterTypeImplTest.dartSuite();
   ClassElementImplTest.dartSuite();
   ElementLocationImplTest.dartSuite();
   ElementImplTest.dartSuite();
   LibraryElementImplTest.dartSuite();
 }