Resynthesize return types lazily.

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 1664 matching lines @@
     return hasModifier(Modifier.FACTORY);
   }
 
   @override
   bool get isStatic => false;
 
   @override
   ElementKind get kind => ElementKind.CONSTRUCTOR;
 
   @override
+  DartType get returnType => enclosingElement.type;
+
+  @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 =
             'Found constructor element named $name with no enclosing element';
@@ skipping 1104 matching lines @@
 
   /**
    * A list containing all of the type parameters defined for this executable
    * element.
    */
   List<TypeParameterElement> _typeParameters = TypeParameterElement.EMPTY_LIST;
 
   /**
    * The return type defined by this executable element.
    */
-  DartType returnType;
+  DartType _returnType;
 
   /**
    * The type of function defined by this executable element.
    */
   FunctionType type;
 
   /**
    * Initialize a newly created executable element to have the given [name] and
    * [offset].
    */
@@ skipping 213 matching lines @@
    * [parameters].
    */
   void set parameters(List<ParameterElement> parameters) {
     for (ParameterElement parameter in parameters) {
       (parameter as ParameterElementImpl).enclosingElement = this;
     }
     this._parameters = parameters;
   }
 
   @override
+  DartType get returnType {
+    if (serializedExecutable != null && _returnType == null) {
+      bool isSetter =
+          serializedExecutable.kind == UnlinkedExecutableKind.setter;
+      _returnType = enclosingUnit.resynthesizerContext.resolveLinkedType(
+              serializedExecutable.inferredReturnTypeSlot,
+              typeParameterContext) ??
+          enclosingUnit.resynthesizerContext.resolveTypeRef(
+              serializedExecutable.returnType, typeParameterContext,
+              defaultVoid: isSetter && context.analysisOptions.strongMode);
+    }
+    return _returnType;
+  }
+
+  void set returnType(DartType returnType) {
+    assert(serializedExecutable == null);
+    _returnType = returnType;
+  }
+
+  @override
   TypeParameterizedElementMixin get typeParameterContext => this;
 
   @override
   List<TypeParameterElement> get typeParameters => _typeParameters;
 
   /**
    * Set the type parameters defined by this executable element to the given
    * [typeParameters].
    */
   void set typeParameters(List<TypeParameterElement> typeParameters) {
@@ skipping 571 matching lines @@
   final UnlinkedTypedef _unlinkedTypedef;
 
   /**
    * A list containing all of the parameters defined by this type alias.
    */
   List<ParameterElement> _parameters = ParameterElement.EMPTY_LIST;
 
   /**
    * The return type defined by this type alias.
    */
-  DartType returnType;
+  DartType _returnType;
 
   /**
    * The type of function defined by this type alias.
    */
   FunctionType type;
 
   /**
    * A list containing all of the type parameters defined for this type.
    */
   List<TypeParameterElement> _typeParameters = TypeParameterElement.EMPTY_LIST;
@@ skipping 110 matching lines @@
   void set parameters(List<ParameterElement> parameters) {
     if (parameters != null) {
       for (ParameterElement parameter in parameters) {
         (parameter as ParameterElementImpl).enclosingElement = this;
       }
     }
     this._parameters = parameters;
   }
 
   @override
+  DartType get returnType {
+    if (_unlinkedTypedef != null && _returnType == null) {
+      _returnType = enclosingUnit.resynthesizerContext
+          .resolveTypeRef(_unlinkedTypedef.returnType, this);
+    }
+    return _returnType;
+  }
+
+  void set returnType(DartType returnType) {
+    assert(_unlinkedTypedef == null);
+    _returnType = returnType;
+  }
+
+  @override
   TypeParameterizedElementMixin get typeParameterContext => this;
 
   @override
   List<TypeParameterElement> get typeParameters {
     if (_unlinkedTypedef != null) {
       return super.typeParameters;
     }
     return _typeParameters;
   }
 
@@ skipping 3279 matching lines @@
 
   @override
   void visitElement(Element element) {
     int offset = element.nameOffset;
     if (offset != -1) {
       map[offset] = element;
     }
     super.visitElement(element);
   }
 }