First steps toward AST-based type inference involving 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 200 matching lines @@
       _storeTypeArguments(
           type.typeArguments, result, compilationUnit, typeParameterContext);
       return result;
     }
     if (element is FunctionTypeAliasElementForLink) {
       result.reference = compilationUnit.addReference(element);
       _storeTypeArguments(
           type.typeArguments, result, compilationUnit, typeParameterContext);
       return result;
     }
-    if (element is FunctionElement) {
-      // Element is a FunctionElement but not a TopLevelFunctionElementForLink
-      // or a MethodElementForLink.  This means that it's a synthetic function
-      // element that was generated on the fly to represent a type that has no
-      // associated source code location.
-      assert(element.enclosingElement == null);
+    if (element is FunctionElement && element.enclosingElement == null) {
+      // Element is a synthetic function element that was generated on the fly
+      // to represent a type that has no associated source code location.
       result.syntheticReturnType = _createLinkedType(
           element.returnType, compilationUnit, typeParameterContext);
       result.syntheticParams = element.parameters
           .map((ParameterElement param) => _serializeSyntheticParam(
               param, compilationUnit, typeParameterContext))
           .toList();
       return result;
     }
+    if (element is FunctionElement) {
+      // Element is a local function inside another executable.
+      result.reference = compilationUnit.addReference(element);
+      // TODO(paulberry): do I need to store type arguments?
+      return result;
+    }
     // TODO(paulberry): implement other cases.
     throw new UnimplementedError('${element.runtimeType}');
   }
   // TODO(paulberry): implement other cases.
   throw new UnimplementedError('${type.runtimeType}');
 }
 
 /**
  * Create an [UnlinkedParam] representing the given [parameter], which should be
  * a parameter of a synthetic function type (e.g. one produced during type
@@ skipping 823 matching lines @@
    * If this compilation unit already has a reference in its references table
    * matching [dependency], [name], [numTypeParameters], [unitNum],
    * [containingReference], and [kind], return its index.  Otherwise add a new reference to
    * the table and return its index.
    */
   int addRawReference(String name,
       {int dependency: 0,
       int numTypeParameters: 0,
       int unitNum: 0,
       int containingReference: 0,
+      int localIndex: 0,
       ReferenceKind kind: ReferenceKind.classOrEnum}) {
     List<LinkedReferenceBuilder> linkedReferences = _linkedUnit.references;
     List<UnlinkedReference> unlinkedReferences = _unlinkedUnit.references;
     for (int i = 0; i < linkedReferences.length; i++) {
       LinkedReferenceBuilder linkedReference = linkedReferences[i];
       int candidateContainingReference = i < unlinkedReferences.length
           ? unlinkedReferences[i].prefixReference
           : linkedReference.containingReference;
       if (candidateContainingReference != 0 &&
           linkedReferences[candidateContainingReference].kind ==
               ReferenceKind.prefix) {
         // We don't need to match containing references when they are prefixes,
         // since the relevant information is in linkedReference.dependency.
         candidateContainingReference = 0;
       }
       if (linkedReference.dependency == dependency &&
           (i < unlinkedReferences.length
                   ? unlinkedReferences[i].name
                   : linkedReference.name) ==
               name &&
           linkedReference.numTypeParameters == numTypeParameters &&
           linkedReference.unit == unitNum &&
           candidateContainingReference == containingReference &&
-          linkedReference.kind == kind) {
+          linkedReference.kind == kind &&
+          linkedReference.localIndex == localIndex) {
         return i;
       }
     }
     int result = linkedReferences.length;
     linkedReferences.add(new LinkedReferenceBuilder(
         dependency: dependency,
         name: name,
         numTypeParameters: numTypeParameters,
         unit: unitNum,
         containingReference: containingReference,
-        kind: kind));
+        kind: kind,
+        localIndex: localIndex));
     return result;
   }
 
   /**
    * If this compilation unit already has a reference in its references table
    * to [element], return its index.  Otherwise add a new reference to the table
    * and return its index.
    */
   int addReference(Element element) {
     if (element is ClassElementForLink) {
@@ skipping 21 matching lines @@
           break;
         default:
           // TODO(paulberry): implement other cases as necessary
           throw new UnimplementedError('${element._unlinkedExecutable.kind}');
       }
       return addRawReference(element.name,
           numTypeParameters: element.typeParameters.length,
           containingReference:
               enclosingClass != null ? addReference(enclosingClass) : null,
           kind: kind);
+    } else if (element is FunctionElementForLink_Local) {
+      FunctionElementImpl parent = element.enclosingElement;
+      int localIndex = parent.functions.indexOf(element);
+      assert(localIndex != -1);
+      return addRawReference(element.name,
+          containingReference: addReference(parent),
+          kind: ReferenceKind.function,
+          localIndex: localIndex);
+    } else if (element is FunctionElementForLink_Initializer) {
+      return addRawReference('',
+          containingReference: addReference(element.enclosingElement),
+          kind: ReferenceKind.function);
+    } else if (element is TopLevelVariableElementForLink) {
+      return addRawReference(element.name,
+          kind: ReferenceKind.topLevelPropertyAccessor);
+    } else if (element is FieldElementForLink_ClassField) {
+      ClassElementForLink_Class enclosingClass = element.enclosingElement;
+      // TODO(paulberry): do we need to set numTypeParameters to nonzero if the
+      // class has type parameters?
+      return addRawReference(element.name,
+          containingReference: addReference(enclosingClass),
+          kind: ReferenceKind.propertyAccessor);
     }
     // TODO(paulberry): implement other cases
     throw new UnimplementedError('${element.runtimeType}');
   }
 
   @override
   DartType getLinkedType(
       int slot, TypeParameterizedElementForLink typeParameterContext) {
     // This method should only be called on compilation units that come from
     // dependencies, never on compilation units that are part of the current
@@ skipping 745 matching lines @@
       // considered to return `void`.
       return VoidTypeImpl.instance;
     } else {
       return DynamicTypeImpl.instance;
     }
   }
 }
 
 class ExprTypeComputer {
   VariableElementForLink variable;
+  FunctionElementForLink_Initializer initializer;
   CompilationUnitElementForLink unit;
   LibraryElementForLink library;
   Linker linker;
   TypeProvider typeProvider;
   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.constExpr;
   }
 
   DartType compute() {
     // Perform RPN evaluation of the constant, using a stack of inferred types.
     for (UnlinkedConstOperation operation in unlinkedConst.operations) {
@@ skipping 146 matching lines @@
           break;
         case UnlinkedConstOperation.typeCheck:
           stack.removeLast();
           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);
+          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 583 matching lines @@
 
 /**
  * Element representing the initializer expression of a variable.
  */
 class FunctionElementForLink_Initializer implements FunctionElementImpl {
   /**
    * The variable for which this element is the initializer.
    */
   final VariableElementForLink _variable;
 
+  List<FunctionElementForLink_Local> _functions;
+
   FunctionElementForLink_Initializer(this._variable);
 
   @override
+  VariableElementForLink get enclosingElement => _variable;
+
+  @override
+  List<FunctionElementForLink_Local> get functions => _functions ??= _variable
+      .unlinkedVariable.initializer.localFunctions
+      .map(
+          (UnlinkedExecutable ex) => new FunctionElementForLink_Local(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
   noSuchMethod(Invocation invocation) => super.noSuchMethod(invocation);
 }
 
 /**
+ * Element representing a local function (possibly a closure) inside another
+ * executable.
+ */
+class FunctionElementForLink_Local implements FunctionElementImpl {
+  /**
+   * The unlinked representation of the local function in the summary.
+   */
+  final UnlinkedExecutable _executable;
+
+  @override
+  final FunctionElementImpl enclosingElement;
+
+  DartType _type;
+
+  FunctionElementForLink_Local(this.enclosingElement, this._executable);
+
+  @override
+  String get name => _executable.name;
+
+  @override
+  DartType get type => _type ??= new FunctionTypeImpl(this);
+
+  @override
+  noSuchMethod(Invocation invocation) => super.noSuchMethod(invocation);
+}
+
+/**
  * Element representing a typedef resynthesized from a summary during linking.
  */
 class FunctionTypeAliasElementForLink extends Object
     with TypeParameterizedElementForLink, ParameterParentElementForLink
     implements
         FunctionTypeAliasElement,
         ReferenceableElementForLink,
         ElementImpl {
   @override
   final CompilationUnitElementForLink enclosingElement;
@@ skipping 2011 matching lines @@
    * there are no type parameters in scope.
    */
   TypeParameterizedElementForLink get _typeParameterContext;
 
   @override
   noSuchMethod(Invocation invocation) => super.noSuchMethod(invocation);
 
   @override
   String toString() => '$enclosingElement.$name';
 }