Serialize local functions and variables.

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/visitor.dart';
 import 'package:analyzer/src/generated/scanner.dart';
 import 'package:analyzer/src/generated/utilities_dart.dart';
@@ skipping 75 matching lines @@
           'Unexpected identifier type: ${identifier.runtimeType}');
     }
     return b;
   }
 
   @override
   EntityRefBuilder serializePropertyAccess(PropertyAccess access) {
     Expression target = access.target;
     if (target is Identifier) {
       EntityRefBuilder targetRef = serializeIdentifier(target);
-      return new EntityRefBuilder(
-          reference: visitor.serializeReference(
-              targetRef.reference, access.propertyName.name));
+      return new EntityRefBuilder(reference: visitor.serializeReference(
+          targetRef.reference, access.propertyName.name));
     } else {
       // TODO(scheglov) should we handle other targets in malformed constants?
       throw new StateError('Unexpected target type: ${target.runtimeType}');
     }
   }
 
   @override
   EntityRefBuilder serializeType(TypeName node) {
     return visitor.serializeTypeName(node);
   }
@@ skipping 54 matching lines @@
    * 1, and each preceding type parameter has the next higher index.
    */
   final int index;
 
   _ScopedTypeParameter(this.index);
 }
 
 /**
  * Visitor used to create a summary from an AST.
  */
-class _SummarizeAstVisitor extends SimpleAstVisitor {
+class _SummarizeAstVisitor extends RecursiveAstVisitor {
   /**
    * List of objects which should be written to [UnlinkedUnit.classes].
    */
   final List<UnlinkedClassBuilder> classes = <UnlinkedClassBuilder>[];
 
   /**
    * List of objects which should be written to [UnlinkedUnit.enums].
    */
   final List<UnlinkedEnumBuilder> enums = <UnlinkedEnumBuilder>[];
 
   /**
-   * List of objects which should be written to [UnlinkedUnit.executables]
-   * or [UnlinkedClass.executables].
+   * List of objects which should be written to [UnlinkedUnit.executables],
+   * [UnlinkedClass.executables] or [UnlinkedExecutable.localFunctions].
    */
   List<UnlinkedExecutableBuilder> executables = <UnlinkedExecutableBuilder>[];
 
   /**
    * List of objects which should be written to [UnlinkedUnit.exports].
    */
   final List<UnlinkedExportNonPublicBuilder> exports =
       <UnlinkedExportNonPublicBuilder>[];
 
   /**
    * List of objects which should be written to [UnlinkedUnit.parts].
    */
   final List<UnlinkedPartBuilder> parts = <UnlinkedPartBuilder>[];
 
   /**
    * List of objects which should be written to [UnlinkedUnit.typedefs].
    */
   final List<UnlinkedTypedefBuilder> typedefs = <UnlinkedTypedefBuilder>[];
 
   /**
-   * List of objects which should be written to [UnlinkedUnit.variables] or
-   * [UnlinkedClass.fields].
+   * List of objects which should be written to [UnlinkedUnit.variables],
+   * [UnlinkedClass.fields] or [UnlinkedExecutable.localVariables].
    */
   List<UnlinkedVariableBuilder> variables = <UnlinkedVariableBuilder>[];
 
   /**
    * The unlinked portion of the "imports table".  This is the list of objects
    * which should be written to [UnlinkedUnit.imports].
    */
   final List<UnlinkedImportBuilder> unlinkedImports = <UnlinkedImportBuilder>[];
 
   /**
@@ skipping 59 matching lines @@
    * Otherwise `null`.
    */
   List<UnlinkedConst> libraryAnnotations = const <UnlinkedConstBuilder>[];
 
   /**
    * 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;
+
+  /**
    * A flag indicating whether a variable declaration is in the context of a
    * field declaration.
    */
   bool inFieldContext = false;
 
   /**
    * Create a slot id for storing a propagated or inferred type.
    */
   int assignTypeSlot() => ++numSlots;
 
@@ skipping 23 matching lines @@
     }
     return scope;
   }
 
   /**
    * Serialize the given list of [annotations].  If there are no annotations,
    * the empty list is returned.
    */
   List<UnlinkedConstBuilder> serializeAnnotations(
       NodeList<Annotation> annotations) {
-    if (annotations.isEmpty) {
+    if (annotations == null || annotations.isEmpty) {
       return const <UnlinkedConstBuilder>[];
     }
     return annotations.map((Annotation a) {
       _ConstExprSerializer serializer = new _ConstExprSerializer(this, null);
       serializer.serializeAnnotation(a);
       return serializer.toBuilder();
     }).toList();
   }
 
   /**
@@ skipping 182 matching lines @@
             b.parameters[i].inferredTypeSlot = assignTypeSlot();
           }
         }
       }
     }
     b.documentationComment = serializeDocumentation(documentationComment);
     b.annotations = serializeAnnotations(annotations);
     if (returnType == null && !isSemanticallyStatic) {
       b.inferredReturnTypeSlot = assignTypeSlot();
     }
+    b.visibleOffset = enclosingBlock?.offset;
+    b.visibleLength = enclosingBlock?.length;
+    serializeFunctionBody(b, body);
     scopes.removeLast();
     assert(scopes.length == oldScopesLength);
     return b;
   }
 
+  void serializeFunctionBody(UnlinkedExecutableBuilder b, FunctionBody body) {
+    List<UnlinkedExecutableBuilder> oldExecutables = executables;
+    List<UnlinkedVariableBuilder> oldVariables = variables;
+    executables = <UnlinkedExecutableBuilder>[];
+    variables = <UnlinkedVariableBuilder>[];
+    body.accept(this);
+    b.localFunctions = executables;
+    b.localVariables = variables;
+    executables = oldExecutables;
+    variables = oldVariables;
+  }
+
   /**
    * Serialize the return type and parameters of a function-typed formal
    * parameter and store them in [b].
    */
   void serializeFunctionTypedParameterDetails(UnlinkedParamBuilder b,
       TypeName returnType, FormalParameterList parameters) {
     EntityRefBuilder serializedReturnType = serializeTypeName(returnType);
     if (serializedReturnType != null) {
       b.type = serializedReturnType;
     }
@@ skipping 176 matching lines @@
       }
       if (variable.initializer != null &&
           (variables.isFinal || variables.isConst)) {
         b.propagatedTypeSlot = assignTypeSlot();
       }
       bool isSemanticallyStatic = !isField || isDeclaredStatic;
       if (variables.type == null &&
           (variable.initializer != null || !isSemanticallyStatic)) {
         b.inferredTypeSlot = assignTypeSlot();
       }
+      b.visibleOffset = enclosingBlock?.offset;
+      b.visibleLength = enclosingBlock?.length;
       this.variables.add(b);
     }
   }
 
   @override
+  void visitBlock(Block node) {
+    Block oldBlock = enclosingBlock;
+    enclosingBlock = node;
+    super.visitBlock(node);
+    enclosingBlock = oldBlock;
+  }
+
+  @override
   void visitClassDeclaration(ClassDeclaration node) {
     TypeName superclass =
         node.extendsClause == null ? null : node.extendsClause.superclass;
     serializeClass(
         node.abstractKeyword,
         node.name.name,
         node.name.offset,
         node.typeParameters,
         superclass,
         node.withClause,
@@ skipping 56 matching lines @@
     if (node.constKeyword != null) {
       Set<String> constructorParameterNames =
           node.parameters.parameters.map((p) => p.identifier.name).toSet();
       b.constantInitializers = node.initializers
           .map((ConstructorInitializer initializer) =>
               serializeConstructorInitializer(initializer, (Expression expr) {
                 return serializeConstExpr(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);
     }
@@ skipping 175 matching lines @@
     UnlinkedTypeParamBuilder b = new UnlinkedTypeParamBuilder();
     b.name = node.name.name;
     b.nameOffset = node.name.offset;
     if (node.bound != null) {
       b.bound = serializeTypeName(node.bound);
     }
     b.annotations = serializeAnnotations(node.metadata);
     return b;
   }
 
+  @override
+  void visitVariableDeclarationStatement(VariableDeclarationStatement node) {
+    serializeVariables(node.variables, false, null, null, false);
+  }
+
   /**
    * 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;
 }