In AST-based type inference, use function elements rather than variable elements.

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 1954 matching lines @@
       compilationUnit._storeLinkedType(
           _unlinkedExecutable.inferredReturnTypeSlot, inferredReturnType, this);
     }
     for (ParameterElementForLink parameterElement in parameters) {
       parameterElement.link(compilationUnit);
     }
   }
 }
 
 class ExprTypeComputer {
-  VariableElementForLink variable;
-  FunctionElementForLink_Initializer initializer;
-  CompilationUnitElementForLink unit;
-  LibraryElementForLink library;
-  Linker linker;
-  TypeProvider typeProvider;
-  UnlinkedConst unlinkedConst;
+  final FunctionElementForLink_Local function;
+  final CompilationUnitElementForLink unit;
+  final LibraryElementForLink library;
+  final Linker linker;
+  final TypeProvider typeProvider;
+  final UnlinkedConst unlinkedConst;
 
   final List<DartType> stack = <DartType>[];
   int intPtr = 0;
   int refPtr = 0;
   int strPtr = 0;
   int assignmentOperatorPtr = 0;
 
-  ExprTypeComputer(VariableElementForLink variableElement) {
-    this.variable = variableElement;
-    initializer = variableElement.initializer;
-    unit = variableElement.compilationUnit;
-    library = unit.enclosingElement;
-    linker = library._linker;
-    typeProvider = linker.typeProvider;
-    unlinkedConst = variableElement.unlinkedVariable.initializer?.bodyExpr;
+  factory ExprTypeComputer(FunctionElementForLink_Local functionElement) {
+    CompilationUnitElementForLink unit = functionElement.compilationUnit;
+    LibraryElementForLink library = unit.enclosingElement;
+    Linker linker = library._linker;
+    TypeProvider typeProvider = linker.typeProvider;
+    UnlinkedConst unlinkedConst = functionElement._unlinkedExecutable.bodyExpr;
+    return new ExprTypeComputer._(
+        functionElement, unit, library, linker, typeProvider, unlinkedConst);
   }
 
+  ExprTypeComputer._(this.function, this.unit, this.library, this.linker,
+      this.typeProvider, this.unlinkedConst);
+
   DartType compute() {
+    if (unlinkedConst == null) {
+      // No function body was stored for this function, so we can't infer its
+      // return type.  Assume `dynamic`.
+      return DynamicTypeImpl.instance;
+    }
     // Perform RPN evaluation of the constant, using a stack of inferred types.
     for (UnlinkedConstOperation operation in unlinkedConst.operations) {
       switch (operation) {
         case UnlinkedConstOperation.pushInt:
           intPtr++;
           stack.add(typeProvider.intType);
           break;
         case UnlinkedConstOperation.pushLongInt:
           int numInts = _getNextInt();
           intPtr += numInts;
@@ skipping 141 matching lines @@
           refPtr++;
           stack.add(typeProvider.boolType);
           break;
         case UnlinkedConstOperation.throwException:
           stack.removeLast();
           stack.add(BottomTypeImpl.instance);
           break;
         case UnlinkedConstOperation.pushLocalFunctionReference:
           int popCount = _getNextInt();
           assert(popCount == 0); // TODO(paulberry): handle the nonzero case.
-          stack.add(initializer.functions[_getNextInt()].type);
+          stack.add(function.functions[_getNextInt()].type);
           break;
         default:
           // TODO(paulberry): implement.
           throw new UnimplementedError('$operation');
       }
     }
     assert(intPtr == unlinkedConst.ints.length);
     assert(refPtr == unlinkedConst.references.length);
     assert(strPtr == unlinkedConst.strings.length);
     assert(assignmentOperatorPtr == unlinkedConst.assignmentOperators.length);
@@ skipping 136 matching lines @@
     strPtr += numNamed;
     EntityRef ref = _getNextRef();
     ConstructorElementForLink element =
         unit.resolveRef(ref.reference).asConstructor;
     if (element != null) {
       ClassElementForLink_Class enclosingClass = element.enclosingClass;
       stack.add(enclosingClass.buildType((int i) {
         // Type argument explicitly specified.
         if (i < ref.typeArguments.length) {
           return unit.resolveTypeRef(
-              ref.typeArguments[i], variable._typeParameterContext);
+              ref.typeArguments[i], function.typeParameterContext);
         } else {
           return null;
         }
       }, const []));
     } else {
       stack.add(DynamicTypeImpl.instance);
     }
   }
 
   void _doInvokeMethod() {
@@ skipping 112 matching lines @@
   List<String> _getNextStrings(int n) {
     List<String> result = new List<String>(n);
     for (int i = 0; i < n; i++) {
       result[i] = _getNextString();
     }
     return result;
   }
 
   DartType _getNextTypeRef() {
     EntityRef ref = _getNextRef();
-    return unit.resolveTypeRef(ref, variable._typeParameterContext);
+    return unit.resolveTypeRef(ref, function.typeParameterContext);
   }
 
   /**
    * Return the type of the property with the given [propertyName] in the
    * given [targetType]. May return `dynamic` if the property cannot be
    * resolved.
    */
   DartType _getPropertyType(DartType targetType, String propertyName) {
     return targetType is InterfaceType
         ? targetType
@@ skipping 289 matching lines @@
   List<TypeParameterElement> get typeParameters => const [];
 
   @override
   noSuchMethod(Invocation invocation) => super.noSuchMethod(invocation);
 }
 
 /**
  * Element representing the initializer expression of a variable.
  */
 class FunctionElementForLink_Initializer extends Object
-    with ReferenceableElementForLink
+    with ReferenceableElementForLink, TypeParameterizedElementMixin
     implements FunctionElementForLink_Local {
   /**
    * The variable for which this element is the initializer.
    */
   final VariableElementForLink _variable;
 
   List<FunctionElementForLink_Local_NonSynthetic> _functions;
 
   FunctionElementForLink_Initializer(this._variable);
 
   @override
+  CompilationUnitElementForLink get compilationUnit =>
+      _variable.compilationUnit;
+
+  @override
   VariableElementForLink get enclosingElement => _variable;
 
   TypeParameterizedElementMixin get enclosingTypeParameterContext =>
       _variable.enclosingElement is ClassElementForLink
           ? _variable.enclosingElement
           : null;
 
   @override
+  CompilationUnitElementForLink get enclosingUnit => _variable.compilationUnit;
+
+  @override
   List<FunctionElementForLink_Local_NonSynthetic> get functions =>
       _functions ??= _variable.unlinkedVariable.initializer.localFunctions
           .map((UnlinkedExecutable ex) =>
               new FunctionElementForLink_Local_NonSynthetic(
                   _variable.compilationUnit, this, ex))
           .toList();
 
   @override
   DartType get returnType {
     // If this is a variable whose type needs inferring, infer it.
     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) {
     // 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
-  int get typeParameterNestingLevel =>
-      enclosingTypeParameterContext?.typeParameterNestingLevel ?? 0;
+  TypeParameterizedElementMixin get typeParameterContext => this;
 
-  List<TypeParameterElement> get typeParameters => const [];
+  @override
+  List<UnlinkedTypeParam> get unlinkedTypeParams => const [];
+
+  @override
+  bool get _hasTypeBeenInferred => _variable._inferredType != null;
+
+  @override
+  UnlinkedExecutable get _unlinkedExecutable =>
+      _variable.unlinkedVariable.initializer;
 
   @override
   FunctionElementForLink_Local getLocalFunction(int index) {
     List<FunctionElementForLink_Local_NonSynthetic> functions = this.functions;
     return index < functions.length ? functions[index] : null;
   }
 
   @override
   noSuchMethod(Invocation invocation) => super.noSuchMethod(invocation);
+
+  @override
+  void _setInferredType(DartType type) {
+    assert(!_hasTypeBeenInferred);
+    _variable._inferredType = type;
+  }
 }
 
 /**
  * Element representing a local function (possibly a closure).
  */
 abstract class FunctionElementForLink_Local
     implements
         ExecutableElementForLink,
         FunctionElementImpl,
-        ReferenceableElementForLink {}
+        ReferenceableElementForLink {
+  /**
+   * Indicates whether type inference has completed for this function.
+   */
+  bool get _hasTypeBeenInferred;
+
+  /**
+   * Stores the given [type] as the inferred return type for this function.
+   * Should only be called if [_hasTypeBeenInferred] is `false`.
+   */
+  void _setInferredType(DartType type);
+}
 
 /**
  * Element representing a local function (possibly a closure) inside another
  * executable.
  */
 class FunctionElementForLink_Local_NonSynthetic extends ExecutableElementForLink
     with ReferenceableElementForLink
     implements FunctionElementForLink_Local {
   @override
   final ExecutableElementForLink enclosingElement;
 
   FunctionElementForLink_Local_NonSynthetic(
       CompilationUnitElementForLink compilationUnit,
       this.enclosingElement,
       UnlinkedExecutable unlinkedExecutable)
       : super(compilationUnit, unlinkedExecutable);
 
   @override
   TypeParameterizedElementMixin get enclosingTypeParameterContext =>
       enclosingElement;
 
   @override
+  bool get _hasTypeBeenInferred {
+    // TODO(paulberry): add logic to infer types of nonsynthetic functions.
+    return true;
+  }
+
+  @override
   DartType buildType(
       DartType getTypeArgument(int i), List<int> implicitFunctionTypeIndices) {
     assert(implicitFunctionTypeIndices.isEmpty);
     return type;
   }
 
   @override
   FunctionElementForLink_Local getLocalFunction(int index) {
     // TODO(paulberry): implement.
     throw new UnimplementedError();
   }
 
   @override
   noSuchMethod(Invocation invocation) => super.noSuchMethod(invocation);
+
+  @override
+  void _setInferredType(DartType type) {
+    // TODO(paulberry): add logic to infer types of nonsynthetic functions.
+    throw new UnimplementedError();
+  }
 }
 
 /**
  * Element representing a typedef resynthesized from a summary during linking.
  */
 class FunctionTypeAliasElementForLink extends Object
     with
         TypeParameterizedElementMixin,
         ParameterParentElementForLink,
         ReferenceableElementForLink
@@ skipping 1433 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.
+   * The [FunctionElementForLink_Local] to which this node refers.
    */
-  final VariableElementForLink variableElement;
+  final FunctionElementForLink_Local functionElement;
 
-  TypeInferenceNode(this.variableElement);
+  TypeInferenceNode(this.functionElement);
 
   @override
-  bool get isEvaluated => variableElement._inferredType != null;
+  bool get isEvaluated => functionElement._hasTypeBeenInferred;
 
   /**
    * Collect the type inference dependencies in [unlinkedExecutable] (which
    * should be interpreted relative to [compilationUnit]) and store them in
    * [dependencies].
    */
   void collectDependencies(
       List<TypeInferenceNode> dependencies,
       UnlinkedExecutable unlinkedExecutable,
       CompilationUnitElementForLink compilationUnit) {
@@ skipping 72 matching lines @@
           break;
       }
     }
     assert(refPtr == unlinkedConst.references.length);
     assert(intPtr == unlinkedConst.ints.length);
   }
 
   @override
   List<TypeInferenceNode> computeDependencies() {
     List<TypeInferenceNode> dependencies = <TypeInferenceNode>[];
-    collectDependencies(
-        dependencies,
-        variableElement.unlinkedVariable.initializer,
-        variableElement.compilationUnit);
+    collectDependencies(dependencies, functionElement._unlinkedExecutable,
+        functionElement.compilationUnit);
     return dependencies;
   }
 
   void evaluate(bool inCycle) {
     if (inCycle) {
-      variableElement._inferredType = DynamicTypeImpl.instance;
+      functionElement._setInferredType(DynamicTypeImpl.instance);
     } else {
-      variableElement._inferredType =
-          new ExprTypeComputer(variableElement).compute();
+      functionElement
+          ._setInferredType(new ExprTypeComputer(functionElement).compute());
     }
   }
 
   @override
-  String toString() => 'TypeInferenceNode($variableElement)';
+  String toString() => 'TypeInferenceNode($functionElement)';
 }
 
 class TypeProviderForLink implements TypeProvider {
   final Linker _linker;
 
   InterfaceType _boolType;
   InterfaceType _deprecatedType;
   InterfaceType _doubleType;
   InterfaceType _functionType;
   InterfaceType _futureDynamicType;
@@ skipping 182 matching lines @@
   /**
    * The compilation unit in which this variable appears.
    */
   final CompilationUnitElementForLink compilationUnit;
 
   VariableElementForLink(this.unlinkedVariable, this.compilationUnit) {
     if (compilationUnit.isInBuildUnit &&
         unlinkedVariable.initializer?.bodyExpr != null) {
       _constNode = new ConstVariableNode(this);
       if (unlinkedVariable.type == null) {
-        _typeInferenceNode = new TypeInferenceNode(this);
+        _typeInferenceNode = new TypeInferenceNode(initializer);
       }
     }
   }
 
   /**
    * If the variable has an explicitly declared return type, return it.
    * Otherwise return `null`.
    */
   DartType get declaredType {
     if (unlinkedVariable.type == null) {
@@ skipping 92 matching lines @@
    * there are no type parameters in scope.
    */
   TypeParameterizedElementMixin get _typeParameterContext;
 
   @override
   noSuchMethod(Invocation invocation) => super.noSuchMethod(invocation);
 
   @override
   String toString() => '$enclosingElement.$name';
 }