Don't serialize local 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/token.dart';
 import 'package:analyzer/dart/ast/visitor.dart';
 import 'package:analyzer/dart/element/type.dart' show DartType;
@@ skipping 233 matching lines @@
    * 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],
-   * [UnlinkedClass.fields] or [UnlinkedExecutable.localVariables].
+   * List of objects which should be written to [UnlinkedUnit.variables] or
+   * [UnlinkedClass.fields].
    */
   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 286 matching lines @@
   UnlinkedExprBuilder serializeConstExpr(
       bool forConst, Map<int, int> localClosureIndexMap, Expression expression,
       [Set<String> parameterNames]) {
     _ConstExprSerializer serializer = new _ConstExprSerializer(
         forConst, this, localClosureIndexMap, parameterNames);
     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,
-      TypeAnnotation 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('\n')
@@ skipping 125 matching lines @@
     if (body is BlockFunctionBody || body is ExpressionFunctionBody) {
       for (UnlinkedParamBuilder parameter in b.parameters) {
         if (!parameter.isInitializingFormal) {
           parameter.visibleOffset = body.offset;
           parameter.visibleLength = body.length;
         }
       }
     }
     List<UnlinkedExecutableBuilder> oldExecutables = executables;
     List<UnlinkedLabelBuilder> oldLabels = labels;
-    List<UnlinkedVariableBuilder> oldVariables = variables;
     Map<int, int> oldLocalClosureIndexMap = _localClosureIndexMap;
     bool oldSerializeClosureBodyExprs = _serializeClosureBodyExprs;
     executables = <UnlinkedExecutableBuilder>[];
     labels = <UnlinkedLabelBuilder>[];
-    variables = <UnlinkedVariableBuilder>[];
     _localClosureIndexMap = <int, int>{};
     _serializeClosureBodyExprs = serializeBodyExpr;
     if (initializers != null) {
       for (ConstructorInitializer initializer in initializers) {
         initializer.accept(this);
       }
     }
     if (serializeBody) {
       body.accept(this);
     }
     if (serializeBodyExpr) {
       if (body is Expression) {
         b.bodyExpr = serializeConstExpr(
             forConst, _localClosureIndexMap, body, _parameterNames);
       } else if (body is ExpressionFunctionBody) {
         b.bodyExpr = serializeConstExpr(
             forConst, _localClosureIndexMap, body.expression, _parameterNames);
       } else {
         // TODO(paulberry): serialize other types of function bodies.
       }
     }
     b.localFunctions = executables;
     b.localLabels = labels;
-    b.localVariables = variables;
     Map<int, int> localClosureIndexMap = _localClosureIndexMap;
     executables = oldExecutables;
     labels = oldLabels;
-    variables = oldVariables;
     _localClosureIndexMap = oldLocalClosureIndexMap;
     _serializeClosureBodyExprs = oldSerializeClosureBodyExprs;
     return localClosureIndexMap;
   }
 
   /**
    * Serialize the return type and parameters of a function-typed formal
    * parameter and store them in [b].
    */
   void serializeFunctionTypedParameterDetails(UnlinkedParamBuilder b,
@@ skipping 214 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) {
     bool isCovariant = isField
         ? (variables.parent as FieldDeclaration).covariantKeyword != null
         : false;
     for (VariableDeclaration variable in variables.variables) {
       UnlinkedVariableBuilder b = new UnlinkedVariableBuilder();
@@ skipping 17 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 = scopeNode?.offset;
-      b.visibleLength = scopeNode?.length;
       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;
-    if (exception != null) {
-      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 117 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(null, node.fields, node.staticKeyword != null,
+    serializeVariables(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;
-    if (loopVariable != null) {
-      serializeDeclaredIdentifier(
-          node,
-          loopVariable.documentationComment,
-          loopVariable.metadata,
-          loopVariable.isFinal,
-          loopVariable.isConst,
-          loopVariable.type,
-          true,
-          loopVariable.identifier);
-    }
-    super.visitForEachStatement(node);
-  }
-
-  @override
-  void visitForStatement(ForStatement node) {
-    VariableDeclarationList declaredVariables = node.variables;
-    if (declaredVariables != null) {
-      serializeVariables(node, declaredVariables, 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 177 matching lines @@
 
   @override
   UnlinkedParamBuilder visitSimpleFormalParameter(SimpleFormalParameter node) {
     UnlinkedParamBuilder b = serializeParameter(node);
     b.type = serializeTypeName(node.type);
     return b;
   }
 
   @override
   void visitTopLevelVariableDeclaration(TopLevelVariableDeclaration node) {
-    serializeVariables(null, node.variables, false, node.documentationComment,
-        node.metadata, false);
+    serializeVariables(
+        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(
-        enclosingBlock, node.variables, false, null, null, false);
+//    serializeVariables(node.variables, false, null, null, false);

[Paul Berry, 2017/06/29 21:34:33]

Should we just remove this override entirely?

[scheglov, 2017/06/29 21:39:54]

We cannot do this.
If there are function expressions in initializers, we will serialize them.
I will add TODO to return to this later.

   }
 
   /**
    * Compute the API signature of the unit and record it.
    */
   static void _computeApiSignature(UnlinkedUnitBuilder b) {
     ApiSignature apiSignature = new ApiSignature();
     b.collectApiSignature(apiSignature);
     b.apiSignature = apiSignature.toByteList();
   }
 }
 
 /**
  * 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;
 }