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

pkg/analyzer/lib/src/summary/summarize_const_expr.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_const_expr;
 
 import 'package:analyzer/dart/ast/ast.dart';
 import 'package:analyzer/dart/ast/token.dart';
 import 'package:analyzer/dart/element/type.dart' show DartType;
 import 'package:analyzer/src/summary/format.dart';
@@ skipping 51 matching lines @@
   }
   throw new StateError('Unexpected initializer type ${node.runtimeType}');
 }
 
 /**
  * Instances of this class keep track of intermediate state during
  * serialization of a single constant [Expression].
  */
 abstract class AbstractConstExprSerializer {
   /**
+   * Whether an expression that should be a constant is being serialized.
+   *
+   * For constants we need to store more than we need just for type inference,
+   * because we need to be able to restore these AST to evaluate actual values
+   * of constants. So, we need to store constructor arguments, elements for
+   * list and map literals even if these literals are typed.
+   */
+  final bool forConst;
+
+  /**
    * See [UnlinkedExprBuilder.isValidConst].
    */
   bool isValidConst = true;
 
   /**
    * See [UnlinkedExprBuilder.name].
    */
   String name = null;
 
   /**
@@ skipping 20 matching lines @@
   /**
    * See [UnlinkedExprBuilder.strings].
    */
   final List<String> strings = <String>[];
 
   /**
    * See [UnlinkedExprBuilder.references].
    */
   final List<EntityRefBuilder> references = <EntityRefBuilder>[];
 
+  AbstractConstExprSerializer(this.forConst);
+
   /**
    * Return `true` if the given [name] is a parameter reference.
    */
   bool isParameterName(String name);
 
   /**
    * Serialize the given [expr] expression into this serializer state.
    */
   void serialize(Expression expr) {
     try {
@@ skipping 284 matching lines @@
     } else if (expr is AwaitExpression) {
       isValidConst = false;
       _serialize(expr.expression);
       operations.add(UnlinkedExprOperation.await);
     } else {
       throw new StateError('Unknown expression type: $expr');
     }
   }
 
   void _serializeArguments(ArgumentList argumentList) {
-    List<Expression> arguments = argumentList.arguments;
-    // Serialize the arguments.
-    List<String> argumentNames = <String>[];
-    arguments.forEach((arg) {
-      if (arg is NamedExpression) {
-        argumentNames.add(arg.name.label.name);
-        _serialize(arg.expression);
-      } else {
-        _serialize(arg);
-      }
-    });
-    // Add numbers of named and positional arguments, and the op-code.
-    ints.add(argumentNames.length);
-    strings.addAll(argumentNames);
-    ints.add(arguments.length - argumentNames.length);
+    if (forConst) {
+      List<Expression> arguments = argumentList.arguments;
+      // Serialize the arguments.
+      List<String> argumentNames = <String>[];
+      arguments.forEach((arg) {
+        if (arg is NamedExpression) {
+          argumentNames.add(arg.name.label.name);
+          _serialize(arg.expression);
+        } else {
+          _serialize(arg);
+        }
+      });
+      // Add numbers of named and positional arguments, and the op-code.
+      ints.add(argumentNames.length);
+      strings.addAll(argumentNames);
+      ints.add(arguments.length - argumentNames.length);
+    } else {
+      ints.add(0);
+      ints.add(0);
+    }
   }
 
   void _serializeAssignment(AssignmentExpression expr) {
     isValidConst = false;
     // Push the value.
     _serialize(expr.rightHandSide);
     // Push the assignment operator.
     TokenType operator = expr.operator.type;
     UnlinkedExprAssignOperator assignmentOperator;
     if (operator == TokenType.EQ) {
@@ skipping 73 matching lines @@
     } else if (operator == TokenType.PERCENT) {
       operations.add(UnlinkedExprOperation.modulo);
     } else if (operator == TokenType.QUESTION_QUESTION) {
       operations.add(UnlinkedExprOperation.ifNull);
     } else {
       throw new StateError('Unknown operator: $operator');
     }
   }
 
   void _serializeListLiteral(ListLiteral expr) {
-    List<Expression> elements = expr.elements;
-    elements.forEach(_serialize);
-    ints.add(elements.length);
+    if (forConst || expr.typeArguments == null) {
+      List<Expression> elements = expr.elements;
+      elements.forEach(_serialize);
+      ints.add(elements.length);
+    } else {
+      ints.add(0);
+    }
     if (expr.typeArguments != null &&
         expr.typeArguments.arguments.length == 1) {
       references.add(serializeTypeName(expr.typeArguments.arguments[0]));
       operations.add(UnlinkedExprOperation.makeTypedList);
     } else {
       operations.add(UnlinkedExprOperation.makeUntypedList);
     }
   }
 
   void _serializeMapLiteral(MapLiteral expr) {
-    for (MapLiteralEntry entry in expr.entries) {
-      _serialize(entry.key);
-      _serialize(entry.value);
+    if (forConst || expr.typeArguments == null) {
+      for (MapLiteralEntry entry in expr.entries) {
+        _serialize(entry.key);
+        _serialize(entry.value);
+      }
+      ints.add(expr.entries.length);
+    } else {
+      ints.add(0);
     }
-    ints.add(expr.entries.length);
     if (expr.typeArguments != null &&
         expr.typeArguments.arguments.length == 2) {
       references.add(serializeTypeName(expr.typeArguments.arguments[0]));
       references.add(serializeTypeName(expr.typeArguments.arguments[1]));
       operations.add(UnlinkedExprOperation.makeTypedMap);
     } else {
       operations.add(UnlinkedExprOperation.makeUntypedMap);
     }
   }
 
@@ skipping 112 matching lines @@
     if (typeArguments == null) {
       ints.add(0);
     } else {
       ints.add(typeArguments.arguments.length);
       for (TypeAnnotation type in typeArguments.arguments) {
         references.add(serializeTypeName(type));
       }
     }
   }
 }