Implement AST-based type inference involving expression-type closures.

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 2149 matching lines @@
           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(function.functions[_getNextInt()].type);
           break;
+        case UnlinkedConstOperation.pushParameter:
+          stack.add(_findParameterType(_getNextString()));
+          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);
     assert(stack.length == 1);
@@ skipping 248 matching lines @@
       // to by expressions.
       assert(ref.syntheticReturnType == null);
       // Nor can implicit function types derived from
       // function-typed parameters.
       assert(ref.implicitFunctionTypeIndices.isEmpty);
       ReferenceableElementForLink element = unit.resolveRef(ref.reference);
       stack.add(element.asStaticType);
     }
   }
 
+  /**
+   * Find the parameter in scope called [parameterName] and return its type.
+   */
+  DartType _findParameterType(String parameterName) {
+    FunctionElementForLink_Local f = this.function;
+    while (true) {
+      for (ParameterElement parameter in f.parameters) {
+        if (parameter.name == parameterName) {
+          return parameter.type;
+        }
+      }
+      Element parent = f.enclosingElement;
+      if (parent is FunctionElementForLink_Local) {
+        f = parent;
+      } else {
+        // Parameter not found.  This should never happen in a well-formed
+        // summary.
+        assert(false);
+        return DynamicTypeImpl.instance;
+      }
+    }
+  }
+
   int _getNextInt() {
     return unlinkedConst.ints[intPtr++];
   }
 
   EntityRef _getNextRef() => unlinkedConst.references[refPtr++];
 
   String _getNextString() {
     return unlinkedConst.strings[strPtr++];
   }
 
@@ skipping 202 matching lines @@
   /**
    * Store the results of type inference for this field in
    * [compilationUnit].
    */
   void link(CompilationUnitElementInBuildUnit compilationUnit) {
     if (hasImplicitType) {
       compilationUnit._storeLinkedType(
           unlinkedVariable.inferredTypeSlot,
           isStatic ? inferredType : _inferredInstanceType,
           _typeParameterContext);
+      initializer?.link(compilationUnit);
     }
   }
 
   @override
   String toString() => '$enclosingElement.$name';
 }
 
 /**
  * Specialization of [FieldElementForLink] for enum fields.
  */
@@ skipping 95 matching lines @@
  * Element representing the initializer expression of a variable.
  */
 class FunctionElementForLink_Initializer extends Object
     with ReferenceableElementForLink, TypeParameterizedElementMixin
     implements FunctionElementForLink_Local {
   /**
    * The variable for which this element is the initializer.
    */
   final VariableElementForLink _variable;
 
+  /**
+   * The type inference node for this function, or `null` if it hasn't been
+   * computed yet.
+   */
+  TypeInferenceNode _typeInferenceNode;
+
   List<FunctionElementForLink_Local_NonSynthetic> _functions;
 
   FunctionElementForLink_Initializer(this._variable);
 
   @override
+  TypeInferenceNode get asTypeInferenceNode =>
+      _typeInferenceNode ??= new TypeInferenceNode(this);
+
+  @override
   CompilationUnitElementForLink get compilationUnit =>
       _variable.compilationUnit;
 
   @override
   VariableElementForLink get enclosingElement => _variable;
 
   TypeParameterizedElementMixin get enclosingTypeParameterContext =>
       _variable.enclosingElement is ClassElementForLink
           ? _variable.enclosingElement
           : null;
@@ skipping 42 matching lines @@
   @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;
   }
 
+  /**
+   * Store the results of type inference for this initializer in
+   * [compilationUnit].
+   */
+  void link(CompilationUnitElementInBuildUnit compilationUnit) {
+    for (FunctionElementForLink_Local_NonSynthetic function in functions) {
+      function.link(compilationUnit);
+    }
+  }
+
   @override
   noSuchMethod(Invocation invocation) => super.noSuchMethod(invocation);
 
   @override
   void _setInferredType(DartType type) {
     assert(!_hasTypeBeenInferred);
     _variable._inferredType = type;
   }
 }
 
@@ skipping 20 matching lines @@
 /**
  * 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;
 
+  List<FunctionElementForLink_Local_NonSynthetic> _functions;
+
+  /**
+   * The type inference node for this function, or `null` if it hasn't been
+   * computed yet.
+   */
+  TypeInferenceNode _typeInferenceNode;
+
   FunctionElementForLink_Local_NonSynthetic(
       CompilationUnitElementForLink compilationUnit,
       this.enclosingElement,
       UnlinkedExecutable unlinkedExecutable)
       : super(compilationUnit, unlinkedExecutable);
 
   @override
+  TypeInferenceNode get asTypeInferenceNode =>
+      _typeInferenceNode ??= new TypeInferenceNode(this);
+
+  @override
   TypeParameterizedElementMixin get enclosingTypeParameterContext =>
       enclosingElement;
 
   @override
-  bool get _hasTypeBeenInferred {
-    // TODO(paulberry): add logic to infer types of nonsynthetic functions.
-    return true;
-  }
+  List<FunctionElementForLink_Local_NonSynthetic> get functions =>
+      _functions ??= _unlinkedExecutable.localFunctions
+          .map((UnlinkedExecutable ex) =>
+              new FunctionElementForLink_Local_NonSynthetic(
+                  compilationUnit, this, ex))
+          .toList();
+
+  @override
+  bool get _hasTypeBeenInferred => _inferredReturnType != null;
 
   @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();
+    List<FunctionElementForLink_Local_NonSynthetic> functions = this.functions;
+    return index < functions.length ? functions[index] : null;
+  }
+
+  /**
+   * Store the results of type inference for this function in [compilationUnit].
+   */
+  void link(CompilationUnitElementInBuildUnit compilationUnit) {
+    compilationUnit._storeLinkedType(
+        _unlinkedExecutable.inferredReturnTypeSlot, inferredReturnType, this);
+    for (FunctionElementForLink_Local_NonSynthetic function in functions) {
+      function.link(compilationUnit);
+    }
   }
 
   @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();
+    // TODO(paulberry): store the inferred return type in the summary.
+    assert(!_hasTypeBeenInferred);
+    _inferredReturnType = type;
   }
 }
 
 /**
  * Element representing a typedef resynthesized from a summary during linking.
  */
 class FunctionTypeAliasElementForLink extends Object
     with
         TypeParameterizedElementMixin,
         ParameterParentElementForLink,
@@ skipping 1405 matching lines @@
    * Store the results of type inference for this variable in
    * [compilationUnit].
    */
   void link(CompilationUnitElementInBuildUnit compilationUnit) {
     if (hasImplicitType) {
       TypeInferenceNode typeInferenceNode = this._typeInferenceNode;
       if (typeInferenceNode != null) {
         compilationUnit._storeLinkedType(
             unlinkedVariable.inferredTypeSlot, inferredType, null);
       }
+      initializer?.link(compilationUnit);
     }
   }
 }
 
 /**
  * Specialization of [DependencyWalker] for performing type inferrence
  * on static and top level variables.
  */
 class TypeInferenceDependencyWalker
     extends DependencyWalker<TypeInferenceNode> {
@@ skipping 93 matching lines @@
         case UnlinkedConstOperation.invokeMethod:
           intPtr += 2;
           break;
         case UnlinkedConstOperation.typeCast:
         case UnlinkedConstOperation.typeCheck:
           refPtr++;
           break;
         case UnlinkedConstOperation.pushLocalFunctionReference:
           int popCount = unlinkedConst.ints[intPtr++];
           assert(popCount == 0); // TODO(paulberry): handle the nonzero case.
-          collectDependencies(
-              dependencies,
-              unlinkedExecutable.localFunctions[unlinkedConst.ints[intPtr++]],
-              compilationUnit);
+          dependencies.add(functionElement
+              .getLocalFunction(unlinkedConst.ints[intPtr++])
+              .asTypeInferenceNode);
           break;
         default:
           break;
       }
     }
     assert(refPtr == unlinkedConst.references.length);
     assert(intPtr == unlinkedConst.ints.length);
   }
 
   @override
@@ skipping 210 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(initializer);
+        _typeInferenceNode = initializer.asTypeInferenceNode;
       }
     }
   }
 
   /**
    * 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';
 }