Improve java2dart code style - relax 'don't reference variable name in its initializer'.

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';
 import 'package:analyzer_experimental/src/generated/java_junit.dart';
 import 'package:analyzer_experimental/src/generated/source_io.dart';
@@ skipping 30 matching lines @@
     JUnitTestCase.assertFalse(first == "a;b;d");
   }
   void test_equals_notEqual_sameLengths() {
     ElementLocationImpl first = new ElementLocationImpl.con2("a;b;c");
     ElementLocationImpl second = new ElementLocationImpl.con2("a;b;d");
     JUnitTestCase.assertFalse(first == second);
   }
   void test_getComponents() {
     String encoding = "a;b;c";
     ElementLocationImpl location = new ElementLocationImpl.con2(encoding);
-    List<String> components2 = location.components;
-    EngineTestCase.assertLength(3, components2);
-    JUnitTestCase.assertEquals("a", components2[0]);
-    JUnitTestCase.assertEquals("b", components2[1]);
-    JUnitTestCase.assertEquals("c", components2[2]);
+    List<String> components = location.components;
+    EngineTestCase.assertLength(3, components);
+    JUnitTestCase.assertEquals("a", components[0]);
+    JUnitTestCase.assertEquals("b", components[1]);
+    JUnitTestCase.assertEquals("c", components[2]);
   }
   void test_getEncoding() {
     String encoding = "a;b;c;;d";
     ElementLocationImpl location = new ElementLocationImpl.con2(encoding);
     JUnitTestCase.assertEquals(encoding, location.encoding);
   }
   static dartSuite() {
     _ut.group('ElementLocationImplTest', () {
       _ut.test('test_create_encoding', () {
         final __test = new ElementLocationImplTest();
@@ skipping 38 matching lines @@
     LibraryElementImpl library4 = ElementFactory.library(context, "l4");
     PrefixElement prefixA = new PrefixElementImpl(ASTFactory.identifier3("a"));
     PrefixElement prefixB = new PrefixElementImpl(ASTFactory.identifier3("b"));
     List<ImportElementImpl> imports = [ElementFactory.importFor(library2, null, []), ElementFactory.importFor(library2, prefixB, []), ElementFactory.importFor(library3, null, []), ElementFactory.importFor(library3, prefixA, []), ElementFactory.importFor(library3, prefixB, []), ElementFactory.importFor(library4, prefixA, [])];
     library1.imports = imports;
     List<LibraryElement> libraries = library1.importedLibraries;
     EngineTestCase.assertEqualsIgnoreOrder(<LibraryElement> [library2, library3, library4], libraries);
   }
   void test_getPrefixes() {
     AnalysisContext context = createAnalysisContext();
-    LibraryElementImpl library2 = ElementFactory.library(context, "l1");
+    LibraryElementImpl library = ElementFactory.library(context, "l1");
     PrefixElement prefixA = new PrefixElementImpl(ASTFactory.identifier3("a"));
     PrefixElement prefixB = new PrefixElementImpl(ASTFactory.identifier3("b"));
     List<ImportElementImpl> imports = [ElementFactory.importFor(ElementFactory.library(context, "l2"), null, []), ElementFactory.importFor(ElementFactory.library(context, "l3"), null, []), ElementFactory.importFor(ElementFactory.library(context, "l4"), prefixA, []), ElementFactory.importFor(ElementFactory.library(context, "l5"), prefixA, []), ElementFactory.importFor(ElementFactory.library(context, "l6"), prefixB, [])];
-    library2.imports = imports;
-    List<PrefixElement> prefixes2 = library2.prefixes;
-    EngineTestCase.assertLength(2, prefixes2);
-    if (identical(prefixA, prefixes2[0])) {
-      JUnitTestCase.assertSame(prefixB, prefixes2[1]);
+    library.imports = imports;
+    List<PrefixElement> prefixes = library.prefixes;
+    EngineTestCase.assertLength(2, prefixes);
+    if (identical(prefixA, prefixes[0])) {
+      JUnitTestCase.assertSame(prefixB, prefixes[1]);
     } else {
-      JUnitTestCase.assertSame(prefixB, prefixes2[0]);
-      JUnitTestCase.assertSame(prefixA, prefixes2[1]);
+      JUnitTestCase.assertSame(prefixB, prefixes[0]);
+      JUnitTestCase.assertSame(prefixA, prefixes[1]);
     }
   }
   void test_isUpToDate() {
     AnalysisContext context = createAnalysisContext();
     context.sourceFactory = new SourceFactory.con2([]);
-    LibraryElement library2 = ElementFactory.library(context, "foo");
-    context.sourceFactory.setContents(library2.definingCompilationUnit.source, "sdfsdff");
-    JUnitTestCase.assertFalse(library2.isUpToDate2(0));
-    JUnitTestCase.assertTrue(library2.isUpToDate2(JavaSystem.currentTimeMillis() + 1000));
+    LibraryElement library = ElementFactory.library(context, "foo");
+    context.sourceFactory.setContents(library.definingCompilationUnit.source, "sdfsdff");
+    JUnitTestCase.assertFalse(library.isUpToDate2(0));
+    JUnitTestCase.assertTrue(library.isUpToDate2(JavaSystem.currentTimeMillis() + 1000));
   }
   void test_setImports() {
     AnalysisContext context = createAnalysisContext();
     LibraryElementImpl library = new LibraryElementImpl(context, ASTFactory.libraryIdentifier2(["l1"]));
     List<ImportElementImpl> expectedImports = [ElementFactory.importFor(ElementFactory.library(context, "l2"), null, []), ElementFactory.importFor(ElementFactory.library(context, "l3"), null, [])];
     library.imports = expectedImports;
     List<ImportElement> actualImports = library.imports;
     EngineTestCase.assertLength(expectedImports.length, actualImports);
     for (int i = 0; i < actualImports.length; i++) {
       JUnitTestCase.assertSame(expectedImports[i], actualImports[i]);
@@ skipping 206 matching lines @@
     InterfaceType typeA = classA.type;
     JUnitTestCase.assertNull(typeA.getGetter("g"));
   }
   void test_getInterfaces_nonParameterized() {
     ClassElementImpl classA = ElementFactory.classElement2("A", []);
     InterfaceType typeA = classA.type;
     ClassElementImpl classB = ElementFactory.classElement2("B", []);
     InterfaceType typeB = classB.type;
     ClassElementImpl classC = ElementFactory.classElement2("C", []);
     classC.interfaces = <InterfaceType> [typeA, typeB];
-    List<InterfaceType> interfaces2 = classC.type.interfaces;
-    EngineTestCase.assertLength(2, interfaces2);
-    if (identical(interfaces2[0], typeA)) {
-      JUnitTestCase.assertSame(typeB, interfaces2[1]);
+    List<InterfaceType> interfaces = classC.type.interfaces;
+    EngineTestCase.assertLength(2, interfaces);
+    if (identical(interfaces[0], typeA)) {
+      JUnitTestCase.assertSame(typeB, interfaces[1]);
     } else {
-      JUnitTestCase.assertSame(typeB, interfaces2[0]);
-      JUnitTestCase.assertSame(typeA, interfaces2[1]);
+      JUnitTestCase.assertSame(typeB, interfaces[0]);
+      JUnitTestCase.assertSame(typeA, interfaces[1]);
     }
   }
   void test_getInterfaces_parameterized() {
     ClassElementImpl classA = ElementFactory.classElement2("A", ["E"]);
     ClassElementImpl classB = ElementFactory.classElement2("B", ["F"]);
     InterfaceType typeB = classB.type;
     InterfaceTypeImpl typeAF = new InterfaceTypeImpl.con1(classA);
     typeAF.typeArguments = <Type2> [typeB.typeArguments[0]];
     classB.interfaces = <InterfaceType> [typeAF];
     InterfaceType typeI = ElementFactory.classElement2("I", []).type;
     InterfaceTypeImpl typeBI = new InterfaceTypeImpl.con1(classB);
     typeBI.typeArguments = <Type2> [typeI];
-    List<InterfaceType> interfaces2 = typeBI.interfaces;
-    EngineTestCase.assertLength(1, interfaces2);
-    InterfaceType result = interfaces2[0];
+    List<InterfaceType> interfaces = typeBI.interfaces;
+    EngineTestCase.assertLength(1, interfaces);
+    InterfaceType result = interfaces[0];
     JUnitTestCase.assertSame(classA, result.element);
     JUnitTestCase.assertSame(typeI, result.typeArguments[0]);
   }
   void test_getLeastUpperBound_directInterfaceCase() {
     ClassElementImpl classA = ElementFactory.classElement2("A", []);
     ClassElementImpl classB = ElementFactory.classElement2("B", []);
     ClassElementImpl classC = ElementFactory.classElement2("C", []);
     InterfaceType typeA = classA.type;
     InterfaceType typeB = classB.type;
     InterfaceType typeC = classC.type;
@@ skipping 152 matching lines @@
     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.dynamicType]), listOfIntType.getLeastUpperBound(listOfDoubleType));
+    InterfaceType listType = _typeProvider.listType;
+    InterfaceType intType = _typeProvider.intType;
+    InterfaceType doubleType = _typeProvider.doubleType;
+    InterfaceType listOfIntType = listType.substitute5(<Type2> [intType]);
+    InterfaceType listOfDoubleType = listType.substitute5(<Type2> [doubleType]);
+    JUnitTestCase.assertEquals(listType.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]);
+    InterfaceType listType = _typeProvider.listType;
+    InterfaceType intType = _typeProvider.intType;
+    InterfaceType listOfIntType = listType.substitute5(<Type2> [intType]);
     JUnitTestCase.assertEquals(listOfIntType, listOfIntType.getLeastUpperBound(listOfIntType));
   }
   void test_getMethod_implemented() {
     ClassElementImpl classA = ElementFactory.classElement2("A", []);
     String methodName = "m";
     MethodElementImpl methodM = ElementFactory.methodElement(methodName, null, []);
     classA.methods = <MethodElement> [methodM];
     InterfaceType typeA = classA.type;
     JUnitTestCase.assertSame(methodM, typeA.getMethod(methodName));
   }
@@ skipping 90 matching lines @@
   void test_getSuperclass_parameterized() {
     ClassElementImpl classA = ElementFactory.classElement2("A", ["E"]);
     ClassElementImpl classB = ElementFactory.classElement2("B", ["F"]);
     InterfaceType typeB = classB.type;
     InterfaceTypeImpl typeAF = new InterfaceTypeImpl.con1(classA);
     typeAF.typeArguments = <Type2> [typeB.typeArguments[0]];
     classB.supertype = typeAF;
     InterfaceType typeI = ElementFactory.classElement2("I", []).type;
     InterfaceTypeImpl typeBI = new InterfaceTypeImpl.con1(classB);
     typeBI.typeArguments = <Type2> [typeI];
-    InterfaceType superclass2 = typeBI.superclass;
-    JUnitTestCase.assertSame(classA, superclass2.element);
-    JUnitTestCase.assertSame(typeI, superclass2.typeArguments[0]);
+    InterfaceType superclass = typeBI.superclass;
+    JUnitTestCase.assertSame(classA, superclass.element);
+    JUnitTestCase.assertSame(typeI, superclass.typeArguments[0]);
   }
   void test_getTypeArguments_empty() {
-    InterfaceType type2 = ElementFactory.classElement2("A", []).type;
-    EngineTestCase.assertLength(0, type2.typeArguments);
+    InterfaceType type = ElementFactory.classElement2("A", []).type;
+    EngineTestCase.assertLength(0, type.typeArguments);
   }
   void test_isDirectSupertypeOf_extends() {
     ClassElement classA = ElementFactory.classElement2("A", []);
     ClassElement classB = ElementFactory.classElement("B", classA.type, []);
     InterfaceType typeA = classA.type;
     InterfaceType typeB = classB.type;
     JUnitTestCase.assertTrue(typeA.isDirectSupertypeOf(typeB));
   }
   void test_isDirectSupertypeOf_false() {
     ClassElement classA = ElementFactory.classElement2("A", []);
@@ skipping 13 matching lines @@
   }
   void test_isDirectSupertypeOf_with() {
     ClassElementImpl classA = ElementFactory.classElement2("A", []);
     ClassElementImpl classB = ElementFactory.classElement2("B", []);
     InterfaceType typeA = classA.type;
     InterfaceType typeB = classB.type;
     classB.mixins = <InterfaceType> [typeA];
     JUnitTestCase.assertTrue(typeA.isDirectSupertypeOf(typeB));
   }
   void test_isMoreSpecificThan_bottom() {
-    Type2 type2 = ElementFactory.classElement2("A", []).type;
-    JUnitTestCase.assertTrue(BottomTypeImpl.instance.isMoreSpecificThan(type2));
+    Type2 type = ElementFactory.classElement2("A", []).type;
+    JUnitTestCase.assertTrue(BottomTypeImpl.instance.isMoreSpecificThan(type));
   }
   void test_isMoreSpecificThan_covariance() {
     ClassElement classA = ElementFactory.classElement2("A", ["E"]);
     ClassElement classI = ElementFactory.classElement2("I", []);
     ClassElement classJ = ElementFactory.classElement("J", classI.type, []);
     InterfaceTypeImpl typeAI = new InterfaceTypeImpl.con1(classA);
     InterfaceTypeImpl typeAJ = new InterfaceTypeImpl.con1(classA);
     typeAI.typeArguments = <Type2> [classI.type];
     typeAJ.typeArguments = <Type2> [classJ.type];
     JUnitTestCase.assertTrue(typeAJ.isMoreSpecificThan(typeAI));
     JUnitTestCase.assertFalse(typeAI.isMoreSpecificThan(typeAJ));
   }
   void test_isMoreSpecificThan_directSupertype() {
     ClassElement classA = ElementFactory.classElement2("A", []);
     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));
+    InterfaceType type = ElementFactory.classElement2("A", []).type;
+    JUnitTestCase.assertTrue(type.isMoreSpecificThan(DynamicTypeImpl.instance));
   }
   void test_isMoreSpecificThan_self() {
-    InterfaceType type2 = ElementFactory.classElement2("A", []).type;
-    JUnitTestCase.assertTrue(type2.isMoreSpecificThan(type2));
+    InterfaceType type = ElementFactory.classElement2("A", []).type;
+    JUnitTestCase.assertTrue(type.isMoreSpecificThan(type));
   }
   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));
   }
@@ skipping 181 matching lines @@
     ClassElement classA = ElementFactory.classElement2("A", []);
     InterfaceType typeA = classA.type;
     JUnitTestCase.assertTrue(typeA.isSupertypeOf(typeA));
   }
   void test_lookUpGetter_implemented() {
     ClassElementImpl classA = ElementFactory.classElement2("A", []);
     String getterName = "g";
     PropertyAccessorElement getterG = ElementFactory.getterElement(getterName, false, null);
     classA.accessors = <PropertyAccessorElement> [getterG];
     InterfaceType typeA = classA.type;
-    LibraryElementImpl library2 = ElementFactory.library(createAnalysisContext(), "lib");
-    CompilationUnitElement unit = library2.definingCompilationUnit;
+    LibraryElementImpl library = ElementFactory.library(createAnalysisContext(), "lib");
+    CompilationUnitElement unit = library.definingCompilationUnit;
     ((unit as CompilationUnitElementImpl)).types = <ClassElement> [classA];
-    JUnitTestCase.assertSame(getterG, typeA.lookUpGetter(getterName, library2));
+    JUnitTestCase.assertSame(getterG, typeA.lookUpGetter(getterName, library));
   }
   void test_lookUpGetter_inherited() {
     ClassElementImpl classA = ElementFactory.classElement2("A", []);
     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;
+    LibraryElementImpl library = ElementFactory.library(createAnalysisContext(), "lib");
+    CompilationUnitElement unit = library.definingCompilationUnit;
     ((unit as CompilationUnitElementImpl)).types = <ClassElement> [classA, classB];
-    JUnitTestCase.assertSame(getterG, typeB.lookUpGetter(getterName, library2));
+    JUnitTestCase.assertSame(getterG, typeB.lookUpGetter(getterName, library));
   }
   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;
+    LibraryElementImpl library = ElementFactory.library(createAnalysisContext(), "lib");
+    CompilationUnitElement unit = library.definingCompilationUnit;
     ((unit as CompilationUnitElementImpl)).types = <ClassElement> [classA, classB];
-    JUnitTestCase.assertNull(typeA.lookUpGetter("g", library2));
+    JUnitTestCase.assertNull(typeA.lookUpGetter("g", library));
   }
   void test_lookUpGetter_unimplemented() {
     ClassElementImpl classA = ElementFactory.classElement2("A", []);
     InterfaceType typeA = classA.type;
-    LibraryElementImpl library2 = ElementFactory.library(createAnalysisContext(), "lib");
-    CompilationUnitElement unit = library2.definingCompilationUnit;
+    LibraryElementImpl library = ElementFactory.library(createAnalysisContext(), "lib");
+    CompilationUnitElement unit = library.definingCompilationUnit;
     ((unit as CompilationUnitElementImpl)).types = <ClassElement> [classA];
-    JUnitTestCase.assertNull(typeA.lookUpGetter("g", library2));
+    JUnitTestCase.assertNull(typeA.lookUpGetter("g", library));
   }
   void test_lookUpMethod_implemented() {
     ClassElementImpl classA = ElementFactory.classElement2("A", []);
     String methodName = "m";
     MethodElementImpl methodM = ElementFactory.methodElement(methodName, null, []);
     classA.methods = <MethodElement> [methodM];
     InterfaceType typeA = classA.type;
-    LibraryElementImpl library2 = ElementFactory.library(createAnalysisContext(), "lib");
-    CompilationUnitElement unit = library2.definingCompilationUnit;
+    LibraryElementImpl library = ElementFactory.library(createAnalysisContext(), "lib");
+    CompilationUnitElement unit = library.definingCompilationUnit;
     ((unit as CompilationUnitElementImpl)).types = <ClassElement> [classA];
-    JUnitTestCase.assertSame(methodM, typeA.lookUpMethod(methodName, library2));
+    JUnitTestCase.assertSame(methodM, typeA.lookUpMethod(methodName, library));
   }
   void test_lookUpMethod_inherited() {
     ClassElementImpl classA = ElementFactory.classElement2("A", []);
     String methodName = "m";
     MethodElementImpl methodM = ElementFactory.methodElement(methodName, null, []);
     classA.methods = <MethodElement> [methodM];
     ClassElementImpl classB = ElementFactory.classElement("B", classA.type, []);
     InterfaceType typeB = classB.type;
-    LibraryElementImpl library2 = ElementFactory.library(createAnalysisContext(), "lib");
-    CompilationUnitElement unit = library2.definingCompilationUnit;
+    LibraryElementImpl library = ElementFactory.library(createAnalysisContext(), "lib");
+    CompilationUnitElement unit = library.definingCompilationUnit;
     ((unit as CompilationUnitElementImpl)).types = <ClassElement> [classA, classB];
-    JUnitTestCase.assertSame(methodM, typeB.lookUpMethod(methodName, library2));
+    JUnitTestCase.assertSame(methodM, typeB.lookUpMethod(methodName, library));
   }
   void test_lookUpMethod_parameterized() {
     ClassElementImpl classA = ElementFactory.classElement2("A", ["E"]);
     Type2 typeE = classA.type.typeArguments[0];
     String methodName = "m";
     MethodElementImpl methodM = ElementFactory.methodElement(methodName, typeE, [typeE]);
     classA.methods = <MethodElement> [methodM];
     ClassElementImpl classB = ElementFactory.classElement2("B", ["F"]);
     InterfaceType typeB = classB.type;
     InterfaceTypeImpl typeAF = new InterfaceTypeImpl.con1(classA);
     typeAF.typeArguments = <Type2> [typeB.typeArguments[0]];
     classB.supertype = typeAF;
-    LibraryElementImpl library2 = ElementFactory.library(createAnalysisContext(), "lib");
-    CompilationUnitElement unit = library2.definingCompilationUnit;
+    LibraryElementImpl library = ElementFactory.library(createAnalysisContext(), "lib");
+    CompilationUnitElement unit = library.definingCompilationUnit;
     ((unit as CompilationUnitElementImpl)).types = <ClassElement> [classA];
     InterfaceType typeI = ElementFactory.classElement2("I", []).type;
     InterfaceTypeImpl typeBI = new InterfaceTypeImpl.con1(classB);
     typeBI.typeArguments = <Type2> [typeI];
-    MethodElement method = typeBI.lookUpMethod(methodName, library2);
+    MethodElement method = typeBI.lookUpMethod(methodName, library);
     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;
+    LibraryElementImpl library = ElementFactory.library(createAnalysisContext(), "lib");
+    CompilationUnitElement unit = library.definingCompilationUnit;
     ((unit as CompilationUnitElementImpl)).types = <ClassElement> [classA, classB];
-    JUnitTestCase.assertNull(typeA.lookUpMethod("m", library2));
+    JUnitTestCase.assertNull(typeA.lookUpMethod("m", library));
   }
   void test_lookUpMethod_unimplemented() {
     ClassElementImpl classA = ElementFactory.classElement2("A", []);
     InterfaceType typeA = classA.type;
-    LibraryElementImpl library2 = ElementFactory.library(createAnalysisContext(), "lib");
-    CompilationUnitElement unit = library2.definingCompilationUnit;
+    LibraryElementImpl library = ElementFactory.library(createAnalysisContext(), "lib");
+    CompilationUnitElement unit = library.definingCompilationUnit;
     ((unit as CompilationUnitElementImpl)).types = <ClassElement> [classA];
-    JUnitTestCase.assertNull(typeA.lookUpMethod("m", library2));
+    JUnitTestCase.assertNull(typeA.lookUpMethod("m", library));
   }
   void test_lookUpSetter_implemented() {
     ClassElementImpl classA = ElementFactory.classElement2("A", []);
     String setterName = "s";
     PropertyAccessorElement setterS = ElementFactory.setterElement(setterName, false, null);
     classA.accessors = <PropertyAccessorElement> [setterS];
     InterfaceType typeA = classA.type;
-    LibraryElementImpl library2 = ElementFactory.library(createAnalysisContext(), "lib");
-    CompilationUnitElement unit = library2.definingCompilationUnit;
+    LibraryElementImpl library = ElementFactory.library(createAnalysisContext(), "lib");
+    CompilationUnitElement unit = library.definingCompilationUnit;
     ((unit as CompilationUnitElementImpl)).types = <ClassElement> [classA];
-    JUnitTestCase.assertSame(setterS, typeA.lookUpSetter(setterName, library2));
+    JUnitTestCase.assertSame(setterS, typeA.lookUpSetter(setterName, library));
   }
   void test_lookUpSetter_inherited() {
     ClassElementImpl classA = ElementFactory.classElement2("A", []);
     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;
+    LibraryElementImpl library = ElementFactory.library(createAnalysisContext(), "lib");
+    CompilationUnitElement unit = library.definingCompilationUnit;
     ((unit as CompilationUnitElementImpl)).types = <ClassElement> [classA, classB];
-    JUnitTestCase.assertSame(setterS, typeB.lookUpSetter(setterName, library2));
+    JUnitTestCase.assertSame(setterS, typeB.lookUpSetter(setterName, library));
   }
   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;
+    LibraryElementImpl library = ElementFactory.library(createAnalysisContext(), "lib");
+    CompilationUnitElement unit = library.definingCompilationUnit;
     ((unit as CompilationUnitElementImpl)).types = <ClassElement> [classA, classB];
-    JUnitTestCase.assertNull(typeA.lookUpSetter("s", library2));
+    JUnitTestCase.assertNull(typeA.lookUpSetter("s", library));
   }
   void test_lookUpSetter_unimplemented() {
     ClassElementImpl classA = ElementFactory.classElement2("A", []);
     InterfaceType typeA = classA.type;
-    LibraryElementImpl library2 = ElementFactory.library(createAnalysisContext(), "lib");
-    CompilationUnitElement unit = library2.definingCompilationUnit;
+    LibraryElementImpl library = ElementFactory.library(createAnalysisContext(), "lib");
+    CompilationUnitElement unit = library.definingCompilationUnit;
     ((unit as CompilationUnitElementImpl)).types = <ClassElement> [classA];
-    JUnitTestCase.assertNull(typeA.lookUpSetter("s", library2));
+    JUnitTestCase.assertNull(typeA.lookUpSetter("s", library));
   }
   void test_setTypeArguments() {
-    InterfaceTypeImpl type2 = ElementFactory.classElement2("A", []).type as InterfaceTypeImpl;
+    InterfaceTypeImpl type = ElementFactory.classElement2("A", []).type as InterfaceTypeImpl;
     List<Type2> typeArguments = <Type2> [ElementFactory.classElement2("B", []).type, ElementFactory.classElement2("C", []).type];
-    type2.typeArguments = typeArguments;
-    JUnitTestCase.assertEquals(typeArguments, type2.typeArguments);
+    type.typeArguments = typeArguments;
+    JUnitTestCase.assertEquals(typeArguments, type.typeArguments);
   }
   void test_substitute_equal() {
     ClassElementImpl classA = ElementFactory.classElement2("A", []);
     TypeVariableElementImpl parameterElement = new TypeVariableElementImpl(ASTFactory.identifier3("E"));
     InterfaceTypeImpl type = new InterfaceTypeImpl.con1(classA);
     TypeVariableTypeImpl parameter = new TypeVariableTypeImpl(parameterElement);
     type.typeArguments = <Type2> [parameter];
     InterfaceType argumentType = ElementFactory.classElement2("B", []).type;
     InterfaceType result = type.substitute2(<Type2> [argumentType], <Type2> [parameter]);
     JUnitTestCase.assertEquals(classA, result.element);
@@ skipping 457 matching lines @@
         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(ClassElement clazz, String name) {
-    Type2 type2 = clazz.type;
+    Type2 type = 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;
+    constructorType.normalParameterTypes = <Type2> [type];
+    constructorType.returnType = type;
     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) {
@@ skipping 319 matching lines @@
     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");
+    LibraryElementImpl library = 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));
+    ((library.definingCompilationUnit as CompilationUnitElementImpl)).types = <ClassElement> [classA];
+    JUnitTestCase.assertSame(getter, classA.lookUpGetter(getterName, library));
   }
   void test_lookUpGetter_inherited() {
-    LibraryElementImpl library2 = ElementFactory.library(createAnalysisContext(), "lib");
+    LibraryElementImpl library = 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));
+    ((library.definingCompilationUnit as CompilationUnitElementImpl)).types = <ClassElement> [classA, classB];
+    JUnitTestCase.assertSame(getter, classB.lookUpGetter(getterName, library));
   }
   void test_lookUpGetter_undeclared() {
-    LibraryElementImpl library2 = ElementFactory.library(createAnalysisContext(), "lib");
+    LibraryElementImpl library = ElementFactory.library(createAnalysisContext(), "lib");
     ClassElementImpl classA = ElementFactory.classElement2("A", []);
-    ((library2.definingCompilationUnit as CompilationUnitElementImpl)).types = <ClassElement> [classA];
-    JUnitTestCase.assertNull(classA.lookUpGetter("g", library2));
+    ((library.definingCompilationUnit as CompilationUnitElementImpl)).types = <ClassElement> [classA];
+    JUnitTestCase.assertNull(classA.lookUpGetter("g", library));
   }
   void test_lookUpGetter_undeclared_recursive() {
-    LibraryElementImpl library2 = ElementFactory.library(createAnalysisContext(), "lib");
+    LibraryElementImpl library = 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));
+    ((library.definingCompilationUnit as CompilationUnitElementImpl)).types = <ClassElement> [classA, classB];
+    JUnitTestCase.assertNull(classA.lookUpGetter("g", library));
   }
   void test_lookUpMethod_declared() {
-    LibraryElementImpl library2 = ElementFactory.library(createAnalysisContext(), "lib");
+    LibraryElementImpl library = 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));
+    ((library.definingCompilationUnit as CompilationUnitElementImpl)).types = <ClassElement> [classA];
+    JUnitTestCase.assertSame(method, classA.lookUpMethod(methodName, library));
   }
   void test_lookUpMethod_inherited() {
-    LibraryElementImpl library2 = ElementFactory.library(createAnalysisContext(), "lib");
+    LibraryElementImpl library = 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));
+    ((library.definingCompilationUnit as CompilationUnitElementImpl)).types = <ClassElement> [classA, classB];
+    JUnitTestCase.assertSame(method, classB.lookUpMethod(methodName, library));
   }
   void test_lookUpMethod_undeclared() {
-    LibraryElementImpl library2 = ElementFactory.library(createAnalysisContext(), "lib");
+    LibraryElementImpl library = ElementFactory.library(createAnalysisContext(), "lib");
     ClassElementImpl classA = ElementFactory.classElement2("A", []);
-    ((library2.definingCompilationUnit as CompilationUnitElementImpl)).types = <ClassElement> [classA];
-    JUnitTestCase.assertNull(classA.lookUpMethod("m", library2));
+    ((library.definingCompilationUnit as CompilationUnitElementImpl)).types = <ClassElement> [classA];
+    JUnitTestCase.assertNull(classA.lookUpMethod("m", library));
   }
   void test_lookUpMethod_undeclared_recursive() {
-    LibraryElementImpl library2 = ElementFactory.library(createAnalysisContext(), "lib");
+    LibraryElementImpl library = 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));
+    ((library.definingCompilationUnit as CompilationUnitElementImpl)).types = <ClassElement> [classA, classB];
+    JUnitTestCase.assertNull(classA.lookUpMethod("m", library));
   }
   void test_lookUpSetter_declared() {
-    LibraryElementImpl library2 = ElementFactory.library(createAnalysisContext(), "lib");
+    LibraryElementImpl library = 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));
+    ((library.definingCompilationUnit as CompilationUnitElementImpl)).types = <ClassElement> [classA];
+    JUnitTestCase.assertSame(setter, classA.lookUpSetter(setterName, library));
   }
   void test_lookUpSetter_inherited() {
-    LibraryElementImpl library2 = ElementFactory.library(createAnalysisContext(), "lib");
+    LibraryElementImpl library = 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));
+    ((library.definingCompilationUnit as CompilationUnitElementImpl)).types = <ClassElement> [classA, classB];
+    JUnitTestCase.assertSame(setter, classB.lookUpSetter(setterName, library));
   }
   void test_lookUpSetter_undeclared() {
-    LibraryElementImpl library2 = ElementFactory.library(createAnalysisContext(), "lib");
+    LibraryElementImpl library = ElementFactory.library(createAnalysisContext(), "lib");
     ClassElementImpl classA = ElementFactory.classElement2("A", []);
-    ((library2.definingCompilationUnit as CompilationUnitElementImpl)).types = <ClassElement> [classA];
-    JUnitTestCase.assertNull(classA.lookUpSetter("s", library2));
+    ((library.definingCompilationUnit as CompilationUnitElementImpl)).types = <ClassElement> [classA];
+    JUnitTestCase.assertNull(classA.lookUpSetter("s", library));
   }
   void test_lookUpSetter_undeclared_recursive() {
-    LibraryElementImpl library2 = ElementFactory.library(createAnalysisContext(), "lib");
+    LibraryElementImpl library = 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));
+    ((library.definingCompilationUnit as CompilationUnitElementImpl)).types = <ClassElement> [classA, classB];
+    JUnitTestCase.assertNull(classA.lookUpSetter("s", library));
   }
   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);
@@ skipping 76 matching lines @@
       });
       _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");
+    LibraryElementImpl library = ElementFactory.library(createAnalysisContext(), "lib");
     ClassElementImpl classElement = ElementFactory.classElement2("C", []);
-    ((library2.definingCompilationUnit as CompilationUnitElementImpl)).types = <ClassElement> [classElement];
+    ((library.definingCompilationUnit as CompilationUnitElementImpl)).types = <ClassElement> [classElement];
     FieldElement field = ElementFactory.fieldElement("next", false, false, false, classElement.type);
     classElement.fields = <FieldElement> [field];
     JUnitTestCase.assertTrue(field == field);
     JUnitTestCase.assertFalse(field == field.getter);
     JUnitTestCase.assertFalse(field == field.setter);
     JUnitTestCase.assertFalse(field.getter == field.setter);
   }
   void test_isAccessibleIn_private_differentLibrary() {
     AnalysisContextImpl context = createAnalysisContext();
     LibraryElementImpl library1 = ElementFactory.library(context, "lib1");
     ClassElement classElement = ElementFactory.classElement2("_C", []);
     ((library1.definingCompilationUnit as CompilationUnitElementImpl)).types = <ClassElement> [classElement];
     LibraryElementImpl library2 = ElementFactory.library(context, "lib2");
     JUnitTestCase.assertFalse(classElement.isAccessibleIn(library2));
   }
   void test_isAccessibleIn_private_sameLibrary() {
-    LibraryElementImpl library2 = ElementFactory.library(createAnalysisContext(), "lib");
+    LibraryElementImpl library = ElementFactory.library(createAnalysisContext(), "lib");
     ClassElement classElement = ElementFactory.classElement2("_C", []);
-    ((library2.definingCompilationUnit as CompilationUnitElementImpl)).types = <ClassElement> [classElement];
-    JUnitTestCase.assertTrue(classElement.isAccessibleIn(library2));
+    ((library.definingCompilationUnit as CompilationUnitElementImpl)).types = <ClassElement> [classElement];
+    JUnitTestCase.assertTrue(classElement.isAccessibleIn(library));
   }
   void test_isAccessibleIn_public_differentLibrary() {
     AnalysisContextImpl context = createAnalysisContext();
     LibraryElementImpl library1 = ElementFactory.library(context, "lib1");
     ClassElement classElement = ElementFactory.classElement2("C", []);
     ((library1.definingCompilationUnit as CompilationUnitElementImpl)).types = <ClassElement> [classElement];
     LibraryElementImpl library2 = ElementFactory.library(context, "lib2");
     JUnitTestCase.assertTrue(classElement.isAccessibleIn(library2));
   }
   void test_isAccessibleIn_public_sameLibrary() {
-    LibraryElementImpl library2 = ElementFactory.library(createAnalysisContext(), "lib");
+    LibraryElementImpl library = ElementFactory.library(createAnalysisContext(), "lib");
     ClassElement classElement = ElementFactory.classElement2("C", []);
-    ((library2.definingCompilationUnit as CompilationUnitElementImpl)).types = <ClassElement> [classElement];
-    JUnitTestCase.assertTrue(classElement.isAccessibleIn(library2));
+    ((library.definingCompilationUnit as CompilationUnitElementImpl)).types = <ClassElement> [classElement];
+    JUnitTestCase.assertTrue(classElement.isAccessibleIn(library));
   }
   static dartSuite() {
     _ut.group('ElementImplTest', () {
       _ut.test('test_equals', () {
         final __test = new ElementImplTest();
         runJUnitTest(__test, __test.test_equals);
       });
       _ut.test('test_isAccessibleIn_private_differentLibrary', () {
         final __test = new ElementImplTest();
         runJUnitTest(__test, __test.test_isAccessibleIn_private_differentLibrary);
@@ skipping 27 matching lines @@
     Map<String, Type2> types = type.namedParameterTypes;
     EngineTestCase.assertSize2(0, types);
   }
   void test_getNormalParameterTypes() {
     FunctionTypeImpl type = new FunctionTypeImpl.con1(new FunctionElementImpl.con1(ASTFactory.identifier3("f")));
     List<Type2> types = type.normalParameterTypes;
     EngineTestCase.assertLength(0, types);
   }
   void test_getReturnType() {
     FunctionTypeImpl type = new FunctionTypeImpl.con1(new FunctionElementImpl.con1(ASTFactory.identifier3("f")));
-    Type2 returnType2 = type.returnType;
-    JUnitTestCase.assertEquals(VoidTypeImpl.instance, returnType2);
+    Type2 returnType = type.returnType;
+    JUnitTestCase.assertEquals(VoidTypeImpl.instance, returnType);
   }
   void test_getTypeArguments() {
     FunctionTypeImpl type = new FunctionTypeImpl.con1(new FunctionElementImpl.con1(ASTFactory.identifier3("f")));
     List<Type2> types = type.typeArguments;
     EngineTestCase.assertLength(0, types);
   }
   void test_hashCode_element() {
     FunctionTypeImpl type = new FunctionTypeImpl.con1(new FunctionElementImpl.con1(ASTFactory.identifier3("f")));
     type.hashCode;
   }
@@ skipping 212 matching lines @@
     FunctionTypeImpl type = new FunctionTypeImpl.con1(new FunctionElementImpl.con1(ASTFactory.identifier3("f")));
     List<Type2> expectedTypes = <Type2> [new InterfaceTypeImpl.con1(new ClassElementImpl(ASTFactory.identifier3("C")))];
     type.normalParameterTypes = expectedTypes;
     List<Type2> types = type.normalParameterTypes;
     JUnitTestCase.assertEquals(expectedTypes, types);
   }
   void test_setReturnType() {
     FunctionTypeImpl type = new FunctionTypeImpl.con1(new FunctionElementImpl.con1(ASTFactory.identifier3("f")));
     Type2 expectedType = new InterfaceTypeImpl.con1(new ClassElementImpl(ASTFactory.identifier3("C")));
     type.returnType = expectedType;
-    Type2 returnType2 = type.returnType;
-    JUnitTestCase.assertEquals(expectedType, returnType2);
+    Type2 returnType = type.returnType;
+    JUnitTestCase.assertEquals(expectedType, returnType);
   }
   void test_setTypeArguments() {
     FunctionTypeImpl type = new FunctionTypeImpl.con1(new FunctionElementImpl.con1(ASTFactory.identifier3("f")));
     Type2 expectedType = new TypeVariableTypeImpl(new TypeVariableElementImpl(ASTFactory.identifier3("C")));
     type.typeArguments = <Type2> [expectedType];
     List<Type2> arguments = type.typeArguments;
     EngineTestCase.assertLength(1, arguments);
     JUnitTestCase.assertEquals(expectedType, arguments[0]);
   }
   void test_substitute2_equal() {
@@ skipping 234 matching lines @@
 main() {
   ElementKindTest.dartSuite();
   FunctionTypeImplTest.dartSuite();
   InterfaceTypeImplTest.dartSuite();
   TypeVariableTypeImplTest.dartSuite();
   ClassElementImplTest.dartSuite();
   ElementLocationImplTest.dartSuite();
   ElementImplTest.dartSuite();
   LibraryElementImplTest.dartSuite();
 }