Compute ConstructorElement.returnType/type dynamically.

pkg/analyzer/lib/src/generated/testing/element_factory.dart

 // Copyright (c) 2014, the Dart project authors.  Please see the AUTHORS file
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 
 library analyzer.src.generated.testing.element_factory;
 
 import 'dart:collection';
 
 import 'package:analyzer/dart/ast/ast.dart';
 import 'package:analyzer/dart/ast/token.dart';
@@ skipping 78 matching lines @@
     unit.librarySource = librarySource;
     return unit;
   }
 
   static ConstLocalVariableElementImpl constLocalVariableElement(String name) =>
       new ConstLocalVariableElementImpl(name, 0);
 
   static ConstructorElementImpl constructorElement(
       ClassElement definingClass, String name, bool isConst,
       [List<DartType> argumentTypes]) {
-    DartType type = definingClass.type;
     ConstructorElementImpl constructor = name == null
         ? new ConstructorElementImpl("", -1)
         : new ConstructorElementImpl(name, 0);
     if (name != null) {
       if (name.isEmpty) {
         constructor.nameEnd = definingClass.name.length;
       } else {
         constructor.periodOffset = definingClass.name.length;
         constructor.nameEnd = definingClass.name.length + name.length + 1;
       }
     }
     constructor.synthetic = name == null;
     constructor.const2 = isConst;
     if (argumentTypes != null) {
       int count = argumentTypes.length;
       List<ParameterElement> parameters = new List<ParameterElement>(count);
       for (int i = 0; i < count; i++) {
         ParameterElementImpl parameter = new ParameterElementImpl("a$i", i);
         parameter.type = argumentTypes[i];
         parameter.parameterKind = ParameterKind.REQUIRED;
         parameters[i] = parameter;
       }
       constructor.parameters = parameters;
     } else {
       constructor.parameters = <ParameterElement>[];
     }
-    constructor.returnType = type;
     constructor.enclosingElement = definingClass;
-    constructor.type = new FunctionTypeImpl(constructor);
     if (!constructor.isSynthetic) {
       constructor.constantInitializers = <ConstructorInitializer>[];
     }
     return constructor;
   }
 
   static ConstructorElementImpl constructorElement2(
           ClassElement definingClass, String name,
           [List<DartType> argumentTypes]) =>
       constructorElement(definingClass, name, false, argumentTypes);
 
-  static EnumElementImpl enumElement(
-      TypeProvider typeProvider, String enumName,
+  static EnumElementImpl enumElement(TypeProvider typeProvider, String enumName,
       [List<String> constantNames]) {
     //
     // Build the enum.
     //
     EnumElementImpl enumElement = new EnumElementImpl(enumName, -1);
     InterfaceTypeImpl enumType = new InterfaceTypeImpl(enumElement);
     enumElement.type = enumType;
     //
     // Populate the fields.
     //
@@ skipping 469 matching lines @@
   }
 
   static TypeParameterElementImpl typeParameterWithType(String name,
       [DartType bound]) {
     TypeParameterElementImpl typeParameter = typeParameterElement(name);
     typeParameter.type = new TypeParameterTypeImpl(typeParameter);
     typeParameter.bound = bound;
     return typeParameter;
   }
 }