Clean up handling of declared/inferred types in VariableElementForLink

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 2396 matching lines @@
 /**
  * Specialization of [FieldElementForLink] for class fields.
  */
 class FieldElementForLink_ClassField extends VariableElementForLink
     implements FieldElementForLink {
   @override
   final ClassElementForLink_Class enclosingElement;
 
   /**
    * If this is an instance field, the type that was computed by
-   * [InstanceMemberInferrer].
+   * [InstanceMemberInferrer] (if any).  Otherwise `null`.
    */
   DartType _inferredInstanceType;
 
-  DartType _declaredType;
-
   FieldElementForLink_ClassField(ClassElementForLink_Class enclosingElement,
       UnlinkedVariable unlinkedVariable)
       : enclosingElement = enclosingElement,
         super(unlinkedVariable, enclosingElement.enclosingElement);
 
   @override
   bool get isStatic => unlinkedVariable.isStatic;
 
   @override
-  DartType get type {
-    // TODO(paulberry): can this be unified with
-    // [VariableElementForLink.asStaticType]?
-    assert(!isStatic);
-    if (_inferredInstanceType != null) {
-      return _inferredInstanceType;
-    } else if (_declaredType == null) {
-      if (unlinkedVariable.type == null) {
-        if (!compilationUnit.isInBuildUnit) {
-          _inferredInstanceType = compilationUnit.getLinkedType(
-              unlinkedVariable.inferredTypeSlot, enclosingElement);
-          return _inferredInstanceType;
-        }
-        _declaredType = DynamicTypeImpl.instance;
-      } else {
-        _declaredType = compilationUnit._resolveTypeRef(
-            unlinkedVariable.type, enclosingElement);
-      }
-    }
-    return _declaredType;
-  }
-
-  @override
   void set type(DartType inferredType) {
     assert(!isStatic);
     assert(_inferredInstanceType == null);
     _inferredInstanceType = inferredType;
   }
 
   @override
   TypeParameterizedElementForLink get _typeParameterContext => enclosingElement;
 
   /**
    * Store the results of type inference for this field in
    * [compilationUnit].
    */
   void link(CompilationUnitElementInBuildUnit compilationUnit) {
     if (hasImplicitType) {
-      if (isStatic) {
-        TypeInferenceNode typeInferenceNode = this.asTypeInferenceNode;
-        if (typeInferenceNode != null) {
-          compilationUnit._storeLinkedType(unlinkedVariable.inferredTypeSlot,
-              typeInferenceNode.inferredType, enclosingElement);
-        }
-      } else {
-        compilationUnit._storeLinkedType(unlinkedVariable.inferredTypeSlot,
-            _inferredInstanceType, enclosingElement);
-      }
+      compilationUnit._storeLinkedType(
+          unlinkedVariable.inferredTypeSlot,
+          isStatic ? inferredType : _inferredInstanceType,
+          _typeParameterContext);
     }
   }
 
   @override
   String toString() => '$enclosingElement.$name';
 }
 
 /**
  * Specialization of [FieldElementForLink] for enum fields.
  */
@@ skipping 106 matching lines @@
   /**
    * The variable for which this element is the initializer.
    */
   final VariableElementForLink _variable;
 
   FunctionElementForLink_Initializer(this._variable);
 
   @override
   DartType get returnType {
     // If this is a variable whose type needs inferring, infer it.
-    TypeInferenceNode typeInferenceNode = _variable._typeInferenceNode;
-    if (typeInferenceNode != null) {
-      return typeInferenceNode.inferredType;
+    if (_variable.hasImplicitType) {
+      return _variable.inferredType;
     } else {
       // There's no reason linking should need to access the type of
       // this FunctionElement, since the variable doesn't need its
       // type inferred.
       assert(false);
       // But for robustness, return the dynamic type.
       return DynamicTypeImpl.instance;
     }
   }
 
   @override
   void set returnType(DartType newType) {
-    // TODO(paulberry): store inferred type.
+    // InstanceMemberInferrer stores the new type both here and on the variable
+    // element.  We don't need to record both values, so we ignore it here.
   }
 
   @override
   noSuchMethod(Invocation invocation) => super.noSuchMethod(invocation);
 }
 
 /**
  * Specialization of [DependencyWalker] for linking library cycles.
  */
 class LibraryCycleDependencyWalker extends DependencyWalker<LibraryCycleNode> {
@@ skipping 1104 matching lines @@
   TypeParameterizedElementForLink get _typeParameterContext => null;
 
   /**
    * Store the results of type inference for this variable in
    * [compilationUnit].
    */
   void link(CompilationUnitElementInBuildUnit compilationUnit) {
     if (hasImplicitType) {
       TypeInferenceNode typeInferenceNode = this.asTypeInferenceNode;
       if (typeInferenceNode != null) {
-        compilationUnit._storeLinkedType(unlinkedVariable.inferredTypeSlot,
-            typeInferenceNode.inferredType, null);
+        compilationUnit._storeLinkedType(
+            unlinkedVariable.inferredTypeSlot, inferredType, null);
       }
     }
   }
 }
 
 /**
  * Specialization of [DependencyWalker] for performing type inferrence
  * on static and top level variables.
  */
 class TypeInferenceDependencyWalker
@@ skipping 15 matching lines @@
  * Specialization of [Node] used to construct the type inference dependency
  * graph.
  */
 class TypeInferenceNode extends Node<TypeInferenceNode> {
   /**
    * The [FieldElement] or [TopLevelVariableElement] to which this
    * node refers.
    */
   final VariableElementForLink variableElement;
 
-  /**
-   * If a type has been inferred for this node, the inferred type (may be
-   * `dynamic`).  Otherwise `null`.
-   */
-  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;
+  bool get isEvaluated => variableElement._inferredType != null;
 
   /**
    * Collect the type inference dependencies in [unlinkedConst] (which should be
    * interpreted relative to [compilationUnit]) and store them in
    * [dependencies].
    */
   void collectDependencies(
       List<TypeInferenceNode> dependencies,
       UnlinkedConst unlinkedConst,
       CompilationUnitElementForLink compilationUnit) {
@@ skipping 47 matching lines @@
     List<TypeInferenceNode> dependencies = <TypeInferenceNode>[];
     collectDependencies(
         dependencies,
         variableElement.unlinkedVariable.constExpr,
         variableElement.compilationUnit);
     return dependencies;
   }
 
   void evaluate(bool inCycle) {
     if (inCycle) {
-      _inferredType = DynamicTypeImpl.instance;
+      variableElement._inferredType = DynamicTypeImpl.instance;
     } else {
-      _inferredType = new ExprTypeComputer(variableElement).compute();
+      variableElement._inferredType =
+          new ExprTypeComputer(variableElement).compute();
     }
   }
 }
 
 /**
  * Element representing a type parameter resynthesized from a summary during
  * linking.
  */
 class TypeParameterElementForLink implements TypeParameterElementImpl {
   /**
@@ skipping 316 matching lines @@
   ConstNode _constNode;
 
   /**
    * If this variable has an initializer and an implicit type, and the enclosing
    * library is part of the build unit being linked, the variable's node in the
    * type inference dependency graph.  Otherwise `null`.
    */
   TypeInferenceNode _typeInferenceNode;
 
   FunctionElementForLink_Initializer _initializer;
-  DartType _staticType;
+  DartType _inferredType;
+  DartType _declaredType;
 
   /**
    * The compilation unit in which this variable appears.
    */
   final CompilationUnitElementForLink compilationUnit;
 
   VariableElementForLink(this.unlinkedVariable, this.compilationUnit) {
     if (compilationUnit.isInBuildUnit && unlinkedVariable.constExpr != null) {
       _constNode = new ConstVariableNode(this);
       if (unlinkedVariable.type == null) {
         _typeInferenceNode = new TypeInferenceNode(this);
       }
     }
   }
 
   @override
   ConstructorElementForLink get asConstructor => null;
 
   @override
   ConstVariableNode get asConstVariable => _constNode;
 
   @override
-  DartType get asStaticType {
-    if (_staticType == null) {
-      if (_typeInferenceNode != null) {
-        assert(_typeInferenceNode.isEvaluated);
-        _staticType = _typeInferenceNode.inferredType;
-      } else if (hasImplicitType) {
-        if (!compilationUnit.isInBuildUnit) {
-          _staticType = compilationUnit.getLinkedType(
-              unlinkedVariable.inferredTypeSlot, _typeParameterContext);
-        } else {
-          _staticType = DynamicTypeImpl.instance;
-        }
-      } else {
-        _staticType = compilationUnit._resolveTypeRef(
-            unlinkedVariable.type, _typeParameterContext);
-      }
-    }
-    return _staticType;
-  }
+  DartType get asStaticType => type;
 
   @override
   TypeInferenceNode get asTypeInferenceNode => _typeInferenceNode;
 
+  /**
+   * If the variable has an explicitly declared return type, return it.
+   * Otherwise return `null`.
+   */
+  DartType get declaredType {
+    if (unlinkedVariable.type == null) {
+      return null;
+    } else {
+      return _declaredType ??= compilationUnit._resolveTypeRef(
+          unlinkedVariable.type, _typeParameterContext);
+    }
+  }
+
   @override
   bool get hasImplicitType => unlinkedVariable.type == null;
 
+  /**
+   * Return the inferred type of the variable element.  Should only be called if
+   * no type was explicitly declared.
+   */
+  DartType get inferredType {
+    // We should only try to infer a type when none is explicitly declared.
+    assert(unlinkedVariable.type == null);
+    if (_inferredType == null) {
+      if (_typeInferenceNode != null) {
+        assert(Linker._initializerTypeInferenceCycle == null);
+        Linker._initializerTypeInferenceCycle =
+            compilationUnit.library.libraryCycleForLink;
+        try {
+          new TypeInferenceDependencyWalker().walk(_typeInferenceNode);
+          assert(_inferredType != null);
+        } finally {
+          Linker._initializerTypeInferenceCycle = null;
+        }
+      } else if (compilationUnit.isInBuildUnit) {
+        _inferredType = DynamicTypeImpl.instance;
+      } else {
+        _inferredType = compilationUnit.getLinkedType(
+            unlinkedVariable.inferredTypeSlot, _typeParameterContext);
+      }
+    }
+    return _inferredType;
+  }
+
   @override
   FunctionElementForLink_Initializer get initializer {
     if (unlinkedVariable.constExpr == null) {
       return null;
     } else {
       return _initializer ??= new FunctionElementForLink_Initializer(this);
     }
   }
 
   @override
@@ skipping 11 matching lines @@
   @override
   String get name => unlinkedVariable.name;
 
   @override
   DartType get propagatedType {
     // TODO(paulberry): implement propagated types in the linker.
     return DynamicTypeImpl.instance;
   }
 
   @override
+  DartType get type => declaredType ?? inferredType;
+
+  @override
   void set type(DartType newType) {
     // TODO(paulberry): store inferred type.
   }
 
   /**
    * The context in which type parameters should be interpreted, or `null` if
    * there are no type parameters in scope.
    */
   TypeParameterizedElementForLink get _typeParameterContext;
 
@@ skipping 22 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;
   }
 }