Store literal values and invocations arguments only for constants and untyped literals.

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 25 matching lines @@
    * siblings.
    */
   final Map<int, int> localClosureIndexMap;
 
   /**
    * If the expression being serialized appears inside a function body, the names
    * of parameters that are in scope.  Otherwise `null`.
    */
   final Set<String> parameterNames;
 
-  _ConstExprSerializer(
-      this.visitor, this.localClosureIndexMap, this.parameterNames);
+  _ConstExprSerializer(bool forConst, this.visitor, this.localClosureIndexMap,
+      this.parameterNames)
+      : super(forConst);
 
   @override
   bool isParameterName(String name) {
     return parameterNames?.contains(name) ?? false;
   }
 
   @override
   void serializeAnnotation(Annotation annotation) {
     Identifier name = annotation.name;
     EntityRefBuilder constructor;
@@ skipping 348 matching lines @@
   List<UnlinkedExprBuilder> serializeAnnotations(
       NodeList<Annotation> annotations) {
     if (annotations == null || annotations.isEmpty) {
       return const <UnlinkedExprBuilder>[];
     }
     return annotations.map((Annotation a) {
       // Closures can't appear inside annotations, so we don't need a
       // localClosureIndexMap.
       Map<int, int> localClosureIndexMap = null;
       _ConstExprSerializer serializer =
-          new _ConstExprSerializer(this, localClosureIndexMap, null);
+          new _ConstExprSerializer(true, this, localClosureIndexMap, null);
       try {
         serializer.serializeAnnotation(a);
       } on StateError {
         return new UnlinkedExprBuilder()..isValidConst = false;
       }
       return serializer.toBuilder();
     }).toList();
   }
 
   /**
@@ skipping 115 matching lines @@
     b.variables = variables;
     b.publicNamespace = computePublicNamespace(compilationUnit);
     _computeApiSignature(b);
     return b;
   }
 
   /**
    * Serialize the given [expression], creating an [UnlinkedExprBuilder].
    */
   UnlinkedExprBuilder serializeConstExpr(
-      Map<int, int> localClosureIndexMap, Expression expression,
+      bool forConst, Map<int, int> localClosureIndexMap, Expression expression,
       [Set<String> parameterNames]) {
-    _ConstExprSerializer serializer =
-        new _ConstExprSerializer(this, localClosureIndexMap, 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,
@@ skipping 119 matching lines @@
     }
     b.visibleOffset = enclosingBlock?.offset;
     b.visibleLength = enclosingBlock?.length;
     Set<String> oldParameterNames = _parameterNames;
     if (formalParameters != null && formalParameters.parameters.isNotEmpty) {
       _parameterNames =
           _parameterNames == null ? new Set<String>() : _parameterNames.toSet();
       _parameterNames.addAll(formalParameters.parameters
           .map((FormalParameter p) => p.identifier.name));
     }
-    serializeFunctionBody(b, null, body, serializeBodyExpr, serializeBody);
+    serializeFunctionBody(
+        b, null, body, serializeBodyExpr, serializeBody, false);
     _parameterNames = oldParameterNames;
     scopes.removeLast();
     assert(scopes.length == oldScopesLength);
     return b;
   }
 
   /**
    * Record local functions and variables into the given executable. The given
    * [body] is usually an actual [FunctionBody], but may be an [Expression]
    * when we process a synthetic variable initializer function.
    *
    * If [initializers] is non-`null`, closures occurring inside the initializers
    * are serialized first.
    *
    * If [serializeBodyExpr] is `true`, then the function definition is stored
    * in [UnlinkedExecutableBuilder.bodyExpr], and closures occurring inside
    * [initializers] and [body] have their function bodies serialized as well.
    *
    * The return value is a map whose keys are the offsets of local function
    * nodes representing closures inside [initializers] and [body], and whose
    * values are the indices of those local functions relative to their siblings.
    */
   Map<int, int> serializeFunctionBody(
       UnlinkedExecutableBuilder b,
       List<ConstructorInitializer> initializers,
       AstNode body,
       bool serializeBodyExpr,
-      bool serializeBody) {
+      bool serializeBody,
+      bool forConst) {
     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(_localClosureIndexMap, body, _parameterNames);
+        b.bodyExpr = serializeConstExpr(
+            forConst, _localClosureIndexMap, body, _parameterNames);
       } else if (body is ExpressionFunctionBody) {
         b.bodyExpr = serializeConstExpr(
-            _localClosureIndexMap, body.expression, _parameterNames);
+            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;
@@ skipping 42 matching lines @@
   }
 
   /**
    * If the given [expression] is not `null`, serialize it as an
    * [UnlinkedExecutableBuilder], otherwise return `null`.
    *
    * If [serializeBodyExpr] is `true`, then the initializer expression is stored
    * in [UnlinkedExecutableBuilder.bodyExpr].
    */
   UnlinkedExecutableBuilder serializeInitializerFunction(
-      Expression expression, bool serializeBodyExpr) {
+      Expression expression, bool serializeBodyExpr, bool forConst) {
     if (expression == null) {
       return null;
     }
     UnlinkedExecutableBuilder initializer =
         new UnlinkedExecutableBuilder(nameOffset: expression.offset);
     serializeFunctionBody(
-        initializer, null, expression, serializeBodyExpr, true);
+        initializer, null, expression, serializeBodyExpr, true, forConst);
     initializer.inferredReturnTypeSlot = assignSlot();
     return initializer;
   }
 
   /**
    * Serialize a [FieldFormalParameter], [FunctionTypedFormalParameter], or
    * [SimpleFormalParameter] into an [UnlinkedParam].
    */
   UnlinkedParamBuilder serializeParameter(NormalFormalParameter node) {
     UnlinkedParamBuilder b = new UnlinkedParamBuilder();
@@ skipping 179 matching lines @@
       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);
       bool serializeBodyExpr = variable.isConst ||
           variable.isFinal && isField && !isDeclaredStatic ||
           variables.type == null;
-      b.initializer =
-          serializeInitializerFunction(variable.initializer, serializeBodyExpr);
+      b.initializer = serializeInitializerFunction(
+          variable.initializer, serializeBodyExpr, b.isConst);
       if (isField && !isDeclaredStatic && !variables.isFinal) {
         b.inheritsCovariantSlot = assignSlot();
       }
       if (variable.initializer != null &&
           (variables.isFinal || variables.isConst)) {
         b.propagatedTypeSlot = assignSlot();
       }
       bool isSemanticallyStatic = !isField || isDeclaredStatic;
       if (variables.type == null &&
           (variable.initializer != null || !isSemanticallyStatic)) {
@@ skipping 81 matching lines @@
     b.kind = UnlinkedExecutableKind.constructor;
     if (node.factoryKeyword != null) {
       b.isFactory = true;
       if (node.redirectedConstructor != null) {
         b.isRedirectedConstructor = true;
         TypeName typeName = node.redirectedConstructor.type;
         // Closures can't appear inside factory constructor redirections, so we
         // don't need a localClosureIndexMap.
         Map<int, int> localClosureIndexMap = null;
         b.redirectedConstructor =
-            new _ConstExprSerializer(this, localClosureIndexMap, null)
+            new _ConstExprSerializer(true, 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 || node.body is NativeFunctionBody;
     b.documentationComment = serializeDocumentation(node.documentationComment);
     b.annotations = serializeAnnotations(node.metadata);
     b.codeRange = serializeCodeRange(node);
-    Map<int, int> localClosureIndexMap = serializeFunctionBody(
-        b, node.initializers, node.body, node.constKeyword != null, false);
+    Map<int, int> localClosureIndexMap = serializeFunctionBody(b,
+        node.initializers, node.body, node.constKeyword != null, false, false);
     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(
-                    localClosureIndexMap, expr, constructorParameterNames);
+                return serializeConstExpr(true, localClosureIndexMap, expr,
+                    constructorParameterNames);
               }))
           .toList();
     }
     executables.add(b);
   }
 
   @override
   UnlinkedParamBuilder visitDefaultFormalParameter(
       DefaultFormalParameter node) {
     UnlinkedParamBuilder b =
         node.parameter.accept(this) as UnlinkedParamBuilder;
-    b.initializer = serializeInitializerFunction(node.defaultValue, true);
+    b.initializer = serializeInitializerFunction(node.defaultValue, true, true);
     if (node.defaultValue != null) {
       b.defaultValueCode = node.defaultValue.toSource();
     }
     b.codeRange = serializeCodeRange(node);
     return b;
   }
 
   @override
   void visitEnumDeclaration(EnumDeclaration node) {
     UnlinkedEnumBuilder b = new UnlinkedEnumBuilder();
@@ skipping 301 matching lines @@
 /**
  * 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;
 }