Compute ConstructorElement.returnType/type dynamically.

pkg/analyzer/lib/src/dart/element/element.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.dart.element.element;
 
 import 'dart:collection';
 import 'dart:math' show min;
 
 import 'package:analyzer/dart/ast/ast.dart';
@@ skipping 1067 matching lines @@
     }
 
     // Now create an implicit constructor for every constructor found above,
     // substituting type parameters as appropriate.
     return constructorsToForward
         .map((ConstructorElement superclassConstructor) {
       ConstructorElementImpl implicitConstructor =
           new ConstructorElementImpl(superclassConstructor.name, -1);
       implicitConstructor.synthetic = true;
       implicitConstructor.redirectedConstructor = superclassConstructor;
-      implicitConstructor.returnType = type;
       List<ParameterElement> superParameters = superclassConstructor.parameters;
       int count = superParameters.length;
       if (count > 0) {
         List<ParameterElement> implicitParameters =
             new List<ParameterElement>(count);
         for (int i = 0; i < count; i++) {
           ParameterElement superParameter = superParameters[i];
           ParameterElementImpl implicitParameter =
               new ParameterElementImpl(superParameter.name, -1);
           implicitParameter.const3 = superParameter.isConst;
           implicitParameter.final2 = superParameter.isFinal;
           implicitParameter.parameterKind = superParameter.parameterKind;
           implicitParameter.synthetic = true;
           implicitParameter.type =
               superParameter.type.substitute2(argumentTypes, parameterTypes);
           implicitParameters[i] = implicitParameter;
         }
         implicitConstructor.parameters = implicitParameters;
       }
       implicitConstructor.enclosingElement = this;
-      implicitConstructor.type = new FunctionTypeImpl(implicitConstructor);
       return implicitConstructor;
     }).toList(growable: false);
   }
 
   bool _safeIsOrInheritsProxy(
       ClassElement classElt, HashSet<ClassElement> visitedClassElts) {
     if (visitedClassElts.contains(classElt)) {
       return false;
     }
     visitedClassElts.add(classElt);
@@ skipping 755 matching lines @@
   }
 
   void set redirectedConstructor(ConstructorElement redirectedConstructor) {
     assert(serializedExecutable == null);
     _redirectedConstructor = redirectedConstructor;
   }
 
   @override
   DartType get returnType => enclosingElement.type;
 
+  void set returnType(DartType returnType) {
+    assert(false);
+  }
+
+  @override
+  FunctionType get type {
+    return _type ??= new FunctionTypeImpl(this);
+  }
+
+  void set type(FunctionType type) {
+    assert(false);
+  }
+
   @override
   accept(ElementVisitor visitor) => visitor.visitConstructorElement(this);
 
   @override
   void appendTo(StringBuffer buffer) {
     if (enclosingElement == null) {
       String message;
       String name = displayName;
       if (name != null && !name.isEmpty) {
         message =
@@ skipping 6152 matching lines @@
 
   @override
   void visitElement(Element element) {
     int offset = element.nameOffset;
     if (offset != -1) {
       map[offset] = element;
     }
     super.visitElement(element);
   }
 }