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 '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 329 matching lines @@
     classA.accessors = <PropertyAccessorElement> [getterG];
     InterfaceType typeA = classA.type;
     JUnitTestCase.assertSame(getterG, typeA.getGetter(getterName));
   }
   void test_getGetter_parameterized() {
     ClassElementImpl classA = ElementFactory.classElement2("A", ["E"]);
     Type2 typeE = classA.type.typeArguments[0];
     String getterName = "g";
     PropertyAccessorElement getterG = ElementFactory.getterElement(getterName, false, typeE);
     classA.accessors = <PropertyAccessorElement> [getterG];
+    ((getterG.type as FunctionTypeImpl)).typeArguments = classA.type.typeArguments;
     InterfaceType typeI = ElementFactory.classElement2("I", []).type;
     InterfaceTypeImpl typeAI = new InterfaceTypeImpl.con1(classA);
     typeAI.typeArguments = <Type2> [typeI];
     PropertyAccessorElement getter = typeAI.getGetter(getterName);
     JUnitTestCase.assertNotNull(getter);
     FunctionType getterType = getter.type;
     JUnitTestCase.assertSame(typeI, getterType.returnType);
   }
   void test_getGetter_unimplemented() {
     ClassElementImpl classA = ElementFactory.classElement2("A", []);
@@ skipping 221 matching lines @@
     classA.methods = <MethodElement> [methodM];
     InterfaceType typeA = classA.type;
     JUnitTestCase.assertSame(methodM, typeA.getMethod(methodName));
   }
   void test_getMethod_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];
+    ((methodM.type as FunctionTypeImpl)).typeArguments = classA.type.typeArguments;
     InterfaceType typeI = ElementFactory.classElement2("I", []).type;
     InterfaceTypeImpl typeAI = new InterfaceTypeImpl.con1(classA);
     typeAI.typeArguments = <Type2> [typeI];
     MethodElement method = typeAI.getMethod(methodName);
     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]);
@@ skipping 42 matching lines @@
     classA.accessors = <PropertyAccessorElement> [setterS];
     InterfaceType typeA = classA.type;
     JUnitTestCase.assertSame(setterS, typeA.getSetter(setterName));
   }
   void test_getSetter_parameterized() {
     ClassElementImpl classA = ElementFactory.classElement2("A", ["E"]);
     Type2 typeE = classA.type.typeArguments[0];
     String setterName = "s";
     PropertyAccessorElement setterS = ElementFactory.setterElement(setterName, false, typeE);
     classA.accessors = <PropertyAccessorElement> [setterS];
+    ((setterS.type as FunctionTypeImpl)).typeArguments = classA.type.typeArguments;
     InterfaceType typeI = ElementFactory.classElement2("I", []).type;
     InterfaceTypeImpl typeAI = new InterfaceTypeImpl.con1(classA);
     typeAI.typeArguments = <Type2> [typeI];
     PropertyAccessorElement setter = typeAI.getSetter(setterName);
     JUnitTestCase.assertNotNull(setter);
     FunctionType setterType = setter.type;
     List<Type2> parameterTypes = setterType.normalParameterTypes;
     EngineTestCase.assertLength(1, parameterTypes);
     JUnitTestCase.assertSame(typeI, parameterTypes[0]);
   }
@@ skipping 353 matching lines @@
     CompilationUnitElement unit = library.definingCompilationUnit;
     ((unit as CompilationUnitElementImpl)).types = <ClassElement> [classA, classB];
     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];
+    ((methodM.type as FunctionTypeImpl)).typeArguments = classA.type.typeArguments;
     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 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);
@@ skipping 512 matching lines @@
         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
+ * 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) {
@@ skipping 10 matching lines @@
         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(ClassElement clazz, String name) {
-    Type2 type = clazz.type;
+  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);
-    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) {
     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;
+    getter.returnType = type2;
     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;
+      setter.returnType = VoidTypeImpl.instance;
       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;
+    if (returnElement == null) {
+      functionElement.returnType = VoidTypeImpl.instance;
+    } else {
+      functionElement.returnType = returnElement.type;
     }
     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;
     }
     int optionalCount = optionalParameters == null ? 0 : optionalParameters.length;
@@ skipping 17 matching lines @@
       }
       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;
+    if (returnElement == null) {
+      functionElement.returnType = VoidTypeImpl.instance;
+    } else {
+      functionElement.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++) {
         normalParameterTypes[i] = normalParameters[i].type;
       }
       functionType.normalParameterTypes = normalParameterTypes;
     }
     if (names != null && names.length > 0 && names.length == namedParameters.length) {
@@ skipping 18 matching lines @@
   }
   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;
+    getter.returnType = type2;
     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;
     spec.combinators = combinators2;
     return spec;
   }
@@ skipping 12 matching lines @@
     MethodElementImpl method = new MethodElementImpl.con1(ASTFactory.identifier3(methodName));
     int count = argumentTypes.length;
     List<ParameterElement> parameters = new List<ParameterElement>(count);
     for (int i = 0; i < count; i++) {
       ParameterElementImpl parameter = new ParameterElementImpl(ASTFactory.identifier3("a${i}"));
       parameter.type = argumentTypes[i];
       parameter.parameterKind = ParameterKind.REQUIRED;
       parameters[i] = parameter;
     }
     method.parameters = parameters;
+    method.returnType = returnType2;
     FunctionTypeImpl methodType = new FunctionTypeImpl.con1(method);
     methodType.normalParameterTypes = argumentTypes;
-    methodType.returnType = returnType2;
     method.type = methodType;
     return method;
   }
   static ParameterElementImpl namedParameter(String name) {
     ParameterElementImpl parameter = new ParameterElementImpl(ASTFactory.identifier3(name));
     parameter.parameterKind = ParameterKind.NAMED;
     return parameter;
   }
   static ParameterElementImpl positionalParameter(String name) {
     ParameterElementImpl parameter = new ParameterElementImpl(ASTFactory.identifier3(name));
     parameter.parameterKind = ParameterKind.POSITIONAL;
     return parameter;
   }
   static PrefixElementImpl prefix(String name) => new PrefixElementImpl(ASTFactory.identifier3(name));
   static ParameterElementImpl requiredParameter(String name) {
     ParameterElementImpl parameter = new ParameterElementImpl(ASTFactory.identifier3(name));
     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;
+    getter.returnType = type2;
     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;
+    setter.returnType = VoidTypeImpl.instance;
     field.setter = setter;
-    FunctionTypeImpl setterType = new FunctionTypeImpl.con1(getter);
+    FunctionTypeImpl setterType = new FunctionTypeImpl.con1(setter);
     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);
   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;
+    getter.returnType = type2;
     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;
+      setter.returnType = VoidTypeImpl.instance;
       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() {
@@ skipping 365 matching lines @@
     FunctionTypeImpl type = new FunctionTypeImpl.con1(new FunctionElementImpl.con1(ASTFactory.identifier3("f")));
     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 expectedReturnType = VoidTypeImpl.instance;
+    FunctionElementImpl functionElement = new FunctionElementImpl.con1(ASTFactory.identifier3("f"));
+    functionElement.returnType = expectedReturnType;
+    FunctionTypeImpl type = new FunctionTypeImpl.con1(functionElement);
     Type2 returnType = type.returnType;
-    JUnitTestCase.assertEquals(VoidTypeImpl.instance, returnType);
+    JUnitTestCase.assertEquals(expectedReturnType, 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 190 matching lines @@
     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);
     FunctionElementImpl functionAliasElement = new FunctionElementImpl.con1(ASTFactory.identifier3("func"));
+    functionAliasElement.returnType = stringType;
     FunctionTypeImpl functionAliasType = new FunctionTypeImpl.con1(functionAliasElement);
     functionAliasElement.type = functionAliasType;
-    functionAliasType.returnType = stringType;
     functionAliasType.normalParameterTypes = <Type2> [typeB];
     functionAliasType.optionalParameterTypes = <Type2> [typeS];
     FunctionElementImpl functionElement = new FunctionElementImpl.con1(ASTFactory.identifier3("f"));
+    functionElement.returnType = provider.dynamicType;
     FunctionTypeImpl functionType = new FunctionTypeImpl.con1(functionElement);
     functionElement.type = functionType;
-    functionType.returnType = provider.dynamicType;
     functionType.normalParameterTypes = <Type2> [boolType];
     functionType.optionalParameterTypes = <Type2> [stringType];
     JUnitTestCase.assertTrue(functionType.isAssignableTo(functionAliasType));
   }
   void test_isSubtypeOf_wrongFunctionType_normal_named() {
     ClassElement a = ElementFactory.classElement2("A", []);
     FunctionType t = ElementFactory.functionElement5("t", <ClassElement> [a]).type;
     FunctionType s = ElementFactory.functionElement7("s", null, <String> ["name"], <ClassElement> [a]).type;
     JUnitTestCase.assertFalse(t.isSubtypeOf(s));
     JUnitTestCase.assertFalse(s.isSubtypeOf(t));
@@ skipping 14 matching lines @@
     JUnitTestCase.assertEquals(expectedTypes, types);
   }
   void test_setNormalParameterTypes() {
     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 returnType = type.returnType;
-    JUnitTestCase.assertEquals(expectedType, returnType);
+    FunctionElementImpl functionElement = new FunctionElementImpl.con1(ASTFactory.identifier3("f"));
+    functionElement.returnType = expectedType;
+    FunctionTypeImpl type = new FunctionTypeImpl.con1(functionElement);
+    JUnitTestCase.assertEquals(expectedType, type.returnType);
   }
   void test_setTypeArguments() {
-    FunctionTypeImpl type = new FunctionTypeImpl.con1(new FunctionElementImpl.con1(ASTFactory.identifier3("f")));
-    Type2 expectedType = new TypeVariableTypeImpl(new TypeVariableElementImpl(ASTFactory.identifier3("C")));
+    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;
     type.typeArguments = <Type2> [expectedType];
     List<Type2> arguments = type.typeArguments;
     EngineTestCase.assertLength(1, arguments);
     JUnitTestCase.assertEquals(expectedType, arguments[0]);
   }
   void test_substitute2_equal() {
-    FunctionTypeImpl functionType = new FunctionTypeImpl.con1(new FunctionElementImpl.con1(ASTFactory.identifier3("f")));
-    TypeVariableTypeImpl parameterType = new TypeVariableTypeImpl(new TypeVariableElementImpl(ASTFactory.identifier3("E")));
-    functionType.returnType = parameterType;
+    ClassElementImpl definingClass = ElementFactory.classElement2("C", ["E"]);
+    TypeVariableType parameterType = definingClass.typeVariables[0].type;
+    MethodElementImpl functionElement = new MethodElementImpl.con1(ASTFactory.identifier3("m"));
+    functionElement.returnType = parameterType;
+    definingClass.methods = <MethodElement> [functionElement];
+    FunctionTypeImpl functionType = new FunctionTypeImpl.con1(functionElement);
     functionType.normalParameterTypes = <Type2> [parameterType];
     functionType.optionalParameterTypes = <Type2> [parameterType];
+    functionType.typeArguments = <Type2> [parameterType];
     LinkedHashMap<String, Type2> namedParameterTypes = new LinkedHashMap<String, Type2>();
     String namedParameterName = "c";
     namedParameterTypes[namedParameterName] = parameterType;
     functionType.namedParameterTypes = namedParameterTypes;
     InterfaceTypeImpl argumentType = new InterfaceTypeImpl.con1(new ClassElementImpl(ASTFactory.identifier3("D")));
     FunctionType result = functionType.substitute2(<Type2> [argumentType], <Type2> [parameterType]);
     JUnitTestCase.assertEquals(argumentType, result.returnType);
     List<Type2> normalParameters = result.normalParameterTypes;
     EngineTestCase.assertLength(1, normalParameters);
     JUnitTestCase.assertEquals(argumentType, normalParameters[0]);
     List<Type2> optionalParameters = result.optionalParameterTypes;
     EngineTestCase.assertLength(1, optionalParameters);
     JUnitTestCase.assertEquals(argumentType, optionalParameters[0]);
     Map<String, Type2> namedParameters = result.namedParameterTypes;
     EngineTestCase.assertSize2(1, namedParameters);
     JUnitTestCase.assertEquals(argumentType, namedParameters[namedParameterName]);
   }
   void test_substitute2_notEqual() {
-    FunctionTypeImpl functionType = new FunctionTypeImpl.con1(new FunctionElementImpl.con1(ASTFactory.identifier3("f")));
     Type2 returnType = new InterfaceTypeImpl.con1(new ClassElementImpl(ASTFactory.identifier3("R")));
     Type2 normalParameterType = new InterfaceTypeImpl.con1(new ClassElementImpl(ASTFactory.identifier3("A")));
     Type2 optionalParameterType = new InterfaceTypeImpl.con1(new ClassElementImpl(ASTFactory.identifier3("B")));
     Type2 namedParameterType = new InterfaceTypeImpl.con1(new ClassElementImpl(ASTFactory.identifier3("C")));
-    functionType.returnType = returnType;
+    FunctionElementImpl functionElement = new FunctionElementImpl.con1(ASTFactory.identifier3("f"));
+    functionElement.returnType = returnType;
+    FunctionTypeImpl functionType = new FunctionTypeImpl.con1(functionElement);
     functionType.normalParameterTypes = <Type2> [normalParameterType];
     functionType.optionalParameterTypes = <Type2> [optionalParameterType];
     LinkedHashMap<String, Type2> namedParameterTypes = new LinkedHashMap<String, Type2>();
     String namedParameterName = "c";
     namedParameterTypes[namedParameterName] = namedParameterType;
     functionType.namedParameterTypes = namedParameterTypes;
     InterfaceTypeImpl argumentType = new InterfaceTypeImpl.con1(new ClassElementImpl(ASTFactory.identifier3("D")));
     TypeVariableTypeImpl parameterType = new TypeVariableTypeImpl(new TypeVariableElementImpl(ASTFactory.identifier3("E")));
     FunctionType result = functionType.substitute2(<Type2> [argumentType], <Type2> [parameterType]);
     JUnitTestCase.assertEquals(returnType, result.returnType);
@@ skipping 199 matching lines @@
 main() {
   ElementKindTest.dartSuite();
   FunctionTypeImplTest.dartSuite();
   InterfaceTypeImplTest.dartSuite();
   TypeVariableTypeImplTest.dartSuite();
   ClassElementImplTest.dartSuite();
   ElementLocationImplTest.dartSuite();
   ElementImplTest.dartSuite();
   LibraryElementImplTest.dartSuite();
 }