Clean up handling of declared/inferred types in ExecutableElementForLink

pkg/analyzer/lib/src/summary/link.dart

 // Copyright (c) 2016, 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.
 
 /**
  * This library is capable of producing linked summaries from unlinked
  * ones (or prelinked ones).  It functions by building a miniature
  * element model to represent the contents of the summaries, and then
  * scanning the element model to gather linked information and adding
  * it to the summary data structures.
@@ skipping 1597 matching lines @@
   final ClassElementForLink_Class enclosingClass;
 
   /**
    * Return the compilation unit in which this executable appears.
    */
   final CompilationUnitElementForLink enclosingUnit;
 
   ExecutableElementForLink(
       this.enclosingUnit, this.enclosingClass, this._unlinkedExecutable);
 
+  /**
+   * If the executable element had an explicitly declared return type, return
+   * it.  Otherwise return `null`.
+   */
+  DartType get declaredReturnType {
+    if (_unlinkedExecutable.returnType == null) {
+      return null;
+    } else {
+      return _declaredReturnType ??=
+          enclosingUnit._resolveTypeRef(_unlinkedExecutable.returnType, this);
+    }
+  }
+
   @override
   String get displayName {
     if (_displayName == null) {
       _displayName = _unlinkedExecutable.name;
       if (_unlinkedExecutable.kind == UnlinkedExecutableKind.setter) {
         _displayName = _displayName.substring(0, _displayName.length - 1);
       }
     }
     return _displayName;
   }
 
   @override
   Element get enclosingElement => enclosingClass ?? enclosingUnit;
 
   @override
   TypeParameterizedElementForLink get enclosingTypeParameterContext =>
       enclosingClass;
 
   @override
   bool get hasImplicitReturnType => _unlinkedExecutable.returnType == null;
 
+  /**
+   * Return the inferred return type of the executable element.  Should only be
+   * called if no return type was explicitly declared.
+   */
+  DartType get inferredReturnType {
+    // We should only try to infer a return type when none is explicitly
+    // declared.
+    assert(_unlinkedExecutable.returnType == null);
+    if (Linker._initializerTypeInferenceCycle != null &&
+        Linker._initializerTypeInferenceCycle ==
+            enclosingUnit.library.libraryCycleForLink) {
+      // We are currently computing the type of an initializer expression in the
+      // current library cycle, so type inference results should be ignored.
+      return _computeDefaultReturnType();
+    }
+    if (_inferredReturnType == null) {
+      if (_unlinkedExecutable.kind == UnlinkedExecutableKind.constructor) {
+        // TODO(paulberry): implement.
+        throw new UnimplementedError();
+      } else if (enclosingUnit.isInBuildUnit) {
+        _inferredReturnType = _computeDefaultReturnType();
+      } else {
+        _inferredReturnType = enclosingUnit.getLinkedType(
+            _unlinkedExecutable.inferredReturnTypeSlot, this);
+      }
+    }
+    return _inferredReturnType;
+  }
+
   @override
   bool get isStatic => _unlinkedExecutable.isStatic;
 
   @override
   bool get isSynthetic => false;
 
   @override
   LibraryElementForLink get library => enclosingElement.library;
 
   @override
@@ skipping 15 matching lines @@
       for (int i = 0; i < numParameters; i++) {
         UnlinkedParam unlinkedParam = _unlinkedExecutable.parameters[i];
         _parameters[i] = new ParameterElementForLink(
             this, unlinkedParam, this, enclosingUnit, i);
       }
     }
     return _parameters;
   }
 
   @override
-  DartType get returnType {
-    if (_inferredReturnType != null) {
-      return _inferredReturnType;
-    } else if (_declaredReturnType == null) {
-      if (_unlinkedExecutable.returnType == null) {
-        if (_unlinkedExecutable.kind == UnlinkedExecutableKind.constructor) {
-          // TODO(paulberry): implement.
-          throw new UnimplementedError();
-        } else if (!enclosingUnit.isInBuildUnit) {
-          _inferredReturnType = enclosingUnit.getLinkedType(
-              _unlinkedExecutable.inferredReturnTypeSlot, this);
-          return _inferredReturnType;
-        } else if (_unlinkedExecutable.kind == UnlinkedExecutableKind.setter &&
-            library._linker.strongMode) {
-          // In strong mode, setters without an explicit return type are
-          // considered to return `void`.
-          _declaredReturnType = VoidTypeImpl.instance;
-        } else {
-          _declaredReturnType = DynamicTypeImpl.instance;
-        }
-      } else {
-        _declaredReturnType =
-            enclosingUnit._resolveTypeRef(_unlinkedExecutable.returnType, this);
-      }
-    }
-    return _declaredReturnType;
-  }
+  DartType get returnType => declaredReturnType ?? inferredReturnType;
 
   @override
   void set returnType(DartType inferredType) {
     assert(_inferredReturnType == null);
     _inferredReturnType = inferredType;
   }
 
   @override
   FunctionTypeImpl get type => _type ??= new FunctionTypeImpl(this);
 
   @override
   List<UnlinkedTypeParam> get _unlinkedTypeParams =>
       _unlinkedExecutable.typeParameters;
 
   @override
   bool isAccessibleIn(LibraryElement library) =>
       !Identifier.isPrivateName(name) || identical(this.library, library);
 
   /**
    * Store the results of type inference for this method in [compilationUnit].
    */
   void link(CompilationUnitElementInBuildUnit compilationUnit) {
-    compilationUnit._storeLinkedType(
-        _unlinkedExecutable.inferredReturnTypeSlot, returnType, this);
+    if (_unlinkedExecutable.returnType == null) {
+      compilationUnit._storeLinkedType(
+          _unlinkedExecutable.inferredReturnTypeSlot, inferredReturnType, this);
+    }
     for (ParameterElementForLink parameterElement in parameters) {
       parameterElement.link(compilationUnit);
     }
   }
+
+  /**
+   * Compute the default return type for this type of executable element (if no
+   * return type is declared and strong mode type inference cannot infer a
+   * better return type).
+   */
+  DartType _computeDefaultReturnType() {
+    if (_unlinkedExecutable.kind == UnlinkedExecutableKind.setter &&
+        library._linker.strongMode) {
+      // In strong mode, setters without an explicit return type are
+      // considered to return `void`.
+      return VoidTypeImpl.instance;
+    } else {
+      return DynamicTypeImpl.instance;
+    }
+  }
 }
 
 class ExprTypeComputer {
   VariableElementForLink variable;
   CompilationUnitElementForLink unit;
   LibraryElementForLink library;
   Linker linker;
   TypeProvider typeProvider;
   UnlinkedConst unlinkedConst;
 
@@ skipping 1243 matching lines @@
     return dependencies;
   }
 }
 
 /**
  * Instances of [Linker] contain the necessary information to link
  * together a single build unit.
  */
 class Linker {
   /**
+   * During linking, if type inference is currently being performed on the
+   * initializer of a static or instance variable, the library cycle in
+   * which inference is being performed.  Otherwise, `null`.
+   *
+   * This allows us to suppress instance member type inference results from a
+   * library cycle while doing inference on the right hand sides of static and
+   * instance variables in that same cycle.
+   */
+  static LibraryCycleForLink _initializerTypeInferenceCycle;
+
+  /**
    * Callback to ask the client for a [LinkedLibrary] for a
    * dependency.
    */
   final GetDependencyCallback getDependency;
 
   /**
    * Callback to ask the client for an [UnlinkedUnit].
    */
   final GetUnitCallback getUnit;
 
@@ skipping 739 matching lines @@
    */
   DartType _inferredType;
 
   TypeInferenceNode(this.variableElement);
 
   /**
    * Infer a type for this node if necessary, and return it.
    */
   DartType get inferredType {
     if (_inferredType == null) {
+      Linker._initializerTypeInferenceCycle =
+          variableElement.compilationUnit.library.libraryCycleForLink;
       new TypeInferenceDependencyWalker().walk(this);
       assert(_inferredType != null);
+      Linker._initializerTypeInferenceCycle = null;
     }
     return _inferredType;
   }
 
   @override
   bool get isEvaluated => _inferredType != null;
 
   /**
    * Collect the type inference dependencies in [unlinkedConst] (which should be
    * interpreted relative to [compilationUnit]) and store them in
@@ skipping 514 matching lines @@
       if (type is InterfaceType) {
         Element result = type.lookUpGetter(name, compilationUnit.library);
         result ??= type.lookUpMethod(name, compilationUnit.library);
         return result;
       }
     }
     // TODO(scheglov): implement for propagated types
     return null;
   }
 }