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

pkg/analyzer/test/src/summary/summary_common.dart

 // Copyright (c) 2015, 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 analyzer.test.src.summary.summary_common;
 
 import 'package:analyzer/analyzer.dart';
 import 'package:analyzer/dart/ast/ast.dart';
 import 'package:analyzer/error/listener.dart';
 import 'package:analyzer/src/dart/scanner/reader.dart';
@@ skipping 7081 matching lines @@
         strings: [
           'f'
         ],
         referenceValidators: [
           (EntityRef r) => checkTypeRef(r, null, 'C',
               expectedKind: ReferenceKind.classOrEnum)
         ]);
   }
 
   test_expr_functionExpression_asArgument() {
-    if (skipNonConstInitializers) {
-      return;
-    }
     UnlinkedVariable variable = serializeVariableText('''
 final v = foo(5, () => 42);
 foo(a, b) {}
 ''');
     assertUnlinkedConst(variable.initializer.bodyExpr,
         isValidConst: false,
         operators: [
-          UnlinkedExprOperation.pushInt,
-          UnlinkedExprOperation.pushLocalFunctionReference,
           UnlinkedExprOperation.invokeMethodRef
         ],
         ints: [
-          5,
           0,
           0,
-          0,
-          2,
           0
         ],
         referenceValidators: [
           (EntityRef r) => checkTypeRef(r, null, 'foo',
               expectedKind: ReferenceKind.topLevelFunction)
         ]);
   }
 
   test_expr_functionExpression_asArgument_multiple() {
-    if (skipNonConstInitializers) {
-      return;
-    }
     UnlinkedVariable variable = serializeVariableText('''
 final v = foo(5, () => 42, () => 43);
 foo(a, b, c) {}
 ''');
     assertUnlinkedConst(variable.initializer.bodyExpr,
         isValidConst: false,
         operators: [
-          UnlinkedExprOperation.pushInt,
-          UnlinkedExprOperation.pushLocalFunctionReference,
-          UnlinkedExprOperation.pushLocalFunctionReference,
           UnlinkedExprOperation.invokeMethodRef
         ],
         ints: [
-          5,
           0,
           0,
-          0,
-          1,
-          0,
-          3,
           0
         ],
         referenceValidators: [
           (EntityRef r) => checkTypeRef(r, null, 'foo',
               expectedKind: ReferenceKind.topLevelFunction)
         ]);
   }
 
   test_expr_functionExpression_withBlockBody() {
     if (skipNonConstInitializers) {
@@ skipping 241 matching lines @@
     var c = serializeClassText('''
 class C<T> {
   final f = T.k;
 }
 ''');
     assertUnlinkedConst(c.fields[0].initializer.bodyExpr,
         isValidConst: false, operators: []);
   }
 
   test_expr_invokeMethod_instance() {
-    if (skipNonConstInitializers) {
-      return;
-    }
     UnlinkedVariable variable = serializeVariableText('''
 class C {
   int m(a, {b, c}) => 42;
 }
 final v = new C().m(1, b: 2, c: 3);
 ''');
     assertUnlinkedConst(variable.initializer.bodyExpr,
         isValidConst: false,
         operators: [
           UnlinkedExprOperation.invokeConstructor,
-          UnlinkedExprOperation.pushInt,
-          UnlinkedExprOperation.pushInt,
-          UnlinkedExprOperation.pushInt,
           UnlinkedExprOperation.invokeMethod,
         ],
         ints: [
           0,
           0,
-          1,
-          2,
-          3,
-          2,
-          1,
+          0,
+          0,
           0
         ],
         strings: [
-          'b',
-          'c',
           'm'
         ],
         referenceValidators: [
           (EntityRef r) => checkTypeRef(r, null, 'C',
               expectedKind: ReferenceKind.classOrEnum)
         ]);
   }
 
   test_expr_invokeMethod_withTypeParameters() {
     if (skipNonConstInitializers) {
@@ skipping 41 matching lines @@
 }
 class C {
   int m(int a, int b) => a + b;
 }
 A a = new A();
 final v = a.b.c.m(10, 20);
 ''');
     assertUnlinkedConst(variable.initializer.bodyExpr,
         isValidConst: false,
         operators: [
-          UnlinkedExprOperation.pushInt,
-          UnlinkedExprOperation.pushInt,
           UnlinkedExprOperation.invokeMethodRef,
         ],
         ints: [
-          10,
-          20,
           0,
-          2,
+          0,
           0
         ],
         strings: [],
         referenceValidators: [
           (EntityRef r) => checkTypeRef(r, null, 'm',
                   expectedKind: ReferenceKind.unresolved,
                   prefixExpectations: [
                     new _PrefixExpectation(ReferenceKind.unresolved, 'c'),
                     new _PrefixExpectation(ReferenceKind.unresolved, 'b'),
                     new _PrefixExpectation(
@@ skipping 44 matching lines @@
       return;
     }
     UnlinkedVariable variable = serializeVariableText('''
 f(x) => null;
 final u = null;
 final v = f(u);
 ''');
     assertUnlinkedConst(variable.initializer.bodyExpr,
         isValidConst: false,
         operators: [
-          UnlinkedExprOperation.pushReference,
           UnlinkedExprOperation.invokeMethodRef
         ],
         ints: [
           0,
-          1,
+          0,
           0
         ],
         referenceValidators: [
-          (EntityRef r) => checkTypeRef(r, null, 'u',
-              expectedKind: ReferenceKind.topLevelPropertyAccessor),
           (EntityRef r) => checkTypeRef(r, null, 'f',
               expectedKind: ReferenceKind.topLevelFunction)
         ]);
   }
 
   test_expr_invokeMethodRef_withTypeParameters() {
     if (skipNonConstInitializers) {
       return;
     }
     UnlinkedVariable variable = serializeVariableText('''
@@ skipping 12 matching lines @@
         ],
         referenceValidators: [
           (EntityRef r) => checkTypeRef(r, null, 'f',
               expectedKind: ReferenceKind.topLevelFunction,
               numTypeParameters: 2),
           (EntityRef r) => checkTypeRef(r, 'dart:core', 'int'),
           (EntityRef r) => checkTypeRef(r, 'dart:core', 'String')
         ]);
   }
 
+  test_expr_makeTypedList() {
+    UnlinkedVariable variable =
+        serializeVariableText('var v = <int>[11, 22, 33];');
+    assertUnlinkedConst(variable.initializer.bodyExpr, operators: [
+      UnlinkedExprOperation.makeTypedList
+    ], ints: [
+      0
+    ], referenceValidators: [
+      (EntityRef r) => checkTypeRef(r, 'dart:core', 'int',
+          expectedKind: ReferenceKind.classOrEnum)
+    ]);
+  }
+
+  test_expr_makeTypedMap() {
+    UnlinkedVariable variable = serializeVariableText(
+        'var v = <int, String>{11: "aaa", 22: "bbb", 33: "ccc"};');
+    assertUnlinkedConst(variable.initializer.bodyExpr, operators: [
+      UnlinkedExprOperation.makeTypedMap
+    ], ints: [
+      0
+    ], referenceValidators: [
+      (EntityRef r) => checkTypeRef(r, 'dart:core', 'int',
+          expectedKind: ReferenceKind.classOrEnum),
+      (EntityRef r) => checkTypeRef(r, 'dart:core', 'String',
+          expectedKind: ReferenceKind.classOrEnum)
+    ]);
+  }
+
+  test_expr_makeUntypedList() {
+    UnlinkedVariable variable = serializeVariableText('var v = [11, 22, 33];');
+    assertUnlinkedConst(variable.initializer.bodyExpr, operators: [
+      UnlinkedExprOperation.pushInt,
+      UnlinkedExprOperation.pushInt,
+      UnlinkedExprOperation.pushInt,
+      UnlinkedExprOperation.makeUntypedList
+    ], ints: [
+      11,
+      22,
+      33,
+      3
+    ]);
+  }
+
+  test_expr_makeUntypedMap() {
+    UnlinkedVariable variable =
+        serializeVariableText('var v = {11: "aaa", 22: "bbb", 33: "ccc"};');
+    assertUnlinkedConst(variable.initializer.bodyExpr, operators: [
+      UnlinkedExprOperation.pushInt,
+      UnlinkedExprOperation.pushString,
+      UnlinkedExprOperation.pushInt,
+      UnlinkedExprOperation.pushString,
+      UnlinkedExprOperation.pushInt,
+      UnlinkedExprOperation.pushString,
+      UnlinkedExprOperation.makeUntypedMap
+    ], ints: [
+      11,
+      22,
+      33,
+      3
+    ], strings: [
+      'aaa',
+      'bbb',
+      'ccc'
+    ]);
+  }
+
   test_expr_super() {
     if (skipNonConstInitializers) {
       return;
     }
     UnlinkedVariable variable = serializeVariableText('''
 final v = super;
 ''');
     assertUnlinkedConst(variable.initializer.bodyExpr, operators: [
       UnlinkedExprOperation.pushSuper,
     ]);
@@ skipping 2982 matching lines @@
  */
 class _PrefixExpectation {
   final ReferenceKind kind;
   final String name;
   final String absoluteUri;
   final int numTypeParameters;
 
   _PrefixExpectation(this.kind, this.name,
       {this.absoluteUri, this.numTypeParameters: 0});
 }