When summarize AST, include local variables in loops and try-catch.

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/src/generated/utilities_dart.dart';
@@ skipping 461 matching lines @@
    */
   UnlinkedConstBuilder serializeConstExpr(Expression expression,
       [Set<String> constructorParameterNames]) {
     _ConstExprSerializer serializer =
         new _ConstExprSerializer(this, constructorParameterNames);
     serializer.serialize(expression);
     return serializer.toBuilder();
   }
 
   /**
+   * Serialize the given [declaredIdentifier] into [UnlinkedVariable], and
+   * store it in [variables].
+   */
+  void serializeDeclaredIdentifier(
+      AstNode scopeNode,
+      Comment documentationComment,
+      NodeList<Annotation> annotations,
+      bool isFinal,
+      bool isConst,
+      TypeName type,
+      bool assignPropagatedTypeSlot,
+      SimpleIdentifier declaredIdentifier) {
+    UnlinkedVariableBuilder b = new UnlinkedVariableBuilder();
+    b.isFinal = isFinal;
+    b.isConst = isConst;
+    b.name = declaredIdentifier.name;
+    b.nameOffset = declaredIdentifier.offset;
+    b.type = serializeTypeName(type);
+    b.documentationComment = serializeDocumentation(documentationComment);
+    b.annotations = serializeAnnotations(annotations);
+    b.codeRange = serializeCodeRange(declaredIdentifier);
+    if (assignPropagatedTypeSlot) {
+      b.propagatedTypeSlot = assignSlot();
+    }
+    b.visibleOffset = scopeNode?.offset;
+    b.visibleLength = scopeNode?.length;
+    this.variables.add(b);
+  }
+
+  /**
    * Serialize a [Comment] node into an [UnlinkedDocumentationComment] object.
    */
   UnlinkedDocumentationCommentBuilder serializeDocumentation(
       Comment documentationComment) {
     if (documentationComment == null) {
       return null;
     }
     String text = documentationComment.tokens
         .map((Token t) => t.toString())
         .join()
@@ skipping 277 matching lines @@
       return typeParameters.typeParameters.map(visitTypeParameter).toList();
     }
     return const <UnlinkedTypeParamBuilder>[];
   }
 
   /**
    * Serialize the given [variables] into [UnlinkedVariable]s, and store them
    * in [this.variables].
    */
   void serializeVariables(
+      AstNode scopeNode,
       VariableDeclarationList variables,
       bool isDeclaredStatic,
       Comment documentationComment,
       NodeList<Annotation> annotations,
       bool isField) {
     for (VariableDeclaration variable in variables.variables) {
       UnlinkedVariableBuilder b = new UnlinkedVariableBuilder();
       b.isFinal = variables.isFinal;
       b.isConst = variables.isConst;
       b.isStatic = isDeclaredStatic;
@@ skipping 12 matching lines @@
       }
       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 = enclosingBlock?.offset;
-      b.visibleLength = enclosingBlock?.length;
+      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;
   }
 
   @override
+  void visitCatchClause(CatchClause node) {
+    SimpleIdentifier exception = node.exceptionParameter;
+    SimpleIdentifier st = node.stackTraceParameter;
+    serializeDeclaredIdentifier(
+        node, null, null, false, false, node.exceptionType, false, exception);
+    if (st != null) {
+      serializeDeclaredIdentifier(
+          node, null, null, false, false, null, false, st);
+    }
+    super.visitCatchClause(node);
+  }
+
+  @override
   void visitClassDeclaration(ClassDeclaration node) {
     TypeName superclass =
         node.extendsClause == null ? null : node.extendsClause.superclass;
     serializeClass(
         node,
         node.abstractKeyword,
         node.name.name,
         node.name.offset,
         node.typeParameters,
         superclass,
@@ skipping 109 matching lines @@
   @override
   void visitExportDirective(ExportDirective node) {
     UnlinkedExportNonPublicBuilder b = new UnlinkedExportNonPublicBuilder(
         uriOffset: node.uri.offset, uriEnd: node.uri.end, offset: node.offset);
     b.annotations = serializeAnnotations(node.metadata);
     exports.add(b);
   }
 
   @override
   void visitFieldDeclaration(FieldDeclaration node) {
-    serializeVariables(node.fields, node.staticKeyword != null,
+    serializeVariables(null, node.fields, node.staticKeyword != null,
         node.documentationComment, node.metadata, true);
   }
 
   @override
   UnlinkedParamBuilder visitFieldFormalParameter(FieldFormalParameter node) {
     UnlinkedParamBuilder b = serializeParameter(node);
     b.isInitializingFormal = true;
     if (node.type != null || node.parameters != null) {
       b.isFunctionTyped = node.parameters != null;
       if (node.parameters != null) {
         serializeFunctionTypedParameterDetails(b, node.type, node.parameters);
       } else {
         b.type = serializeTypeName(node.type);
       }
     }
     return b;
   }
 
   @override
+  void visitForEachStatement(ForEachStatement node) {
+    DeclaredIdentifier loopVariable = node.loopVariable;
+    serializeDeclaredIdentifier(
+        node,
+        loopVariable.documentationComment,
+        loopVariable.metadata,
+        loopVariable.isFinal,
+        loopVariable.isConst,
+        loopVariable.type,
+        true,
+        loopVariable.identifier);
+    super.visitForEachStatement(node);
+  }
+
+  @override
+  void visitForStatement(ForStatement node) {
+    serializeVariables(node, node.variables, false, null, null, false);
+    super.visitForStatement(node);
+  }
+
+  @override
   void visitFunctionDeclaration(FunctionDeclaration node) {
     executables.add(serializeExecutable(
         node,
         node.name.name,
         node.name.offset,
         node.isGetter,
         node.isSetter,
         node.returnType,
         node.functionExpression.parameters,
         node.functionExpression.body,
@@ skipping 137 matching lines @@
 
   @override
   UnlinkedParamBuilder visitSimpleFormalParameter(SimpleFormalParameter node) {
     UnlinkedParamBuilder b = serializeParameter(node);
     b.type = serializeTypeName(node.type);
     return b;
   }
 
   @override
   void visitTopLevelVariableDeclaration(TopLevelVariableDeclaration node) {
-    serializeVariables(
-        node.variables, false, node.documentationComment, node.metadata, false);
+    serializeVariables(null, node.variables, false, node.documentationComment,
+        node.metadata, false);
   }
 
   @override
   UnlinkedTypeParamBuilder visitTypeParameter(TypeParameter node) {
     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);
     b.codeRange = serializeCodeRange(node);
     return b;
   }
 
   @override
   void visitVariableDeclarationStatement(VariableDeclarationStatement node) {
-    serializeVariables(node.variables, false, null, null, false);
+    serializeVariables(
+        enclosingBlock, 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;
 }