First steps toward AST-based type inference involving closures.

pkg/analyzer/lib/src/summary/summarize_ast.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.
 
 library serialization.summarize_ast;
 
 import 'package:analyzer/dart/ast/ast.dart';
 import 'package:analyzer/dart/ast/token.dart';
 import 'package:analyzer/dart/ast/visitor.dart';
 import 'package:analyzer/dart/element/type.dart' show DartType;
@@ skipping 11 matching lines @@
 }
 
 /**
  * Instances of this class keep track of intermediate state during
  * serialization of a single constant [Expression].
  */
 class _ConstExprSerializer extends AbstractConstExprSerializer {
   final _SummarizeAstVisitor visitor;
 
   /**
+   * If the expression being serialized can contain closures, map whose
+   * keys are the offsets of local function nodes representing those closures,
+   * and whose values are indices of those local functions relative to their
+   * siblings.
+   */
+  final Map<int, int> localClosureIndexMap;
+
+  /**
    * If a constructor initializer expression is being serialized, the names of
    * the constructor parameters.  Otherwise `null`.
    */
   final Set<String> constructorParameterNames;
 
-  _ConstExprSerializer(this.visitor, this.constructorParameterNames);
+  _ConstExprSerializer(
+      this.visitor, this.localClosureIndexMap, this.constructorParameterNames);
 
   @override
   bool isConstructorParameterName(String name) {
     return constructorParameterNames?.contains(name) ?? false;
   }
 
   @override
   void serializeAnnotation(Annotation annotation) {
     if (annotation.arguments == null) {
       assert(annotation.constructorName == null);
@@ skipping 19 matching lines @@
     if (name == null) {
       return typeBuilder;
     } else {
       int nameRef =
           visitor.serializeReference(typeBuilder.reference, name.name);
       return new EntityRefBuilder(
           reference: nameRef, typeArguments: typeBuilder.typeArguments);
     }
   }
 
+  @override
+  List<int> serializeFunctionExpression(FunctionExpression functionExpression) {
+    int localIndex;
+    if (localClosureIndexMap == null) {
+      return null;
+    } else {
+      localIndex = localClosureIndexMap[functionExpression.offset];
+      assert(localIndex != null);
+      return <int>[0, localIndex];
+    }
+  }
+
   EntityRefBuilder serializeIdentifier(Identifier identifier) {
     EntityRefBuilder b = new EntityRefBuilder();
     if (identifier is SimpleIdentifier) {
       int index = visitor.serializeSimpleReference(identifier.name,
           allowTypeParameter: true);
       if (index < 0) {
         b.paramReference = -index;
       } else {
         b.reference = index;
       }
@@ skipping 223 matching lines @@
    * The number of slot ids which have been assigned to this compilation unit.
    */
   int numSlots = 0;
 
   /**
    * The [Block] that is being visited now, or `null` for non-local contexts.
    */
   Block enclosingBlock = null;
 
   /**
+   * If an expression is being serialized which can contain closures, map whose
+   * keys are the offsets of local function nodes representing those closures,
+   * and whose values are indices of those local functions relative to their
+   * siblings.
+   */
+  Map<int, int> _localClosureIndexMap;
+
+  /**
    * Create a slot id for storing a propagated or inferred type or const cycle
    * info.
    */
   int assignSlot() => ++numSlots;
 
   /**
    * Build a [_Scope] object containing the names defined within the body of a
    * class declaration.
    */
   _Scope buildClassMemberScope(
@@ skipping 22 matching lines @@
   /**
    * Serialize the given list of [annotations].  If there are no annotations,
    * the empty list is returned.
    */
   List<UnlinkedConstBuilder> serializeAnnotations(
       NodeList<Annotation> annotations) {
     if (annotations == null || annotations.isEmpty) {
       return const <UnlinkedConstBuilder>[];
     }
     return annotations.map((Annotation a) {
-      _ConstExprSerializer serializer = new _ConstExprSerializer(this, null);
+      var localClosureIndexMap = null; // TODO(paulberry): fix.

[scheglov, 2016/05/10 21:47:03]

Do we want to have types for these variables?

[Paul Berry, 2016/05/10 22:04:15]

Good point.  Fixed.

+      _ConstExprSerializer serializer =
+          new _ConstExprSerializer(this, localClosureIndexMap, null);
       serializer.serializeAnnotation(a);
       return serializer.toBuilder();
     }).toList();
   }
 
   /**
    * Serialize a [ClassDeclaration] or [ClassTypeAlias] into an [UnlinkedClass]
    * and store the result in [classes].
    */
   void serializeClass(
@@ skipping 107 matching lines @@
     b.references = unlinkedReferences;
     b.typedefs = typedefs;
     b.variables = variables;
     b.publicNamespace = computePublicNamespace(compilationUnit);
     return b;
   }
 
   /**
    * Serialize the given [expression], creating an [UnlinkedConstBuilder].
    */
-  UnlinkedConstBuilder serializeConstExpr(Expression expression,
+  UnlinkedConstBuilder serializeConstExpr(
+      Map<int, int> localClosureIndexMap, Expression expression,
       [Set<String> constructorParameterNames]) {
-    _ConstExprSerializer serializer =
-        new _ConstExprSerializer(this, constructorParameterNames);
+    _ConstExprSerializer serializer = new _ConstExprSerializer(
+        this, localClosureIndexMap, constructorParameterNames);
     serializer.serialize(expression);
     return serializer.toBuilder();
   }
 
   /**
    * Serialize the given [declaredIdentifier] into [UnlinkedVariable], and
    * store it in [variables].
    */
   void serializeDeclaredIdentifier(
       AstNode scopeNode,
@@ skipping 339 matching lines @@
       UnlinkedVariableBuilder b = new UnlinkedVariableBuilder();
       b.isFinal = variables.isFinal;
       b.isConst = variables.isConst;
       b.isStatic = isDeclaredStatic;
       b.name = variable.name.name;
       b.nameOffset = variable.name.offset;
       b.type = serializeTypeName(variables.type);
       b.documentationComment = serializeDocumentation(documentationComment);
       b.annotations = serializeAnnotations(annotations);
       b.codeRange = serializeCodeRange(variables.parent);
+      Map<int, int> localClosureIndexMap = _withLocalClosureIndexMap(() {
+        b.initializer = serializeInitializerFunction(variable.initializer);
+      });
       if (variable.isConst ||
           variable.isFinal && isField && !isDeclaredStatic ||
           variables.type == null) {
         Expression initializer = variable.initializer;
         if (initializer != null) {
-          b.constExpr = serializeConstExpr(initializer);
+          b.constExpr = serializeConstExpr(localClosureIndexMap, initializer);
         }
       }
       if (variable.initializer != null &&
           (variables.isFinal || variables.isConst)) {
         b.propagatedTypeSlot = assignSlot();
       }
       bool isSemanticallyStatic = !isField || isDeclaredStatic;
       if (variables.type == null &&
           (variable.initializer != null || !isSemanticallyStatic)) {
         b.inferredTypeSlot = assignSlot();
       }
       b.visibleOffset = scopeNode?.offset;
       b.visibleLength = scopeNode?.length;
-      b.initializer = serializeInitializerFunction(variable.initializer);
       this.variables.add(b);
     }
   }
 
   @override
   void visitBlock(Block node) {
     Block oldBlock = enclosingBlock;
     enclosingBlock = node;
     super.visitBlock(node);
     enclosingBlock = oldBlock;
@@ skipping 63 matching lines @@
     }
     b.parameters = node.parameters.parameters
         .map((FormalParameter p) => p.accept(this))
         .toList();
     b.kind = UnlinkedExecutableKind.constructor;
     if (node.factoryKeyword != null) {
       b.isFactory = true;
       if (node.redirectedConstructor != null) {
         b.isRedirectedConstructor = true;
         TypeName typeName = node.redirectedConstructor.type;
-        b.redirectedConstructor = new _ConstExprSerializer(this, null)
-            .serializeConstructorRef(null, typeName.name,
-                typeName.typeArguments, node.redirectedConstructor.name);
+        var localClosureIndexMap = null; // TODO(paulberry): fix.
+        b.redirectedConstructor =
+            new _ConstExprSerializer(this, localClosureIndexMap, null)
+                .serializeConstructorRef(null, typeName.name,
+                    typeName.typeArguments, node.redirectedConstructor.name);
       }
     } else {
       for (ConstructorInitializer initializer in node.initializers) {
         if (initializer is RedirectingConstructorInvocation) {
           b.isRedirectedConstructor = true;
           b.redirectedConstructorName = initializer.constructorName?.name;
         }
       }
     }
     if (node.constKeyword != null) {
       b.isConst = true;
       b.constCycleSlot = assignSlot();
     }
     b.isExternal = node.externalKeyword != null;
     b.documentationComment = serializeDocumentation(node.documentationComment);
     b.annotations = serializeAnnotations(node.metadata);
     b.codeRange = serializeCodeRange(node);
     if (node.constKeyword != null) {
       Set<String> constructorParameterNames =
           node.parameters.parameters.map((p) => p.identifier.name).toSet();
+      var localClosureIndexMap = null; // TODO(paulberry): fix.
       b.constantInitializers = node.initializers
           .map((ConstructorInitializer initializer) =>
               serializeConstructorInitializer(initializer, (Expression expr) {
-                return serializeConstExpr(expr, constructorParameterNames);
+                return serializeConstExpr(
+                    localClosureIndexMap, expr, constructorParameterNames);
               }))
           .toList();
     }
     serializeFunctionBody(b, node.body);
     executables.add(b);
   }
 
   @override
   UnlinkedParamBuilder visitDefaultFormalParameter(
       DefaultFormalParameter node) {
     UnlinkedParamBuilder b = node.parameter.accept(this);
     if (node.defaultValue != null) {
-      b.defaultValue = serializeConstExpr(node.defaultValue);
+      var localClosureIndexMap = null; // TODO(paulberry): fix.
+      b.defaultValue =
+          serializeConstExpr(localClosureIndexMap, node.defaultValue);
       b.defaultValueCode = node.defaultValue.toSource();
     }
     b.initializer = serializeInitializerFunction(node.defaultValue);
     b.codeRange = serializeCodeRange(node);
     return b;
   }
 
   @override
   void visitEnumDeclaration(EnumDeclaration node) {
     UnlinkedEnumBuilder b = new UnlinkedEnumBuilder();
@@ skipping 82 matching lines @@
         false,
         node.documentationComment,
         node.metadata,
         node.functionExpression.typeParameters,
         node.externalKeyword != null));
   }
 
   @override
   void visitFunctionExpression(FunctionExpression node) {
     if (node.parent is! FunctionDeclaration) {
+      if (_localClosureIndexMap != null) {
+        _localClosureIndexMap[node.offset] = executables.length;
+      }
       executables.add(serializeExecutable(
           node,
           null,
           node.offset,
           false,
           false,
           null,
           node.parameters,
           node.body,
           false,
@@ skipping 142 matching lines @@
     return b;
   }
 
   @override
   void visitVariableDeclarationStatement(VariableDeclarationStatement node) {
     serializeVariables(
         enclosingBlock, node.variables, false, null, null, false);
   }
 
   /**
+   * Execute [callback], gathering any local closures in
+   * [_localClosureIndexMap], and return the resulting map.
+   *
+   * Properly handles cases where one closure is nested within another.
+   */
+  Map<int, int> _withLocalClosureIndexMap(void callback()) {
+    Map<int, int> prevLocalClosureIndexMap = _localClosureIndexMap;
+    _localClosureIndexMap = <int, int>{};
+    callback();
+    Map<int, int> localClosureIndexMap = _localClosureIndexMap;
+    _localClosureIndexMap = prevLocalClosureIndexMap;
+    return localClosureIndexMap;
+  }
+
+  /**
    * Helper method to determine if a given [typeName] refers to `dynamic`.
    */
   static bool isDynamic(TypeName typeName) {
     Identifier name = typeName.name;
     return name is SimpleIdentifier && name.name == 'dynamic';
   }
 }
 
 /**
  * A [_TypeParameterScope] is a [_Scope] which defines [_ScopedTypeParameter]s.
  */
 class _TypeParameterScope extends _Scope {
   /**
    * Get the number of [_ScopedTypeParameter]s defined in this
    * [_TypeParameterScope].
    */
   int get length => _definedNames.length;
 }