Rename UnlinkedConst -> UnlinkedExpr

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 161 matching lines @@
   /**
    * Add the given source file so that it may be referenced by the file under
    * test.
    */
   Source addNamedSource(String filePath, String contents);
 
   /**
    * Check that [annotations] contains a single entry which is a reference to
    * a top level variable called `a` in the current library.
    */
-  void checkAnnotationA(List<UnlinkedConst> annotations) {
+  void checkAnnotationA(List<UnlinkedExpr> annotations) {
     expect(annotations, hasLength(1));
     _assertUnlinkedConst(annotations[0], operators: [
-      UnlinkedConstOperation.pushReference
+      UnlinkedExprOperation.pushReference
     ], referenceValidators: [
       (EntityRef r) => checkTypeRef(r, null, null, 'a',
           expectedKind: ReferenceKind.topLevelPropertyAccessor)
     ]);
   }
 
   void checkConstCycle(String className,
       {String name: '', bool hasCycle: true}) {
     UnlinkedClass cls = findClass(className);
     int constCycleSlot =
@@ skipping 1344 matching lines @@
         absUri('/b.dart'), 'b.dart', 'D',
         onlyInStrongMode: false);
     if (!skipFullyLinkedData) {
       checkHasDependency('b.dart', fullyLinked: true);
     }
   }
 
   test_constExpr_binary_add() {
     UnlinkedVariable variable = serializeVariableText('const v = 1 + 2;');
     _assertUnlinkedConst(variable.initializer.bodyExpr, operators: [
-      UnlinkedConstOperation.pushInt,
-      UnlinkedConstOperation.pushInt,
-      UnlinkedConstOperation.add
+      UnlinkedExprOperation.pushInt,
+      UnlinkedExprOperation.pushInt,
+      UnlinkedExprOperation.add
     ], ints: [
       1,
       2
     ]);
   }
 
   test_constExpr_binary_and() {
     UnlinkedVariable variable =
         serializeVariableText('const v = true && false;');
     _assertUnlinkedConst(variable.initializer.bodyExpr, operators: [
-      UnlinkedConstOperation.pushTrue,
-      UnlinkedConstOperation.pushFalse,
-      UnlinkedConstOperation.and
+      UnlinkedExprOperation.pushTrue,
+      UnlinkedExprOperation.pushFalse,
+      UnlinkedExprOperation.and
     ]);
   }
 
   test_constExpr_binary_bitAnd() {
     UnlinkedVariable variable = serializeVariableText('const v = 1 & 2;');
     _assertUnlinkedConst(variable.initializer.bodyExpr, operators: [
-      UnlinkedConstOperation.pushInt,
-      UnlinkedConstOperation.pushInt,
-      UnlinkedConstOperation.bitAnd
+      UnlinkedExprOperation.pushInt,
+      UnlinkedExprOperation.pushInt,
+      UnlinkedExprOperation.bitAnd
     ], ints: [
       1,
       2
     ]);
   }
 
   test_constExpr_binary_bitOr() {
     UnlinkedVariable variable = serializeVariableText('const v = 1 | 2;');
     _assertUnlinkedConst(variable.initializer.bodyExpr, operators: [
-      UnlinkedConstOperation.pushInt,
-      UnlinkedConstOperation.pushInt,
-      UnlinkedConstOperation.bitOr
+      UnlinkedExprOperation.pushInt,
+      UnlinkedExprOperation.pushInt,
+      UnlinkedExprOperation.bitOr
     ], ints: [
       1,
       2
     ]);
   }
 
   test_constExpr_binary_bitShiftLeft() {
     UnlinkedVariable variable = serializeVariableText('const v = 1 << 2;');
     _assertUnlinkedConst(variable.initializer.bodyExpr, operators: [
-      UnlinkedConstOperation.pushInt,
-      UnlinkedConstOperation.pushInt,
-      UnlinkedConstOperation.bitShiftLeft
+      UnlinkedExprOperation.pushInt,
+      UnlinkedExprOperation.pushInt,
+      UnlinkedExprOperation.bitShiftLeft
     ], ints: [
       1,
       2
     ]);
   }
 
   test_constExpr_binary_bitShiftRight() {
     UnlinkedVariable variable = serializeVariableText('const v = 1 >> 2;');
     _assertUnlinkedConst(variable.initializer.bodyExpr, operators: [
-      UnlinkedConstOperation.pushInt,
-      UnlinkedConstOperation.pushInt,
-      UnlinkedConstOperation.bitShiftRight
+      UnlinkedExprOperation.pushInt,
+      UnlinkedExprOperation.pushInt,
+      UnlinkedExprOperation.bitShiftRight
     ], ints: [
       1,
       2
     ]);
   }
 
   test_constExpr_binary_bitXor() {
     UnlinkedVariable variable = serializeVariableText('const v = 1 ^ 2;');
     _assertUnlinkedConst(variable.initializer.bodyExpr, operators: [
-      UnlinkedConstOperation.pushInt,
-      UnlinkedConstOperation.pushInt,
-      UnlinkedConstOperation.bitXor
+      UnlinkedExprOperation.pushInt,
+      UnlinkedExprOperation.pushInt,
+      UnlinkedExprOperation.bitXor
     ], ints: [
       1,
       2
     ]);
   }
 
   test_constExpr_binary_divide() {
     UnlinkedVariable variable = serializeVariableText('const v = 1 / 2;');
     _assertUnlinkedConst(variable.initializer.bodyExpr, operators: [
-      UnlinkedConstOperation.pushInt,
-      UnlinkedConstOperation.pushInt,
-      UnlinkedConstOperation.divide
+      UnlinkedExprOperation.pushInt,
+      UnlinkedExprOperation.pushInt,
+      UnlinkedExprOperation.divide
     ], ints: [
       1,
       2
     ]);
   }
 
   test_constExpr_binary_equal() {
     UnlinkedVariable variable = serializeVariableText('const v = 1 == 2;');
     _assertUnlinkedConst(variable.initializer.bodyExpr, operators: [
-      UnlinkedConstOperation.pushInt,
-      UnlinkedConstOperation.pushInt,
-      UnlinkedConstOperation.equal
+      UnlinkedExprOperation.pushInt,
+      UnlinkedExprOperation.pushInt,
+      UnlinkedExprOperation.equal
     ], ints: [
       1,
       2
     ]);
   }
 
   test_constExpr_binary_equal_not() {
     UnlinkedVariable variable = serializeVariableText('const v = 1 != 2;');
     _assertUnlinkedConst(variable.initializer.bodyExpr, operators: [
-      UnlinkedConstOperation.pushInt,
-      UnlinkedConstOperation.pushInt,
-      UnlinkedConstOperation.notEqual
+      UnlinkedExprOperation.pushInt,
+      UnlinkedExprOperation.pushInt,
+      UnlinkedExprOperation.notEqual
     ], ints: [
       1,
       2
     ]);
   }
 
   test_constExpr_binary_floorDivide() {
     UnlinkedVariable variable = serializeVariableText('const v = 1 ~/ 2;');
     _assertUnlinkedConst(variable.initializer.bodyExpr, operators: [
-      UnlinkedConstOperation.pushInt,
-      UnlinkedConstOperation.pushInt,
-      UnlinkedConstOperation.floorDivide
+      UnlinkedExprOperation.pushInt,
+      UnlinkedExprOperation.pushInt,
+      UnlinkedExprOperation.floorDivide
     ], ints: [
       1,
       2
     ]);
   }
 
   test_constExpr_binary_greater() {
     UnlinkedVariable variable = serializeVariableText('const v = 1 > 2;');
     _assertUnlinkedConst(variable.initializer.bodyExpr, operators: [
-      UnlinkedConstOperation.pushInt,
-      UnlinkedConstOperation.pushInt,
-      UnlinkedConstOperation.greater
+      UnlinkedExprOperation.pushInt,
+      UnlinkedExprOperation.pushInt,
+      UnlinkedExprOperation.greater
     ], ints: [
       1,
       2
     ]);
   }
 
   test_constExpr_binary_greaterEqual() {
     UnlinkedVariable variable = serializeVariableText('const v = 1 >= 2;');
     _assertUnlinkedConst(variable.initializer.bodyExpr, operators: [
-      UnlinkedConstOperation.pushInt,
-      UnlinkedConstOperation.pushInt,
-      UnlinkedConstOperation.greaterEqual
+      UnlinkedExprOperation.pushInt,
+      UnlinkedExprOperation.pushInt,
+      UnlinkedExprOperation.greaterEqual
     ], ints: [
       1,
       2
     ]);
   }
 
   test_constExpr_binary_less() {
     UnlinkedVariable variable = serializeVariableText('const v = 1 < 2;');
     _assertUnlinkedConst(variable.initializer.bodyExpr, operators: [
-      UnlinkedConstOperation.pushInt,
-      UnlinkedConstOperation.pushInt,
-      UnlinkedConstOperation.less
+      UnlinkedExprOperation.pushInt,
+      UnlinkedExprOperation.pushInt,
+      UnlinkedExprOperation.less
     ], ints: [
       1,
       2
     ]);
   }
 
   test_constExpr_binary_lessEqual() {
     UnlinkedVariable variable = serializeVariableText('const v = 1 <= 2;');
     _assertUnlinkedConst(variable.initializer.bodyExpr, operators: [
-      UnlinkedConstOperation.pushInt,
-      UnlinkedConstOperation.pushInt,
-      UnlinkedConstOperation.lessEqual
+      UnlinkedExprOperation.pushInt,
+      UnlinkedExprOperation.pushInt,
+      UnlinkedExprOperation.lessEqual
     ], ints: [
       1,
       2
     ]);
   }
 
   test_constExpr_binary_modulo() {
     UnlinkedVariable variable = serializeVariableText('const v = 1 % 2;');
     _assertUnlinkedConst(variable.initializer.bodyExpr, operators: [
-      UnlinkedConstOperation.pushInt,
-      UnlinkedConstOperation.pushInt,
-      UnlinkedConstOperation.modulo
+      UnlinkedExprOperation.pushInt,
+      UnlinkedExprOperation.pushInt,
+      UnlinkedExprOperation.modulo
     ], ints: [
       1,
       2
     ]);
   }
 
   test_constExpr_binary_multiply() {
     UnlinkedVariable variable = serializeVariableText('const v = 1 * 2;');
     _assertUnlinkedConst(variable.initializer.bodyExpr, operators: [
-      UnlinkedConstOperation.pushInt,
-      UnlinkedConstOperation.pushInt,
-      UnlinkedConstOperation.multiply
+      UnlinkedExprOperation.pushInt,
+      UnlinkedExprOperation.pushInt,
+      UnlinkedExprOperation.multiply
     ], ints: [
       1,
       2
     ]);
   }
 
   test_constExpr_binary_or() {
     UnlinkedVariable variable =
         serializeVariableText('const v = false || true;');
     _assertUnlinkedConst(variable.initializer.bodyExpr, operators: [
-      UnlinkedConstOperation.pushFalse,
-      UnlinkedConstOperation.pushTrue,
-      UnlinkedConstOperation.or
+      UnlinkedExprOperation.pushFalse,
+      UnlinkedExprOperation.pushTrue,
+      UnlinkedExprOperation.or
     ]);
   }
 
   test_constExpr_binary_subtract() {
     UnlinkedVariable variable = serializeVariableText('const v = 1 - 2;');
     _assertUnlinkedConst(variable.initializer.bodyExpr, operators: [
-      UnlinkedConstOperation.pushInt,
-      UnlinkedConstOperation.pushInt,
-      UnlinkedConstOperation.subtract
+      UnlinkedExprOperation.pushInt,
+      UnlinkedExprOperation.pushInt,
+      UnlinkedExprOperation.subtract
     ], ints: [
       1,
       2
     ]);
   }
 
   test_constExpr_classMember_shadows_typeParam() {
     // Although it is an error for a class member to have the same name as a
     // type parameter, the spec makes it clear that the class member scope is
     // nested inside the type parameter scope.  So go ahead and verify that
     // the class member shadows the type parameter.
     String text = '''
 class C<T> {
   static const T = null;
   final x;
   const C() : x = T;
 }
 ''';
     UnlinkedClass cls = serializeClassText(text, allowErrors: true);
     _assertUnlinkedConst(cls.executables[0].constantInitializers[0].expression,
         operators: [
-          UnlinkedConstOperation.pushReference
+          UnlinkedExprOperation.pushReference
         ],
         referenceValidators: [
           (EntityRef r) => checkTypeRef(r, null, null, 'T',
                   expectedKind: ReferenceKind.propertyAccessor,
                   prefixExpectations: [
                     new _PrefixExpectation(ReferenceKind.classOrEnum, 'C',
                         numTypeParameters: 1)
                   ])
         ]);
   }
 
   test_constExpr_conditional() {
     UnlinkedVariable variable =
         serializeVariableText('const v = true ? 1 : 2;', allowErrors: true);
     _assertUnlinkedConst(variable.initializer.bodyExpr, operators: [
-      UnlinkedConstOperation.pushTrue,
-      UnlinkedConstOperation.pushInt,
-      UnlinkedConstOperation.pushInt,
-      UnlinkedConstOperation.conditional
+      UnlinkedExprOperation.pushTrue,
+      UnlinkedExprOperation.pushInt,
+      UnlinkedExprOperation.pushInt,
+      UnlinkedExprOperation.conditional
     ], ints: [
       1,
       2
     ]);
   }
 
   test_constExpr_constructorParam_shadows_classMember() {
     UnlinkedClass cls = serializeClassText('''
 class C {
   static const a = null;
   final b;
   const C(a) : b = a;
 }
 ''');
     _assertUnlinkedConst(cls.executables[0].constantInitializers[0].expression,
-        operators: [UnlinkedConstOperation.pushParameter], strings: ['a']);
+        operators: [UnlinkedExprOperation.pushParameter], strings: ['a']);
   }
 
   test_constExpr_constructorParam_shadows_typeParam() {
     UnlinkedClass cls = serializeClassText('''
 class C<T> {
   final x;
   const C(T) : x = T;
 }
 ''');
     _assertUnlinkedConst(cls.executables[0].constantInitializers[0].expression,
-        operators: [UnlinkedConstOperation.pushParameter], strings: ['T']);
+        operators: [UnlinkedExprOperation.pushParameter], strings: ['T']);
   }
 
   test_constExpr_functionExpression_asArgument() {
     // Even though function expressions are not allowed in constant
     // declarations, they might occur due to erroneous code, so make sure they
     // function correctly.
     UnlinkedVariable variable = serializeVariableText('''
 const v = foo(5, () => 42);
 foo(a, b) {}
 ''');
     _assertUnlinkedConst(variable.initializer.bodyExpr,
         isValidConst: false,
         operators: [
-          UnlinkedConstOperation.pushInt,
-          UnlinkedConstOperation.pushLocalFunctionReference,
-          UnlinkedConstOperation.invokeMethodRef
+          UnlinkedExprOperation.pushInt,
+          UnlinkedExprOperation.pushLocalFunctionReference,
+          UnlinkedExprOperation.invokeMethodRef
         ],
         ints: [
           5,
           0,
           0,
           0,
           2,
           0
         ],
         referenceValidators: [
           (EntityRef r) => checkTypeRef(r, null, null, 'foo',
               expectedKind: ReferenceKind.topLevelFunction)
         ]);
   }
 
   test_constExpr_functionExpression_asArgument_multiple() {
     // Even though function expressions are not allowed in constant
     // declarations, they might occur due to erroneous code, so make sure they
     // function correctly.
     UnlinkedVariable variable = serializeVariableText('''
 const v = foo(5, () => 42, () => 43);
 foo(a, b, c) {}
 ''');
     _assertUnlinkedConst(variable.initializer.bodyExpr,
         isValidConst: false,
         operators: [
-          UnlinkedConstOperation.pushInt,
-          UnlinkedConstOperation.pushLocalFunctionReference,
-          UnlinkedConstOperation.pushLocalFunctionReference,
-          UnlinkedConstOperation.invokeMethodRef
+          UnlinkedExprOperation.pushInt,
+          UnlinkedExprOperation.pushLocalFunctionReference,
+          UnlinkedExprOperation.pushLocalFunctionReference,
+          UnlinkedExprOperation.invokeMethodRef
         ],
         ints: [
           5,
           0,
           0,
           0,
           1,
           0,
           3,
           0
@@ skipping 10 matching lines @@
     // function correctly.
     UnlinkedExecutable executable = serializeClassText('''
 class C {
   final x, y;
   const C() : x = (() => 42), y = (() => 43);
 }
 ''').executables[0];
     expect(executable.localFunctions, hasLength(2));
     _assertUnlinkedConst(executable.constantInitializers[0].expression,
         isValidConst: false,
-        operators: [UnlinkedConstOperation.pushLocalFunctionReference],
+        operators: [UnlinkedExprOperation.pushLocalFunctionReference],
         ints: [0, 0]);
     _assertUnlinkedConst(executable.constantInitializers[1].expression,
         isValidConst: false,
-        operators: [UnlinkedConstOperation.pushLocalFunctionReference],
+        operators: [UnlinkedExprOperation.pushLocalFunctionReference],
         ints: [0, 1]);
   }
 
   test_constExpr_invokeConstructor_generic_named() {
     UnlinkedVariable variable = serializeVariableText('''
 class C<K, V> {
   const C.named();
 }
 const v = const C<int, String>.named();
 ''');
     _assertUnlinkedConst(variable.initializer.bodyExpr, operators: [
-      UnlinkedConstOperation.invokeConstructor,
+      UnlinkedExprOperation.invokeConstructor,
     ], ints: [
       0,
       0
     ], referenceValidators: [
       (EntityRef r) {
         checkTypeRef(r, null, null, 'named',
             expectedKind: ReferenceKind.constructor,
             prefixExpectations: [
               new _PrefixExpectation(ReferenceKind.classOrEnum, 'C',
                   numTypeParameters: 2)
@@ skipping 11 matching lines @@
         '''
 class C<K, V> {
   const C.named();
 }
 ''');
     UnlinkedVariable variable = serializeVariableText('''
 import 'a.dart';
 const v = const C<int, String>.named();
 ''');
     _assertUnlinkedConst(variable.initializer.bodyExpr, operators: [
-      UnlinkedConstOperation.invokeConstructor,
+      UnlinkedExprOperation.invokeConstructor,
     ], ints: [
       0,
       0
     ], referenceValidators: [
       (EntityRef r) {
         checkTypeRef(r, null, null, 'named',
             expectedKind: ReferenceKind.constructor,
             prefixExpectations: [
               new _PrefixExpectation(ReferenceKind.classOrEnum, 'C',
                   absoluteUri: absUri('/a.dart'),
@@ skipping 13 matching lines @@
         '''
 class C<K, V> {
   const C.named();
 }
 ''');
     UnlinkedVariable variable = serializeVariableText('''
 import 'a.dart' as p;
 const v = const p.C<int, String>.named();
 ''');
     _assertUnlinkedConst(variable.initializer.bodyExpr, operators: [
-      UnlinkedConstOperation.invokeConstructor,
+      UnlinkedExprOperation.invokeConstructor,
     ], ints: [
       0,
       0
     ], referenceValidators: [
       (EntityRef r) {
         checkTypeRef(r, null, null, 'named',
             expectedKind: ReferenceKind.constructor,
             prefixExpectations: [
               new _PrefixExpectation(ReferenceKind.classOrEnum, 'C',
                   absoluteUri: absUri('/a.dart'),
                   relativeUri: 'a.dart',
                   numTypeParameters: 2),
               new _PrefixExpectation(ReferenceKind.prefix, 'p')
             ],
             numTypeArguments: 2);
         checkTypeRef(r.typeArguments[0], 'dart:core', 'dart:core', 'int');
         checkTypeRef(r.typeArguments[1], 'dart:core', 'dart:core', 'String');
       }
     ]);
   }
 
   test_constExpr_invokeConstructor_generic_unnamed() {
     UnlinkedVariable variable = serializeVariableText('''
 class C<K, V> {
   const C();
 }
 const v = const C<int, String>();
 ''');
     _assertUnlinkedConst(variable.initializer.bodyExpr, operators: [
-      UnlinkedConstOperation.invokeConstructor,
+      UnlinkedExprOperation.invokeConstructor,
     ], ints: [
       0,
       0
     ], referenceValidators: [
       (EntityRef r) {
         checkTypeRef(r, null, null, 'C',
             expectedKind: ReferenceKind.classOrEnum,
             numTypeParameters: 2,
             numTypeArguments: 2);
         checkTypeRef(r.typeArguments[0], 'dart:core', 'dart:core', 'int');
         checkTypeRef(r.typeArguments[1], 'dart:core', 'dart:core', 'String');
       }
     ]);
   }
 
   test_constExpr_invokeConstructor_generic_unnamed_imported() {
     addNamedSource(
         '/a.dart',
         '''
 class C<K, V> {
   const C();
 }
 ''');
     UnlinkedVariable variable = serializeVariableText('''
 import 'a.dart';
 const v = const C<int, String>();
 ''');
     _assertUnlinkedConst(variable.initializer.bodyExpr, operators: [
-      UnlinkedConstOperation.invokeConstructor,
+      UnlinkedExprOperation.invokeConstructor,
     ], ints: [
       0,
       0
     ], referenceValidators: [
       (EntityRef r) {
         checkTypeRef(r, absUri('/a.dart'), 'a.dart', 'C',
             expectedKind: ReferenceKind.classOrEnum,
             numTypeParameters: 2,
             numTypeArguments: 2);
         checkTypeRef(r.typeArguments[0], 'dart:core', 'dart:core', 'int');
         checkTypeRef(r.typeArguments[1], 'dart:core', 'dart:core', 'String');
       }
     ]);
   }
 
   test_constExpr_invokeConstructor_generic_unnamed_imported_withPrefix() {
     addNamedSource(
         '/a.dart',
         '''
 class C<K, V> {
   const C();
 }
 ''');
     UnlinkedVariable variable = serializeVariableText('''
 import 'a.dart' as p;
 const v = const p.C<int, String>();
 ''');
     _assertUnlinkedConst(variable.initializer.bodyExpr, operators: [
-      UnlinkedConstOperation.invokeConstructor,
+      UnlinkedExprOperation.invokeConstructor,
     ], ints: [
       0,
       0
     ], referenceValidators: [
       (EntityRef r) {
         checkTypeRef(r, absUri('/a.dart'), 'a.dart', 'C',
             expectedKind: ReferenceKind.classOrEnum,
             numTypeParameters: 2,
             numTypeArguments: 2,
             prefixExpectations: [
               new _PrefixExpectation(ReferenceKind.prefix, 'p')
             ]);
         checkTypeRef(r.typeArguments[0], 'dart:core', 'dart:core', 'int');
         checkTypeRef(r.typeArguments[1], 'dart:core', 'dart:core', 'String');
       }
     ]);
   }
 
   test_constExpr_invokeConstructor_named() {
     UnlinkedVariable variable = serializeVariableText('''
 class C {
   const C.named();
 }
 const v = const C.named();
 ''');
     _assertUnlinkedConst(variable.initializer.bodyExpr, operators: [
-      UnlinkedConstOperation.invokeConstructor,
+      UnlinkedExprOperation.invokeConstructor,
     ], ints: [
       0,
       0
     ], referenceValidators: [
       (EntityRef r) => checkTypeRef(r, null, null, 'named',
               expectedKind: ReferenceKind.constructor,
               prefixExpectations: [
                 new _PrefixExpectation(ReferenceKind.classOrEnum, 'C')
               ])
     ]);
   }
 
   test_constExpr_invokeConstructor_named_imported() {
     addNamedSource(
         '/a.dart',
         '''
 class C {
   const C.named();
 }
 ''');
     UnlinkedVariable variable = serializeVariableText('''
 import 'a.dart';
 const v = const C.named();
 ''');
     _assertUnlinkedConst(variable.initializer.bodyExpr, operators: [
-      UnlinkedConstOperation.invokeConstructor,
+      UnlinkedExprOperation.invokeConstructor,
     ], ints: [
       0,
       0
     ], referenceValidators: [
       (EntityRef r) => checkTypeRef(r, null, null, 'named',
               expectedKind: ReferenceKind.constructor,
               prefixExpectations: [
                 new _PrefixExpectation(ReferenceKind.classOrEnum, 'C',
                     absoluteUri: absUri('/a.dart'), relativeUri: 'a.dart')
               ])
     ]);
   }
 
   test_constExpr_invokeConstructor_named_imported_withPrefix() {
     addNamedSource(
         '/a.dart',
         '''
 class C {
   const C.named();
 }
 ''');
     UnlinkedVariable variable = serializeVariableText('''
 import 'a.dart' as p;
 const v = const p.C.named();
 ''');
     _assertUnlinkedConst(variable.initializer.bodyExpr, operators: [
-      UnlinkedConstOperation.invokeConstructor,
+      UnlinkedExprOperation.invokeConstructor,
     ], ints: [
       0,
       0
     ], referenceValidators: [
       (EntityRef r) => checkTypeRef(r, null, null, 'named',
               expectedKind: ReferenceKind.constructor,
               prefixExpectations: [
                 new _PrefixExpectation(ReferenceKind.classOrEnum, 'C',
                     absoluteUri: absUri('/a.dart'), relativeUri: 'a.dart'),
                 new _PrefixExpectation(ReferenceKind.prefix, 'p')
               ])
     ]);
   }
 
   test_constExpr_invokeConstructor_unnamed() {
     UnlinkedVariable variable = serializeVariableText('''
 class C {
   const C(a, b, c, d, {e, f, g});
 }
 const v = const C(11, 22, 3.3, '444', e: 55, g: '777', f: 66);
 ''');
     // Stack: 11 22 3.3 '444' 55 '777' 66 ^head
     // Ints: ^pointer 3 4
     // Doubles: ^pointer
     // Strings: ^pointer 'e' 'g' 'f' ''
     _assertUnlinkedConst(variable.initializer.bodyExpr, operators: [
-      UnlinkedConstOperation.pushInt,
-      UnlinkedConstOperation.pushInt,
-      UnlinkedConstOperation.pushDouble,
-      UnlinkedConstOperation.pushString,
-      UnlinkedConstOperation.pushInt,
-      UnlinkedConstOperation.pushString,
-      UnlinkedConstOperation.pushInt,
-      UnlinkedConstOperation.invokeConstructor,
+      UnlinkedExprOperation.pushInt,
+      UnlinkedExprOperation.pushInt,
+      UnlinkedExprOperation.pushDouble,
+      UnlinkedExprOperation.pushString,
+      UnlinkedExprOperation.pushInt,
+      UnlinkedExprOperation.pushString,
+      UnlinkedExprOperation.pushInt,
+      UnlinkedExprOperation.invokeConstructor,
     ], ints: [
       11,
       22,
       55,
       66,
       3,
       4,
     ], doubles: [
       3.3
     ], strings: [
@@ skipping 14 matching lines @@
         '''
 class C {
   const C();
 }
 ''');
     UnlinkedVariable variable = serializeVariableText('''
 import 'a.dart';
 const v = const C();
 ''');
     _assertUnlinkedConst(variable.initializer.bodyExpr, operators: [
-      UnlinkedConstOperation.invokeConstructor,
+      UnlinkedExprOperation.invokeConstructor,
     ], ints: [
       0,
       0
     ], referenceValidators: [
       (EntityRef r) => checkTypeRef(r, absUri('/a.dart'), 'a.dart', 'C',
           expectedKind: ReferenceKind.classOrEnum)
     ]);
   }
 
   test_constExpr_invokeConstructor_unnamed_imported_withPrefix() {
     addNamedSource(
         '/a.dart',
         '''
 class C {
   const C();
 }
 ''');
     UnlinkedVariable variable = serializeVariableText('''
 import 'a.dart' as p;
 const v = const p.C();
 ''');
     _assertUnlinkedConst(variable.initializer.bodyExpr, operators: [
-      UnlinkedConstOperation.invokeConstructor,
+      UnlinkedExprOperation.invokeConstructor,
     ], ints: [
       0,
       0
     ], referenceValidators: [
       (EntityRef r) => checkTypeRef(r, absUri('/a.dart'), 'a.dart', 'C',
               expectedKind: ReferenceKind.classOrEnum,
               prefixExpectations: [
                 new _PrefixExpectation(ReferenceKind.prefix, 'p')
               ])
     ]);
   }
 
   test_constExpr_invokeConstructor_unresolved_named() {
     UnlinkedVariable variable = serializeVariableText(
         '''
 class C {}
 const v = const C.foo();
 ''',
         allowErrors: true);
     _assertUnlinkedConst(variable.initializer.bodyExpr, operators: [
-      UnlinkedConstOperation.invokeConstructor,
+      UnlinkedExprOperation.invokeConstructor,
     ], ints: [
       0,
       0
     ], referenceValidators: [
       (EntityRef r) => checkTypeRef(r, null, null, 'foo',
               expectedKind: ReferenceKind.unresolved,
               prefixExpectations: [
                 new _PrefixExpectation(ReferenceKind.classOrEnum, 'C')
               ])
     ]);
   }
 
   test_constExpr_invokeConstructor_unresolved_named2() {
     UnlinkedVariable variable = serializeVariableText(
         '''
 const v = const C.foo();
 ''',
         allowErrors: true);
     _assertUnlinkedConst(variable.initializer.bodyExpr, operators: [
-      UnlinkedConstOperation.invokeConstructor,
+      UnlinkedExprOperation.invokeConstructor,
     ], ints: [
       0,
       0
     ], referenceValidators: [
       (EntityRef r) => checkTypeRef(r, null, null, 'foo',
               expectedKind: ReferenceKind.unresolved,
               prefixExpectations: [
                 new _PrefixExpectation(ReferenceKind.unresolved, 'C')
               ])
     ]);
   }
 
   test_constExpr_invokeConstructor_unresolved_named_prefixed() {
     addNamedSource(
         '/a.dart',
         '''
 class C {
 }
 ''');
     UnlinkedVariable variable = serializeVariableText(
         '''
 import 'a.dart' as p;
 const v = const p.C.foo();
 ''',
         allowErrors: true);
     _assertUnlinkedConst(variable.initializer.bodyExpr, operators: [
-      UnlinkedConstOperation.invokeConstructor,
+      UnlinkedExprOperation.invokeConstructor,
     ], ints: [
       0,
       0
     ], referenceValidators: [
       (EntityRef r) => checkTypeRef(r, null, null, 'foo',
               expectedKind: ReferenceKind.unresolved,
               prefixExpectations: [
                 new _PrefixExpectation(ReferenceKind.classOrEnum, 'C',
                     absoluteUri: absUri('/a.dart'), relativeUri: 'a.dart'),
                 new _PrefixExpectation(ReferenceKind.prefix, 'p')
               ])
     ]);
   }
 
   test_constExpr_invokeConstructor_unresolved_named_prefixed2() {
     addNamedSource('/a.dart', '');
     UnlinkedVariable variable = serializeVariableText(
         '''
 import 'a.dart' as p;
 const v = const p.C.foo();
 ''',
         allowErrors: true);
     _assertUnlinkedConst(variable.initializer.bodyExpr, operators: [
-      UnlinkedConstOperation.invokeConstructor,
+      UnlinkedExprOperation.invokeConstructor,
     ], ints: [
       0,
       0
     ], referenceValidators: [
       (EntityRef r) => checkTypeRef(r, null, null, 'foo',
               expectedKind: ReferenceKind.unresolved,
               prefixExpectations: [
                 new _PrefixExpectation(ReferenceKind.unresolved, 'C'),
                 new _PrefixExpectation(ReferenceKind.prefix, 'p')
               ])
     ]);
   }
 
   test_constExpr_invokeConstructor_unresolved_unnamed() {
     UnlinkedVariable variable = serializeVariableText(
         '''
 const v = const Foo();
 ''',
         allowErrors: true);
     _assertUnlinkedConst(variable.initializer.bodyExpr, operators: [
-      UnlinkedConstOperation.invokeConstructor,
+      UnlinkedExprOperation.invokeConstructor,
     ], ints: [
       0,
       0
     ], referenceValidators: [
       (EntityRef r) => checkTypeRef(r, null, null, 'Foo',
           expectedKind: ReferenceKind.unresolved)
     ]);
   }
 
   test_constExpr_invokeMethodRef_identical() {
     UnlinkedVariable variable =
         serializeVariableText('const v = identical(42, null);');
     _assertUnlinkedConst(variable.initializer.bodyExpr, operators: [
-      UnlinkedConstOperation.pushInt,
-      UnlinkedConstOperation.pushNull,
-      UnlinkedConstOperation.invokeMethodRef
+      UnlinkedExprOperation.pushInt,
+      UnlinkedExprOperation.pushNull,
+      UnlinkedExprOperation.invokeMethodRef
     ], ints: [
       42,
       0,
       2,
       0
     ], referenceValidators: [
       (EntityRef r) {
         checkTypeRef(r, 'dart:core', 'dart:core', 'identical',
             expectedKind: ReferenceKind.topLevelFunction);
       }
     ]);
   }
 
   test_constExpr_length_classConstField() {
     UnlinkedVariable variable = serializeVariableText('''
 class C {
   static const int length = 0;
 }
 const int v = C.length;
 ''');
     _assertUnlinkedConst(variable.initializer.bodyExpr, operators: [
-      UnlinkedConstOperation.pushReference
+      UnlinkedExprOperation.pushReference
     ], referenceValidators: [
       (EntityRef r) => checkTypeRef(r, null, null, 'length',
               expectedKind: ReferenceKind.propertyAccessor,
               prefixExpectations: [
                 new _PrefixExpectation(ReferenceKind.classOrEnum, 'C')
               ])
     ]);
   }
 
   test_constExpr_length_classConstField_imported_withPrefix() {
     addNamedSource(
         '/a.dart',
         '''
 class C {
   static const int length = 0;
 }
 ''');
     UnlinkedVariable variable = serializeVariableText('''
 import 'a.dart' as p;
 const int v = p.C.length;
 ''');
     _assertUnlinkedConst(variable.initializer.bodyExpr, operators: [
-      UnlinkedConstOperation.pushReference
+      UnlinkedExprOperation.pushReference
     ], referenceValidators: [
       (EntityRef r) => checkTypeRef(r, null, null, 'length',
               expectedKind: ReferenceKind.propertyAccessor,
               prefixExpectations: [
                 new _PrefixExpectation(ReferenceKind.classOrEnum, 'C',
                     absoluteUri: absUri('/a.dart'), relativeUri: 'a.dart'),
                 new _PrefixExpectation(ReferenceKind.prefix, 'p')
               ])
     ]);
   }
 
   test_constExpr_length_identifierTarget() {
     UnlinkedVariable variable = serializeVariableText('''
 const String a = 'aaa';
 const int v = a.length;
 ''');
     _assertUnlinkedConst(variable.initializer.bodyExpr, operators: [
-      UnlinkedConstOperation.pushReference
+      UnlinkedExprOperation.pushReference
     ], referenceValidators: [
       (EntityRef r) => checkTypeRef(r, null, null, 'length',
               expectedKind: ReferenceKind.unresolved,
               unresolvedHasName: true,
               prefixExpectations: [
                 new _PrefixExpectation(
                     ReferenceKind.topLevelPropertyAccessor, 'a')
               ])
     ]);
   }
 
   test_constExpr_length_identifierTarget_classConstField() {
     UnlinkedVariable variable = serializeVariableText('''
 class C {
   static const String F = '';
 }
 const int v = C.F.length;
 ''');
     _assertUnlinkedConst(variable.initializer.bodyExpr, operators: [
-      UnlinkedConstOperation.pushReference
+      UnlinkedExprOperation.pushReference
     ], referenceValidators: [
       (EntityRef r) => checkTypeRef(r, null, null, 'length',
               expectedKind: ReferenceKind.unresolved,
               unresolvedHasName: true,
               prefixExpectations: [
                 new _PrefixExpectation(ReferenceKind.propertyAccessor, 'F'),
                 new _PrefixExpectation(ReferenceKind.classOrEnum, 'C'),
               ])
     ]);
   }
 
   test_constExpr_length_identifierTarget_imported() {
     addNamedSource(
         '/a.dart',
         '''
 const String a = 'aaa';
 ''');
     UnlinkedVariable variable = serializeVariableText('''
 import 'a.dart';
 const int v = a.length;
 ''');
     _assertUnlinkedConst(variable.initializer.bodyExpr, operators: [
-      UnlinkedConstOperation.pushReference
+      UnlinkedExprOperation.pushReference
     ], referenceValidators: [
       (EntityRef r) => checkTypeRef(r, null, null, 'length',
               expectedKind: ReferenceKind.unresolved,
               unresolvedHasName: true,
               prefixExpectations: [
                 new _PrefixExpectation(
                     ReferenceKind.topLevelPropertyAccessor, 'a',
                     absoluteUri: absUri('/a.dart'), relativeUri: 'a.dart')
               ])
     ]);
   }
 
   test_constExpr_length_identifierTarget_imported_withPrefix() {
     addNamedSource(
         '/a.dart',
         '''
 const String a = 'aaa';
 ''');
     UnlinkedVariable variable = serializeVariableText('''
 import 'a.dart' as p;
 const int v = p.a.length;
 ''');
     _assertUnlinkedConst(variable.initializer.bodyExpr, operators: [
-      UnlinkedConstOperation.pushReference
+      UnlinkedExprOperation.pushReference
     ], referenceValidators: [
       (EntityRef r) => checkTypeRef(r, null, null, 'length',
               expectedKind: ReferenceKind.unresolved,
               unresolvedHasName: true,
               prefixExpectations: [
                 new _PrefixExpectation(
                     ReferenceKind.topLevelPropertyAccessor, 'a',
                     absoluteUri: absUri('/a.dart'), relativeUri: 'a.dart'),
                 new _PrefixExpectation(ReferenceKind.prefix, 'p')
               ])
     ]);
   }
 
   test_constExpr_length_parenthesizedBinaryTarget() {
     UnlinkedVariable variable =
         serializeVariableText('const v = ("abc" + "edf").length;');
     _assertUnlinkedConst(variable.initializer.bodyExpr, operators: [
-      UnlinkedConstOperation.pushString,
-      UnlinkedConstOperation.pushString,
-      UnlinkedConstOperation.add,
-      UnlinkedConstOperation.extractProperty
+      UnlinkedExprOperation.pushString,
+      UnlinkedExprOperation.pushString,
+      UnlinkedExprOperation.add,
+      UnlinkedExprOperation.extractProperty
     ], strings: [
       'abc',
       'edf',
       'length'
     ]);
   }
 
   test_constExpr_length_parenthesizedStringTarget() {
     UnlinkedVariable variable =
         serializeVariableText('const v = ("abc").length;');
     _assertUnlinkedConst(variable.initializer.bodyExpr, operators: [
-      UnlinkedConstOperation.pushString,
-      UnlinkedConstOperation.extractProperty
+      UnlinkedExprOperation.pushString,
+      UnlinkedExprOperation.extractProperty
     ], strings: [
       'abc',
       'length'
     ]);
   }
 
   test_constExpr_length_stringLiteralTarget() {
     UnlinkedVariable variable =
         serializeVariableText('const v = "abc".length;');
     _assertUnlinkedConst(variable.initializer.bodyExpr, operators: [
-      UnlinkedConstOperation.pushString,
-      UnlinkedConstOperation.extractProperty
+      UnlinkedExprOperation.pushString,
+      UnlinkedExprOperation.extractProperty
     ], strings: [
       'abc',
       'length'
     ]);
   }
 
   test_constExpr_makeSymbol() {
     UnlinkedVariable variable = serializeVariableText('const v = #a.bb.ccc;');
     _assertUnlinkedConst(variable.initializer.bodyExpr,
-        operators: [UnlinkedConstOperation.makeSymbol], strings: ['a.bb.ccc']);
+        operators: [UnlinkedExprOperation.makeSymbol], strings: ['a.bb.ccc']);
   }
 
   test_constExpr_makeTypedList() {
     UnlinkedVariable variable =
         serializeVariableText('const v = const <int>[11, 22, 33];');
     _assertUnlinkedConst(variable.initializer.bodyExpr, operators: [
-      UnlinkedConstOperation.pushInt,
-      UnlinkedConstOperation.pushInt,
-      UnlinkedConstOperation.pushInt,
-      UnlinkedConstOperation.makeTypedList
+      UnlinkedExprOperation.pushInt,
+      UnlinkedExprOperation.pushInt,
+      UnlinkedExprOperation.pushInt,
+      UnlinkedExprOperation.makeTypedList
     ], ints: [
       11,
       22,
       33,
       3
     ], referenceValidators: [
       (EntityRef r) => checkTypeRef(r, 'dart:core', 'dart:core', 'int',
           expectedKind: ReferenceKind.classOrEnum)
     ]);
   }
 
   test_constExpr_makeTypedList_dynamic() {
     UnlinkedVariable variable =
         serializeVariableText('const v = const <dynamic>[11, 22, 33];');
     _assertUnlinkedConst(variable.initializer.bodyExpr, operators: [
-      UnlinkedConstOperation.pushInt,
-      UnlinkedConstOperation.pushInt,
-      UnlinkedConstOperation.pushInt,
-      UnlinkedConstOperation.makeTypedList
+      UnlinkedExprOperation.pushInt,
+      UnlinkedExprOperation.pushInt,
+      UnlinkedExprOperation.pushInt,
+      UnlinkedExprOperation.makeTypedList
     ], ints: [
       11,
       22,
       33,
       3
     ], referenceValidators: [
       (EntityRef r) => checkDynamicTypeRef(r)
     ]);
   }
 
   test_constExpr_makeTypedMap() {
     UnlinkedVariable variable = serializeVariableText(
         'const v = const <int, String>{11: "aaa", 22: "bbb", 33: "ccc"};');
     _assertUnlinkedConst(variable.initializer.bodyExpr, operators: [
-      UnlinkedConstOperation.pushInt,
-      UnlinkedConstOperation.pushString,
-      UnlinkedConstOperation.pushInt,
-      UnlinkedConstOperation.pushString,
-      UnlinkedConstOperation.pushInt,
-      UnlinkedConstOperation.pushString,
-      UnlinkedConstOperation.makeTypedMap
+      UnlinkedExprOperation.pushInt,
+      UnlinkedExprOperation.pushString,
+      UnlinkedExprOperation.pushInt,
+      UnlinkedExprOperation.pushString,
+      UnlinkedExprOperation.pushInt,
+      UnlinkedExprOperation.pushString,
+      UnlinkedExprOperation.makeTypedMap
     ], ints: [
       11,
       22,
       33,
       3
     ], strings: [
       'aaa',
       'bbb',
       'ccc'
     ], referenceValidators: [
       (EntityRef r) => checkTypeRef(r, 'dart:core', 'dart:core', 'int',
           expectedKind: ReferenceKind.classOrEnum),
       (EntityRef r) => checkTypeRef(r, 'dart:core', 'dart:core', 'String',
           expectedKind: ReferenceKind.classOrEnum)
     ]);
   }
 
   test_constExpr_makeTypedMap_dynamic() {
     UnlinkedVariable variable = serializeVariableText(
         'const v = const <dynamic, dynamic>{11: "aaa", 22: "bbb", 33: "ccc"};');
     _assertUnlinkedConst(variable.initializer.bodyExpr, operators: [
-      UnlinkedConstOperation.pushInt,
-      UnlinkedConstOperation.pushString,
-      UnlinkedConstOperation.pushInt,
-      UnlinkedConstOperation.pushString,
-      UnlinkedConstOperation.pushInt,
-      UnlinkedConstOperation.pushString,
-      UnlinkedConstOperation.makeTypedMap
+      UnlinkedExprOperation.pushInt,
+      UnlinkedExprOperation.pushString,
+      UnlinkedExprOperation.pushInt,
+      UnlinkedExprOperation.pushString,
+      UnlinkedExprOperation.pushInt,
+      UnlinkedExprOperation.pushString,
+      UnlinkedExprOperation.makeTypedMap
     ], ints: [
       11,
       22,
       33,
       3
     ], strings: [
       'aaa',
       'bbb',
       'ccc'
     ], referenceValidators: [
       (EntityRef r) => checkDynamicTypeRef(r),
       (EntityRef r) => checkDynamicTypeRef(r)
     ]);
   }
 
   test_constExpr_makeUntypedList() {
     UnlinkedVariable variable =
         serializeVariableText('const v = const [11, 22, 33];');
     _assertUnlinkedConst(variable.initializer.bodyExpr, operators: [
-      UnlinkedConstOperation.pushInt,
-      UnlinkedConstOperation.pushInt,
-      UnlinkedConstOperation.pushInt,
-      UnlinkedConstOperation.makeUntypedList
+      UnlinkedExprOperation.pushInt,
+      UnlinkedExprOperation.pushInt,
+      UnlinkedExprOperation.pushInt,
+      UnlinkedExprOperation.makeUntypedList
     ], ints: [
       11,
       22,
       33,
       3
     ]);
   }
 
   test_constExpr_makeUntypedMap() {
     UnlinkedVariable variable = serializeVariableText(
         'const v = const {11: "aaa", 22: "bbb", 33: "ccc"};');
     _assertUnlinkedConst(variable.initializer.bodyExpr, operators: [
-      UnlinkedConstOperation.pushInt,
-      UnlinkedConstOperation.pushString,
-      UnlinkedConstOperation.pushInt,
-      UnlinkedConstOperation.pushString,
-      UnlinkedConstOperation.pushInt,
-      UnlinkedConstOperation.pushString,
-      UnlinkedConstOperation.makeUntypedMap
+      UnlinkedExprOperation.pushInt,
+      UnlinkedExprOperation.pushString,
+      UnlinkedExprOperation.pushInt,
+      UnlinkedExprOperation.pushString,
+      UnlinkedExprOperation.pushInt,
+      UnlinkedExprOperation.pushString,
+      UnlinkedExprOperation.makeUntypedMap
     ], ints: [
       11,
       22,
       33,
       3
     ], strings: [
       'aaa',
       'bbb',
       'ccc'
     ]);
   }
 
   test_constExpr_parenthesized() {
     UnlinkedVariable variable = serializeVariableText('const v = (1 + 2) * 3;');
     _assertUnlinkedConst(variable.initializer.bodyExpr, operators: [
-      UnlinkedConstOperation.pushInt,
-      UnlinkedConstOperation.pushInt,
-      UnlinkedConstOperation.add,
-      UnlinkedConstOperation.pushInt,
-      UnlinkedConstOperation.multiply,
+      UnlinkedExprOperation.pushInt,
+      UnlinkedExprOperation.pushInt,
+      UnlinkedExprOperation.add,
+      UnlinkedExprOperation.pushInt,
+      UnlinkedExprOperation.multiply,
     ], ints: [
       1,
       2,
       3
     ]);
   }
 
   test_constExpr_prefix_complement() {
     UnlinkedVariable variable = serializeVariableText('const v = ~2;');
     _assertUnlinkedConst(variable.initializer.bodyExpr, operators: [
-      UnlinkedConstOperation.pushInt,
-      UnlinkedConstOperation.complement
+      UnlinkedExprOperation.pushInt,
+      UnlinkedExprOperation.complement
     ], ints: [
       2
     ]);
   }
 
   test_constExpr_prefix_negate() {
     UnlinkedVariable variable = serializeVariableText('const v = -(2);');
     _assertUnlinkedConst(variable.initializer.bodyExpr, operators: [
-      UnlinkedConstOperation.pushInt,
-      UnlinkedConstOperation.negate
+      UnlinkedExprOperation.pushInt,
+      UnlinkedExprOperation.negate
     ], ints: [
       2
     ]);
   }
 
   test_constExpr_prefix_not() {
     UnlinkedVariable variable = serializeVariableText('const v = !true;');
-    _assertUnlinkedConst(variable.initializer.bodyExpr, operators: [
-      UnlinkedConstOperation.pushTrue,
-      UnlinkedConstOperation.not
-    ]);
+    _assertUnlinkedConst(variable.initializer.bodyExpr,
+        operators: [UnlinkedExprOperation.pushTrue, UnlinkedExprOperation.not]);
   }
 
   test_constExpr_pushDouble() {
     UnlinkedVariable variable = serializeVariableText('const v = 123.4567;');
     _assertUnlinkedConst(variable.initializer.bodyExpr,
-        operators: [UnlinkedConstOperation.pushDouble], doubles: [123.4567]);
+        operators: [UnlinkedExprOperation.pushDouble], doubles: [123.4567]);
   }
 
   test_constExpr_pushFalse() {
     UnlinkedVariable variable = serializeVariableText('const v = false;');
     _assertUnlinkedConst(variable.initializer.bodyExpr,
-        operators: [UnlinkedConstOperation.pushFalse]);
+        operators: [UnlinkedExprOperation.pushFalse]);
   }
 
   test_constExpr_pushInt() {
     UnlinkedVariable variable = serializeVariableText('const v = 1;');
     _assertUnlinkedConst(variable.initializer.bodyExpr,
-        operators: [UnlinkedConstOperation.pushInt], ints: [1]);
+        operators: [UnlinkedExprOperation.pushInt], ints: [1]);
   }
 
   test_constExpr_pushInt_max() {
     UnlinkedVariable variable = serializeVariableText('const v = 0xFFFFFFFF;');
     _assertUnlinkedConst(variable.initializer.bodyExpr, operators: [
-      UnlinkedConstOperation.pushInt,
+      UnlinkedExprOperation.pushInt,
     ], ints: [
       0xFFFFFFFF
     ]);
   }
 
   test_constExpr_pushInt_negative() {
     UnlinkedVariable variable = serializeVariableText('const v = -5;');
     _assertUnlinkedConst(variable.initializer.bodyExpr, operators: [
-      UnlinkedConstOperation.pushInt,
-      UnlinkedConstOperation.negate
+      UnlinkedExprOperation.pushInt,
+      UnlinkedExprOperation.negate
     ], ints: [
       5
     ]);
   }
 
   test_constExpr_pushLongInt() {
     UnlinkedVariable variable =
         serializeVariableText('const v = 0xA123456789ABCDEF012345678;');
     _assertUnlinkedConst(variable.initializer.bodyExpr,
-        operators: [UnlinkedConstOperation.pushLongInt],
+        operators: [UnlinkedExprOperation.pushLongInt],
         ints: [4, 0xA, 0x12345678, 0x9ABCDEF0, 0x12345678]);
   }
 
   test_constExpr_pushLongInt_min2() {
     UnlinkedVariable variable = serializeVariableText('const v = 0x100000000;');
     _assertUnlinkedConst(variable.initializer.bodyExpr, operators: [
-      UnlinkedConstOperation.pushLongInt
+      UnlinkedExprOperation.pushLongInt
     ], ints: [
       2,
       1,
       0,
     ]);
   }
 
   test_constExpr_pushLongInt_min3() {
     UnlinkedVariable variable =
         serializeVariableText('const v = 0x10000000000000000;');
     _assertUnlinkedConst(variable.initializer.bodyExpr, operators: [
-      UnlinkedConstOperation.pushLongInt
+      UnlinkedExprOperation.pushLongInt
     ], ints: [
       3,
       1,
       0,
       0,
     ]);
   }
 
   test_constExpr_pushNull() {
     UnlinkedVariable variable = serializeVariableText('const v = null;');
     _assertUnlinkedConst(variable.initializer.bodyExpr,
-        operators: [UnlinkedConstOperation.pushNull]);
+        operators: [UnlinkedExprOperation.pushNull]);
   }
 
   test_constExpr_pushReference_class() {
     UnlinkedVariable variable = serializeVariableText('''
 class C {}
 const v = C;
 ''');
     _assertUnlinkedConst(variable.initializer.bodyExpr, operators: [
-      UnlinkedConstOperation.pushReference
+      UnlinkedExprOperation.pushReference
     ], referenceValidators: [
       (EntityRef r) => checkTypeRef(r, null, null, 'C',
           expectedKind: ReferenceKind.classOrEnum)
     ]);
   }
 
   test_constExpr_pushReference_enum() {
     UnlinkedVariable variable = serializeVariableText('''
 enum C {V1, V2, V3}
 const v = C;
 ''');
     _assertUnlinkedConst(variable.initializer.bodyExpr, operators: [
-      UnlinkedConstOperation.pushReference
+      UnlinkedExprOperation.pushReference
     ], referenceValidators: [
       (EntityRef r) => checkTypeRef(r, null, null, 'C',
           expectedKind: ReferenceKind.classOrEnum)
     ]);
   }
 
   test_constExpr_pushReference_enumValue() {
     UnlinkedVariable variable = serializeVariableText('''
 enum C {V1, V2, V3}
 const v = C.V1;
 ''');
     _assertUnlinkedConst(variable.initializer.bodyExpr, operators: [
-      UnlinkedConstOperation.pushReference
+      UnlinkedExprOperation.pushReference
     ], referenceValidators: [
       (EntityRef r) => checkTypeRef(r, null, null, 'V1',
               expectedKind: ReferenceKind.propertyAccessor,
               prefixExpectations: [
                 new _PrefixExpectation(ReferenceKind.classOrEnum, 'C')
               ])
     ]);
   }
 
   test_constExpr_pushReference_enumValue_viaImport() {
     addNamedSource(
         '/a.dart',
         '''
 enum C {V1, V2, V3}
 ''');
     UnlinkedVariable variable = serializeVariableText('''
 import 'a.dart';
 const v = C.V1;
 ''');
     _assertUnlinkedConst(variable.initializer.bodyExpr, operators: [
-      UnlinkedConstOperation.pushReference
+      UnlinkedExprOperation.pushReference
     ], referenceValidators: [
       (EntityRef r) => checkTypeRef(r, null, null, 'V1',
               expectedKind: ReferenceKind.propertyAccessor,
               prefixExpectations: [
                 new _PrefixExpectation(ReferenceKind.classOrEnum, 'C',
                     absoluteUri: absUri('/a.dart'), relativeUri: 'a.dart')
               ])
     ]);
   }
 
   test_constExpr_pushReference_enumValues() {
     UnlinkedVariable variable = serializeVariableText('''
 enum C {V1, V2, V3}
 const v = C.values;
 ''');
     _assertUnlinkedConst(variable.initializer.bodyExpr, operators: [
-      UnlinkedConstOperation.pushReference
+      UnlinkedExprOperation.pushReference
     ], referenceValidators: [
       (EntityRef r) => checkTypeRef(r, null, null, 'values',
               expectedKind: ReferenceKind.propertyAccessor,
               prefixExpectations: [
                 new _PrefixExpectation(ReferenceKind.classOrEnum, 'C')
               ])
     ]);
   }
 
   test_constExpr_pushReference_enumValues_viaImport() {
     addNamedSource(
         '/a.dart',
         '''
 enum C {V1, V2, V3}
 ''');
     UnlinkedVariable variable = serializeVariableText('''
 import 'a.dart';
 const v = C.values;
 ''');
     _assertUnlinkedConst(variable.initializer.bodyExpr, operators: [
-      UnlinkedConstOperation.pushReference
+      UnlinkedExprOperation.pushReference
     ], referenceValidators: [
       (EntityRef r) => checkTypeRef(r, null, null, 'values',
               expectedKind: ReferenceKind.propertyAccessor,
               prefixExpectations: [
                 new _PrefixExpectation(ReferenceKind.classOrEnum, 'C',
                     absoluteUri: absUri('/a.dart'), relativeUri: 'a.dart')
               ])
     ]);
   }
 
   test_constExpr_pushReference_field() {
     UnlinkedVariable variable = serializeVariableText('''
 class C {
   static const int F = 1;
 }
 const v = C.F;
 ''');
     _assertUnlinkedConst(variable.initializer.bodyExpr, operators: [
-      UnlinkedConstOperation.pushReference
+      UnlinkedExprOperation.pushReference
     ], referenceValidators: [
       (EntityRef r) => checkTypeRef(r, null, null, 'F',
               expectedKind: ReferenceKind.propertyAccessor,
               prefixExpectations: [
                 new _PrefixExpectation(ReferenceKind.classOrEnum, 'C')
               ])
     ]);
   }
 
   test_constExpr_pushReference_field_imported() {
     addNamedSource(
         '/a.dart',
         '''
 class C {
   static const int F = 1;
 }
 ''');
     UnlinkedVariable variable = serializeVariableText('''
 import 'a.dart';
 const v = C.F;
 ''');
     _assertUnlinkedConst(variable.initializer.bodyExpr, operators: [
-      UnlinkedConstOperation.pushReference
+      UnlinkedExprOperation.pushReference
     ], referenceValidators: [
       (EntityRef r) => checkTypeRef(r, null, null, 'F',
               expectedKind: ReferenceKind.propertyAccessor,
               prefixExpectations: [
                 new _PrefixExpectation(ReferenceKind.classOrEnum, 'C',
                     absoluteUri: absUri('/a.dart'), relativeUri: 'a.dart')
               ])
     ]);
   }
 
   test_constExpr_pushReference_field_imported_withPrefix() {
     addNamedSource(
         '/a.dart',
         '''
 class C {
   static const int F = 1;
 }
 ''');
     UnlinkedVariable variable = serializeVariableText('''
 import 'a.dart' as p;
 const v = p.C.F;
 ''');
     _assertUnlinkedConst(variable.initializer.bodyExpr, operators: [
-      UnlinkedConstOperation.pushReference
+      UnlinkedExprOperation.pushReference
     ], referenceValidators: [
       (EntityRef r) => checkTypeRef(r, null, null, 'F',
               expectedKind: ReferenceKind.propertyAccessor,
               prefixExpectations: [
                 new _PrefixExpectation(ReferenceKind.classOrEnum, 'C',
                     absoluteUri: absUri('/a.dart'), relativeUri: 'a.dart'),
                 new _PrefixExpectation(ReferenceKind.prefix, 'p'),
               ])
     ]);
   }
 
   test_constExpr_pushReference_field_simpleIdentifier() {
     UnlinkedVariable variable = serializeClassText('''
 class C {
   static const a = b;
   static const b = null;
 }
 ''').fields[0];
     _assertUnlinkedConst(variable.initializer.bodyExpr, operators: [
-      UnlinkedConstOperation.pushReference
+      UnlinkedExprOperation.pushReference
     ], referenceValidators: [
       (EntityRef r) => checkTypeRef(r, null, null, 'b',
               expectedKind: ReferenceKind.propertyAccessor,
               prefixExpectations: [
                 new _PrefixExpectation(ReferenceKind.classOrEnum, 'C')
               ])
     ]);
   }
 
   test_constExpr_pushReference_staticGetter() {
     UnlinkedVariable variable = serializeVariableText('''
 class C {
   static int get x => null;
 }
 const v = C.x;
 ''');
     _assertUnlinkedConst(variable.initializer.bodyExpr, operators: [
-      UnlinkedConstOperation.pushReference
+      UnlinkedExprOperation.pushReference
     ], referenceValidators: [
       (EntityRef r) => checkTypeRef(r, null, null, 'x',
               expectedKind: ReferenceKind.propertyAccessor,
               prefixExpectations: [
                 new _PrefixExpectation(ReferenceKind.classOrEnum, 'C')
               ])
     ]);
   }
 
   test_constExpr_pushReference_staticGetter_imported() {
     addNamedSource(
         '/a.dart',
         '''
 class C {
   static int get x => null;
 }
 ''');
     UnlinkedVariable variable = serializeVariableText('''
 import 'a.dart';
 const v = C.x;
 ''');
     _assertUnlinkedConst(variable.initializer.bodyExpr, operators: [
-      UnlinkedConstOperation.pushReference
+      UnlinkedExprOperation.pushReference
     ], referenceValidators: [
       (EntityRef r) => checkTypeRef(r, null, null, 'x',
               expectedKind: ReferenceKind.propertyAccessor,
               prefixExpectations: [
                 new _PrefixExpectation(ReferenceKind.classOrEnum, 'C',
                     absoluteUri: absUri('/a.dart'), relativeUri: 'a.dart')
               ])
     ]);
   }
 
   test_constExpr_pushReference_staticGetter_imported_withPrefix() {
     addNamedSource(
         '/a.dart',
         '''
 class C {
   static int get x => null;
 }
 ''');
     UnlinkedVariable variable = serializeVariableText('''
 import 'a.dart' as p;
 const v = p.C.x;
 ''');
     _assertUnlinkedConst(variable.initializer.bodyExpr, operators: [
-      UnlinkedConstOperation.pushReference
+      UnlinkedExprOperation.pushReference
     ], referenceValidators: [
       (EntityRef r) => checkTypeRef(r, null, null, 'x',
               expectedKind: ReferenceKind.propertyAccessor,
               prefixExpectations: [
                 new _PrefixExpectation(ReferenceKind.classOrEnum, 'C',
                     absoluteUri: absUri('/a.dart'), relativeUri: 'a.dart'),
                 new _PrefixExpectation(ReferenceKind.prefix, 'p')
               ])
     ]);
   }
 
   test_constExpr_pushReference_staticMethod() {
     UnlinkedVariable variable = serializeVariableText('''
 class C {
   static m() {}
 }
 const v = C.m;
 ''');
     _assertUnlinkedConst(variable.initializer.bodyExpr, operators: [
-      UnlinkedConstOperation.pushReference
+      UnlinkedExprOperation.pushReference
     ], referenceValidators: [
       (EntityRef r) => checkTypeRef(r, null, null, 'm',
               expectedKind: ReferenceKind.method,
               prefixExpectations: [
                 new _PrefixExpectation(ReferenceKind.classOrEnum, 'C')
               ])
     ]);
   }
 
   test_constExpr_pushReference_staticMethod_imported() {
     addNamedSource(
         '/a.dart',
         '''
 class C {
   static m() {}
 }
 ''');
     UnlinkedVariable variable = serializeVariableText('''
 import 'a.dart';
 const v = C.m;
 ''');
     _assertUnlinkedConst(variable.initializer.bodyExpr, operators: [
-      UnlinkedConstOperation.pushReference
+      UnlinkedExprOperation.pushReference
     ], referenceValidators: [
       (EntityRef r) => checkTypeRef(r, null, null, 'm',
               expectedKind: ReferenceKind.method,
               prefixExpectations: [
                 new _PrefixExpectation(ReferenceKind.classOrEnum, 'C',
                     absoluteUri: absUri('/a.dart'), relativeUri: 'a.dart')
               ])
     ]);
   }
 
   test_constExpr_pushReference_staticMethod_imported_withPrefix() {
     addNamedSource(
         '/a.dart',
         '''
 class C {
   static m() {}
 }
 ''');
     UnlinkedVariable variable = serializeVariableText('''
 import 'a.dart' as p;
 const v = p.C.m;
 ''');
     _assertUnlinkedConst(variable.initializer.bodyExpr, operators: [
-      UnlinkedConstOperation.pushReference
+      UnlinkedExprOperation.pushReference
     ], referenceValidators: [
       (EntityRef r) => checkTypeRef(r, null, null, 'm',
               expectedKind: ReferenceKind.method,
               prefixExpectations: [
                 new _PrefixExpectation(ReferenceKind.classOrEnum, 'C',
                     absoluteUri: absUri('/a.dart'), relativeUri: 'a.dart'),
                 new _PrefixExpectation(ReferenceKind.prefix, 'p')
               ])
     ]);
   }
 
   test_constExpr_pushReference_staticMethod_simpleIdentifier() {
     UnlinkedVariable variable = serializeClassText('''
 class C {
   static const a = m;
   static m() {}
 }
 ''').fields[0];
     _assertUnlinkedConst(variable.initializer.bodyExpr, operators: [
-      UnlinkedConstOperation.pushReference
+      UnlinkedExprOperation.pushReference
     ], referenceValidators: [
       (EntityRef r) => checkTypeRef(r, null, null, 'm',
               expectedKind: ReferenceKind.method,
               prefixExpectations: [
                 new _PrefixExpectation(ReferenceKind.classOrEnum, 'C')
               ])
     ]);
   }
 
   test_constExpr_pushReference_topLevelFunction() {
     UnlinkedVariable variable = serializeVariableText('''
 f() {}
 const v = f;
 ''');
     _assertUnlinkedConst(variable.initializer.bodyExpr, operators: [
-      UnlinkedConstOperation.pushReference
+      UnlinkedExprOperation.pushReference
     ], referenceValidators: [
       (EntityRef r) => checkTypeRef(r, null, null, 'f',
           expectedKind: ReferenceKind.topLevelFunction)
     ]);
   }
 
   test_constExpr_pushReference_topLevelFunction_imported() {
     addNamedSource(
         '/a.dart',
         '''
 f() {}
 ''');
     UnlinkedVariable variable = serializeVariableText('''
 import 'a.dart';
 const v = f;
 ''');
     _assertUnlinkedConst(variable.initializer.bodyExpr, operators: [
-      UnlinkedConstOperation.pushReference
+      UnlinkedExprOperation.pushReference
     ], referenceValidators: [
       (EntityRef r) => checkTypeRef(r, absUri('/a.dart'), 'a.dart', 'f',
           expectedKind: ReferenceKind.topLevelFunction)
     ]);
   }
 
   test_constExpr_pushReference_topLevelFunction_imported_withPrefix() {
     addNamedSource(
         '/a.dart',
         '''
 f() {}
 ''');
     UnlinkedVariable variable = serializeVariableText('''
 import 'a.dart' as p;
 const v = p.f;
 ''');
     _assertUnlinkedConst(variable.initializer.bodyExpr, operators: [
-      UnlinkedConstOperation.pushReference
+      UnlinkedExprOperation.pushReference
     ], referenceValidators: [
       (EntityRef r) => checkTypeRef(r, absUri('/a.dart'), 'a.dart', 'f',
               expectedKind: ReferenceKind.topLevelFunction,
               prefixExpectations: [
                 new _PrefixExpectation(ReferenceKind.prefix, 'p')
               ])
     ]);
   }
 
   test_constExpr_pushReference_topLevelGetter() {
     UnlinkedVariable variable = serializeVariableText('''
 int get x => null;
 const v = x;
 ''');
     _assertUnlinkedConst(variable.initializer.bodyExpr, operators: [
-      UnlinkedConstOperation.pushReference
+      UnlinkedExprOperation.pushReference
     ], referenceValidators: [
       (EntityRef r) => checkTypeRef(r, null, null, 'x',
           expectedKind: ReferenceKind.topLevelPropertyAccessor)
     ]);
   }
 
   test_constExpr_pushReference_topLevelGetter_imported() {
     addNamedSource('/a.dart', 'int get x => null;');
     UnlinkedVariable variable = serializeVariableText('''
 import 'a.dart';
 const v = x;
 ''');
     _assertUnlinkedConst(variable.initializer.bodyExpr, operators: [
-      UnlinkedConstOperation.pushReference
+      UnlinkedExprOperation.pushReference
     ], referenceValidators: [
       (EntityRef r) => checkTypeRef(r, absUri('/a.dart'), 'a.dart', 'x',
           expectedKind: ReferenceKind.topLevelPropertyAccessor)
     ]);
   }
 
   test_constExpr_pushReference_topLevelGetter_imported_withPrefix() {
     addNamedSource('/a.dart', 'int get x => null;');
     UnlinkedVariable variable = serializeVariableText('''
 import 'a.dart' as p;
 const v = p.x;
 ''');
     _assertUnlinkedConst(variable.initializer.bodyExpr, operators: [
-      UnlinkedConstOperation.pushReference
+      UnlinkedExprOperation.pushReference
     ], referenceValidators: [
       (EntityRef r) => checkTypeRef(r, absUri('/a.dart'), 'a.dart', 'x',
           expectedKind: ReferenceKind.topLevelPropertyAccessor,
           expectedPrefix: 'p')
     ]);
   }
 
   test_constExpr_pushReference_topLevelVariable() {
     UnlinkedVariable variable = serializeVariableText('''
 const int a = 1;
 const v = a;
 ''');
     _assertUnlinkedConst(variable.initializer.bodyExpr, operators: [
-      UnlinkedConstOperation.pushReference
+      UnlinkedExprOperation.pushReference
     ], referenceValidators: [
       (EntityRef r) => checkTypeRef(r, null, null, 'a',
           expectedKind: ReferenceKind.topLevelPropertyAccessor)
     ]);
   }
 
   test_constExpr_pushReference_topLevelVariable_imported() {
     addNamedSource('/a.dart', 'const int a = 1;');
     UnlinkedVariable variable = serializeVariableText('''
 import 'a.dart';
 const v = a;
 ''');
     _assertUnlinkedConst(variable.initializer.bodyExpr, operators: [
-      UnlinkedConstOperation.pushReference
+      UnlinkedExprOperation.pushReference
     ], referenceValidators: [
       (EntityRef r) => checkTypeRef(r, absUri('/a.dart'), 'a.dart', 'a',
           expectedKind: ReferenceKind.topLevelPropertyAccessor)
     ]);
   }
 
   test_constExpr_pushReference_topLevelVariable_imported_withPrefix() {
     addNamedSource('/a.dart', 'const int a = 1;');
     UnlinkedVariable variable = serializeVariableText('''
 import 'a.dart' as p;
 const v = p.a;
 ''');
     _assertUnlinkedConst(variable.initializer.bodyExpr, operators: [
-      UnlinkedConstOperation.pushReference
+      UnlinkedExprOperation.pushReference
     ], referenceValidators: [
       (EntityRef r) {
         return checkTypeRef(r, absUri('/a.dart'), 'a.dart', 'a',
             expectedKind: ReferenceKind.topLevelPropertyAccessor,
             expectedPrefix: 'p');
       }
     ]);
   }
 
   test_constExpr_pushReference_typeParameter() {
     String text = '''
 class C<T> {
   static const a = T;
 }
 ''';
     UnlinkedVariable variable =
         serializeClassText(text, allowErrors: true).fields[0];
     _assertUnlinkedConst(variable.initializer.bodyExpr, operators: [
-      UnlinkedConstOperation.pushReference
+      UnlinkedExprOperation.pushReference
     ], referenceValidators: [
       (EntityRef r) {
         return checkParamTypeRef(r, 1);
       }
     ]);
   }
 
   test_constExpr_pushReference_unresolved_prefix0() {
     UnlinkedVariable variable = serializeVariableText(
         '''
 const v = foo;
 ''',
         allowErrors: true);
     _assertUnlinkedConst(variable.initializer.bodyExpr, operators: [
-      UnlinkedConstOperation.pushReference
+      UnlinkedExprOperation.pushReference
     ], referenceValidators: [
       (EntityRef r) => checkTypeRef(r, null, null, 'foo',
           expectedKind: ReferenceKind.unresolved)
     ]);
   }
 
   test_constExpr_pushReference_unresolved_prefix1() {
     UnlinkedVariable variable = serializeVariableText(
         '''
 class C {}
 const v = C.foo;
 ''',
         allowErrors: true);
     _assertUnlinkedConst(variable.initializer.bodyExpr, operators: [
-      UnlinkedConstOperation.pushReference
+      UnlinkedExprOperation.pushReference
     ], referenceValidators: [
       (EntityRef r) => checkTypeRef(r, null, null, 'foo',
               expectedKind: ReferenceKind.unresolved,
               prefixExpectations: [
                 new _PrefixExpectation(ReferenceKind.classOrEnum, 'C')
               ])
     ]);
   }
 
   test_constExpr_pushReference_unresolved_prefix2() {
     addNamedSource(
         '/a.dart',
         '''
 class C {}
 ''');
     UnlinkedVariable variable = serializeVariableText(
         '''
 import 'a.dart' as p;
 const v = p.C.foo;
 ''',
         allowErrors: true);
     _assertUnlinkedConst(variable.initializer.bodyExpr, operators: [
-      UnlinkedConstOperation.pushReference
+      UnlinkedExprOperation.pushReference
     ], referenceValidators: [
       (EntityRef r) => checkTypeRef(r, null, null, 'foo',
               expectedKind: ReferenceKind.unresolved,
               prefixExpectations: [
                 new _PrefixExpectation(ReferenceKind.classOrEnum, 'C',
                     absoluteUri: absUri('/a.dart'), relativeUri: 'a.dart'),
                 new _PrefixExpectation(ReferenceKind.prefix, 'p'),
               ])
     ]);
   }
 
   test_constExpr_pushString_adjacent() {
     UnlinkedVariable variable =
         serializeVariableText('const v = "aaa" "b" "ccc";');
     _assertUnlinkedConst(variable.initializer.bodyExpr,
-        operators: [UnlinkedConstOperation.pushString], strings: ['aaabccc']);
+        operators: [UnlinkedExprOperation.pushString], strings: ['aaabccc']);
   }
 
   test_constExpr_pushString_adjacent_interpolation() {
     UnlinkedVariable variable =
         serializeVariableText(r'const v = "aaa" "bb ${42} bbb" "cccc";');
     _assertUnlinkedConst(variable.initializer.bodyExpr, operators: [
-      UnlinkedConstOperation.pushString,
-      UnlinkedConstOperation.pushString,
-      UnlinkedConstOperation.pushInt,
-      UnlinkedConstOperation.pushString,
-      UnlinkedConstOperation.concatenate,
-      UnlinkedConstOperation.pushString,
-      UnlinkedConstOperation.concatenate,
+      UnlinkedExprOperation.pushString,
+      UnlinkedExprOperation.pushString,
+      UnlinkedExprOperation.pushInt,
+      UnlinkedExprOperation.pushString,
+      UnlinkedExprOperation.concatenate,
+      UnlinkedExprOperation.pushString,
+      UnlinkedExprOperation.concatenate,
     ], ints: [
       42,
       3,
       3,
     ], strings: [
       'aaa',
       'bb ',
       ' bbb',
       'cccc'
     ]);
   }
 
   test_constExpr_pushString_interpolation() {
     UnlinkedVariable variable =
         serializeVariableText(r'const v = "aaa ${42} bbb";');
     _assertUnlinkedConst(variable.initializer.bodyExpr, operators: [
-      UnlinkedConstOperation.pushString,
-      UnlinkedConstOperation.pushInt,
-      UnlinkedConstOperation.pushString,
-      UnlinkedConstOperation.concatenate
+      UnlinkedExprOperation.pushString,
+      UnlinkedExprOperation.pushInt,
+      UnlinkedExprOperation.pushString,
+      UnlinkedExprOperation.concatenate
     ], ints: [
       42,
       3
     ], strings: [
       'aaa ',
       ' bbb'
     ]);
   }
 
   test_constExpr_pushString_simple() {
     UnlinkedVariable variable = serializeVariableText('const v = "abc";');
     _assertUnlinkedConst(variable.initializer.bodyExpr,
-        operators: [UnlinkedConstOperation.pushString], strings: ['abc']);
+        operators: [UnlinkedExprOperation.pushString], strings: ['abc']);
   }
 
   test_constExpr_pushTrue() {
     UnlinkedVariable variable = serializeVariableText('const v = true;');
     _assertUnlinkedConst(variable.initializer.bodyExpr,
-        operators: [UnlinkedConstOperation.pushTrue]);
+        operators: [UnlinkedExprOperation.pushTrue]);
   }
 
   test_constructor() {
     String text = 'class C { C(); }';
     UnlinkedExecutable executable =
         findExecutable('', executables: serializeClassText(text).executables);
     expect(executable.kind, UnlinkedExecutableKind.constructor);
     expect(executable.returnType, isNull);
     expect(executable.isAsynchronous, isFalse);
     expect(executable.isExternal, isFalse);
@@ skipping 71 matching lines @@
   final x;
   const C() : x = 42;
 }
 ''').executables);
     expect(executable.constantInitializers, hasLength(1));
     UnlinkedConstructorInitializer initializer =
         executable.constantInitializers[0];
     expect(initializer.kind, UnlinkedConstructorInitializerKind.field);
     expect(initializer.name, 'x');
     _assertUnlinkedConst(initializer.expression,
-        operators: [UnlinkedConstOperation.pushInt], ints: [42]);
+        operators: [UnlinkedExprOperation.pushInt], ints: [42]);
     expect(initializer.arguments, isEmpty);
   }
 
   test_constructor_initializers_field_withParameter() {
     UnlinkedExecutable executable =
         findExecutable('', executables: serializeClassText(r'''
 class C {
   final x;
   const C(int p) : x = p;
 }
 ''').executables);
     expect(executable.constantInitializers, hasLength(1));
     UnlinkedConstructorInitializer initializer =
         executable.constantInitializers[0];
     expect(initializer.kind, UnlinkedConstructorInitializerKind.field);
     expect(initializer.name, 'x');
     _assertUnlinkedConst(initializer.expression,
-        operators: [UnlinkedConstOperation.pushParameter], strings: ['p']);
+        operators: [UnlinkedExprOperation.pushParameter], strings: ['p']);
     expect(initializer.arguments, isEmpty);
   }
 
   test_constructor_initializers_notConst() {
     UnlinkedExecutable executable =
         findExecutable('', executables: serializeClassText(r'''
 class C {
   final x;
   C() : x = 42;
 }
@@ skipping 13 matching lines @@
 ''').executables);
     expect(executable.constantInitializers, hasLength(1));
     UnlinkedConstructorInitializer initializer =
         executable.constantInitializers[0];
     expect(
         initializer.kind, UnlinkedConstructorInitializerKind.superInvocation);
     expect(initializer.name, 'aaa');
     expect(initializer.expression, isNull);
     expect(initializer.arguments, hasLength(1));
     _assertUnlinkedConst(initializer.arguments[0],
-        operators: [UnlinkedConstOperation.pushInt], ints: [42]);
+        operators: [UnlinkedExprOperation.pushInt], ints: [42]);
   }
 
   test_constructor_initializers_superInvocation_namedExpression() {
     UnlinkedExecutable executable =
         findExecutable('', executables: serializeClassText(r'''
 class A {
   const A(a, {int b, int c});
 }
 class C extends A {
   const C() : super(1, b: 2, c: 3);
 }
 ''').executables);
     expect(executable.constantInitializers, hasLength(1));
     UnlinkedConstructorInitializer initializer =
         executable.constantInitializers[0];
     expect(
         initializer.kind, UnlinkedConstructorInitializerKind.superInvocation);
     expect(initializer.name, '');
     expect(initializer.expression, isNull);
     expect(initializer.arguments, hasLength(3));
     _assertUnlinkedConst(initializer.arguments[0],
-        operators: [UnlinkedConstOperation.pushInt], ints: [1]);
+        operators: [UnlinkedExprOperation.pushInt], ints: [1]);
     _assertUnlinkedConst(initializer.arguments[1],
-        operators: [UnlinkedConstOperation.pushInt], ints: [2]);
+        operators: [UnlinkedExprOperation.pushInt], ints: [2]);
     _assertUnlinkedConst(initializer.arguments[2],
-        operators: [UnlinkedConstOperation.pushInt], ints: [3]);
+        operators: [UnlinkedExprOperation.pushInt], ints: [3]);
     expect(initializer.argumentNames, ['b', 'c']);
   }
 
   test_constructor_initializers_superInvocation_unnamed() {
     UnlinkedExecutable executable =
         findExecutable('ccc', executables: serializeClassText(r'''
 class A {
   const A(int p);
 }
 class C extends A {
   const C.ccc() : super(42);
 }
 ''').executables);
     expect(executable.constantInitializers, hasLength(1));
     UnlinkedConstructorInitializer initializer =
         executable.constantInitializers[0];
     expect(
         initializer.kind, UnlinkedConstructorInitializerKind.superInvocation);
     expect(initializer.name, '');
     expect(initializer.expression, isNull);
     expect(initializer.arguments, hasLength(1));
     _assertUnlinkedConst(initializer.arguments[0],
-        operators: [UnlinkedConstOperation.pushInt], ints: [42]);
+        operators: [UnlinkedExprOperation.pushInt], ints: [42]);
   }
 
   test_constructor_initializers_thisInvocation_named() {
     UnlinkedExecutable executable =
         findExecutable('', executables: serializeClassText(r'''
 class C {
   const C() : this.named(1, 'bbb');
   const C.named(int a, String b);
 }
 ''').executables);
     expect(executable.constantInitializers, hasLength(1));
     UnlinkedConstructorInitializer initializer =
         executable.constantInitializers[0];
     expect(initializer.kind, UnlinkedConstructorInitializerKind.thisInvocation);
     expect(initializer.name, 'named');
     expect(initializer.expression, isNull);
     expect(initializer.arguments, hasLength(2));
     _assertUnlinkedConst(initializer.arguments[0],
-        operators: [UnlinkedConstOperation.pushInt], ints: [1]);
+        operators: [UnlinkedExprOperation.pushInt], ints: [1]);
     _assertUnlinkedConst(initializer.arguments[1],
-        operators: [UnlinkedConstOperation.pushString], strings: ['bbb']);
+        operators: [UnlinkedExprOperation.pushString], strings: ['bbb']);
   }
 
   test_constructor_initializers_thisInvocation_namedExpression() {
     UnlinkedExecutable executable =
         findExecutable('', executables: serializeClassText(r'''
 class C {
   const C() : this.named(1, b: 2, c: 3);
   const C.named(a, {int b, int c});
 }
 ''').executables);
     expect(executable.constantInitializers, hasLength(1));
     UnlinkedConstructorInitializer initializer =
         executable.constantInitializers[0];
     expect(initializer.kind, UnlinkedConstructorInitializerKind.thisInvocation);
     expect(initializer.name, 'named');
     expect(initializer.expression, isNull);
     expect(initializer.arguments, hasLength(3));
     _assertUnlinkedConst(initializer.arguments[0],
-        operators: [UnlinkedConstOperation.pushInt], ints: [1]);
+        operators: [UnlinkedExprOperation.pushInt], ints: [1]);
     _assertUnlinkedConst(initializer.arguments[1],
-        operators: [UnlinkedConstOperation.pushInt], ints: [2]);
+        operators: [UnlinkedExprOperation.pushInt], ints: [2]);
     _assertUnlinkedConst(initializer.arguments[2],
-        operators: [UnlinkedConstOperation.pushInt], ints: [3]);
+        operators: [UnlinkedExprOperation.pushInt], ints: [3]);
     expect(initializer.argumentNames, ['b', 'c']);
   }
 
   test_constructor_initializers_thisInvocation_unnamed() {
     UnlinkedExecutable executable =
         findExecutable('named', executables: serializeClassText(r'''
 class C {
   const C.named() : this(1, 'bbb');
   const C(int a, String b);
 }
 ''').executables);
     expect(executable.constantInitializers, hasLength(1));
     UnlinkedConstructorInitializer initializer =
         executable.constantInitializers[0];
     expect(initializer.kind, UnlinkedConstructorInitializerKind.thisInvocation);
     expect(initializer.name, '');
     expect(initializer.expression, isNull);
     expect(initializer.arguments, hasLength(2));
     _assertUnlinkedConst(initializer.arguments[0],
-        operators: [UnlinkedConstOperation.pushInt], ints: [1]);
+        operators: [UnlinkedExprOperation.pushInt], ints: [1]);
     _assertUnlinkedConst(initializer.arguments[1],
-        operators: [UnlinkedConstOperation.pushString], strings: ['bbb']);
+        operators: [UnlinkedExprOperation.pushString], strings: ['bbb']);
   }
 
   test_constructor_initializing_formal() {
     UnlinkedExecutable executable = findExecutable('',
         executables:
             serializeClassText('class C { C(this.x); final x; }').executables);
     UnlinkedParam parameter = executable.parameters[0];
     expect(parameter.isInitializingFormal, isTrue);
   }
 
@@ skipping 64 matching lines @@
   C([this.x() = foo]);
   final x;
 }
 int foo() => 0;
 ''').executables);
     UnlinkedParam param = executable.parameters[0];
     expect(param.isFunctionTyped, isTrue);
     expect(param.kind, UnlinkedParamKind.positional);
     expect(param.defaultValueCode, 'foo');
     _assertUnlinkedConst(param.initializer.bodyExpr, operators: [
-      UnlinkedConstOperation.pushReference
+      UnlinkedExprOperation.pushReference
     ], referenceValidators: [
       (EntityRef r) => checkTypeRef(r, null, null, 'foo',
           expectedKind: ReferenceKind.topLevelFunction)
     ]);
   }
 
   test_constructor_initializing_formal_implicit_type() {
     // Note: the implicit type of an initializing formal is the type of the
     // field.
     UnlinkedExecutable executable = findExecutable('',
@@ skipping 24 matching lines @@
   test_constructor_initializing_formal_named_withDefault() {
     UnlinkedExecutable executable = findExecutable('',
         executables: serializeClassText('class C { C({this.x: 42}); final x; }')
             .executables);
     UnlinkedParam parameter = executable.parameters[0];
     expect(parameter.kind, UnlinkedParamKind.named);
     expect(parameter.initializer, isNotNull);
     expect(parameter.defaultValueCode, '42');
     _assertCodeRange(parameter.codeRange, 13, 10);
     _assertUnlinkedConst(parameter.initializer.bodyExpr,
-        operators: [UnlinkedConstOperation.pushInt], ints: [42]);
+        operators: [UnlinkedExprOperation.pushInt], ints: [42]);
   }
 
   test_constructor_initializing_formal_non_function_typed() {
     UnlinkedExecutable executable = findExecutable('',
         executables:
             serializeClassText('class C { C(this.x); final x; }').executables);
     UnlinkedParam parameter = executable.parameters[0];
     expect(parameter.isFunctionTyped, isFalse);
   }
 
@@ skipping 11 matching lines @@
     UnlinkedExecutable executable = findExecutable('',
         executables:
             serializeClassText('class C { C([this.x = 42]); final x; }')
                 .executables);
     UnlinkedParam parameter = executable.parameters[0];
     expect(parameter.kind, UnlinkedParamKind.positional);
     expect(parameter.initializer, isNotNull);
     expect(parameter.defaultValueCode, '42');
     _assertCodeRange(parameter.codeRange, 13, 11);
     _assertUnlinkedConst(parameter.initializer.bodyExpr,
-        operators: [UnlinkedConstOperation.pushInt], ints: [42]);
+        operators: [UnlinkedExprOperation.pushInt], ints: [42]);
   }
 
   test_constructor_initializing_formal_required() {
     UnlinkedExecutable executable = findExecutable('',
         executables:
             serializeClassText('class C { C(this.x); final x; }').executables);
     UnlinkedParam parameter = executable.parameters[0];
     expect(parameter.kind, UnlinkedParamKind.required);
   }
 
@@ skipping 11 matching lines @@
     UnlinkedExecutable executable =
         findExecutable('', executables: serializeClassText(r'''
 class C {
   C([this.x = 42]);
   final int x;
 }''').executables);
     UnlinkedParam param = executable.parameters[0];
     expect(param.kind, UnlinkedParamKind.positional);
     expect(param.defaultValueCode, '42');
     _assertUnlinkedConst(param.initializer.bodyExpr,
-        operators: [UnlinkedConstOperation.pushInt], ints: [42]);
+        operators: [UnlinkedExprOperation.pushInt], ints: [42]);
   }
 
   test_constructor_named() {
     String text = 'class C { C.foo(); }';
     UnlinkedExecutable executable = findExecutable('foo',
         executables: serializeClassText(text).executables);
     expect(executable.name, 'foo');
     expect(executable.nameOffset, text.indexOf('foo'));
     expect(executable.periodOffset, text.indexOf('.foo'));
     expect(executable.nameEnd, text.indexOf('()'));
@@ skipping 1889 matching lines @@
   test_executable_param_function_typed_withDefault() {
     UnlinkedExecutable executable = serializeExecutableText(r'''
 f([int p(int a2, String b2) = foo]) {}
 int foo(int a, String b) => 0;
 ''');
     UnlinkedParam param = executable.parameters[0];
     expect(param.kind, UnlinkedParamKind.positional);
     expect(param.initializer, isNotNull);
     expect(param.defaultValueCode, 'foo');
     _assertUnlinkedConst(param.initializer.bodyExpr, operators: [
-      UnlinkedConstOperation.pushReference
+      UnlinkedExprOperation.pushReference
     ], referenceValidators: [
       (EntityRef r) => checkTypeRef(r, null, null, 'foo',
           expectedKind: ReferenceKind.topLevelFunction)
     ]);
   }
 
   test_executable_param_kind_named() {
     UnlinkedExecutable executable = serializeExecutableText('f({x}) {}');
     UnlinkedParam param = executable.parameters[0];
     expect(param.kind, UnlinkedParamKind.named);
     expect(param.initializer, isNull);
     expect(param.defaultValueCode, isEmpty);
   }
 
   test_executable_param_kind_named_withDefault() {
     UnlinkedExecutable executable = serializeExecutableText('f({x: 42}) {}');
     UnlinkedParam param = executable.parameters[0];
     expect(param.kind, UnlinkedParamKind.named);
     expect(param.initializer, isNotNull);
     expect(param.defaultValueCode, '42');
     _assertCodeRange(param.codeRange, 3, 5);
     _assertUnlinkedConst(param.initializer.bodyExpr,
-        operators: [UnlinkedConstOperation.pushInt], ints: [42]);
+        operators: [UnlinkedExprOperation.pushInt], ints: [42]);
   }
 
   test_executable_param_kind_positional() {
     UnlinkedExecutable executable = serializeExecutableText('f([x]) {}');
     UnlinkedParam param = executable.parameters[0];
     expect(param.kind, UnlinkedParamKind.positional);
     expect(param.initializer, isNull);
     expect(param.defaultValueCode, isEmpty);
   }
 
   test_executable_param_kind_positional_withDefault() {
     UnlinkedExecutable executable = serializeExecutableText('f([x = 42]) {}');
     UnlinkedParam param = executable.parameters[0];
     expect(param.kind, UnlinkedParamKind.positional);
     expect(param.initializer, isNotNull);
     expect(param.defaultValueCode, '42');
     _assertCodeRange(param.codeRange, 3, 6);
     _assertUnlinkedConst(param.initializer.bodyExpr,
-        operators: [UnlinkedConstOperation.pushInt], ints: [42]);
+        operators: [UnlinkedExprOperation.pushInt], ints: [42]);
   }
 
   test_executable_param_kind_required() {
     UnlinkedExecutable executable = serializeExecutableText('f(x) {}');
     UnlinkedParam param = executable.parameters[0];
     expect(param.kind, UnlinkedParamKind.required);
     expect(param.initializer, isNull);
     expect(param.defaultValueCode, isEmpty);
   }
 
@@ skipping 543 matching lines @@
 }
 class C {
   List<int> f = <int>[0, 1, 2];
 }
 A a = new A();
 final v = (a.b.c.f[1] = 5);
 ''');
     _assertUnlinkedConst(variable.initializer.bodyExpr,
         isValidConst: false,
         operators: [
-          UnlinkedConstOperation.pushInt,
-          UnlinkedConstOperation.pushReference,
-          UnlinkedConstOperation.pushInt,
-          UnlinkedConstOperation.assignToIndex,
+          UnlinkedExprOperation.pushInt,
+          UnlinkedExprOperation.pushReference,
+          UnlinkedExprOperation.pushInt,
+          UnlinkedExprOperation.assignToIndex,
         ],
         assignmentOperators: [
           (UnlinkedExprAssignOperator.assign)
         ],
         ints: [
           5,
           1
         ],
         strings: [],
         referenceValidators: [
@@ skipping 22 matching lines @@
 class C {
   List<int> f = <int>[0, 1, 2];
 }
 A a = new A();
 final v = (a.b[1].c[2].f[3] = 5);
 ''');
     _assertUnlinkedConst(variable.initializer.bodyExpr,
         isValidConst: false,
         operators: [
           // 5
-          UnlinkedConstOperation.pushInt,
+          UnlinkedExprOperation.pushInt,
           // a.b[1]
-          UnlinkedConstOperation.pushReference,
-          UnlinkedConstOperation.pushInt,
-          UnlinkedConstOperation.extractIndex,
+          UnlinkedExprOperation.pushReference,
+          UnlinkedExprOperation.pushInt,
+          UnlinkedExprOperation.extractIndex,
           // c[2]
-          UnlinkedConstOperation.extractProperty,
-          UnlinkedConstOperation.pushInt,
-          UnlinkedConstOperation.extractIndex,
+          UnlinkedExprOperation.extractProperty,
+          UnlinkedExprOperation.pushInt,
+          UnlinkedExprOperation.extractIndex,
           // f[3] = 5
-          UnlinkedConstOperation.extractProperty,
-          UnlinkedConstOperation.pushInt,
-          UnlinkedConstOperation.assignToIndex,
+          UnlinkedExprOperation.extractProperty,
+          UnlinkedExprOperation.pushInt,
+          UnlinkedExprOperation.assignToIndex,
         ],
         assignmentOperators: [
           (UnlinkedExprAssignOperator.assign)
         ],
         ints: [
           5,
           1,
           2,
           3,
         ],
@@ skipping 15 matching lines @@
     if (skipNonConstInitializers) {
       return;
     }
     UnlinkedVariable variable = serializeVariableText('''
 List<int> a = <int>[0, 1, 2];
 final v = (a[1] = 5);
 ''');
     _assertUnlinkedConst(variable.initializer.bodyExpr,
         isValidConst: false,
         operators: [
-          UnlinkedConstOperation.pushInt,
-          UnlinkedConstOperation.pushReference,
-          UnlinkedConstOperation.pushInt,
-          UnlinkedConstOperation.assignToIndex,
+          UnlinkedExprOperation.pushInt,
+          UnlinkedExprOperation.pushReference,
+          UnlinkedExprOperation.pushInt,
+          UnlinkedExprOperation.assignToIndex,
         ],
         assignmentOperators: [
           (UnlinkedExprAssignOperator.assign)
         ],
         ints: [
           5,
           1,
         ],
         strings: [],
         referenceValidators: [
           (EntityRef r) => checkTypeRef(r, null, null, 'a',
               expectedKind: ReferenceKind.topLevelPropertyAccessor)
         ]);
   }
 
   test_expr_assignToProperty_ofInstanceCreation() {
     if (skipNonConstInitializers) {
       return;
     }
     UnlinkedVariable variable = serializeVariableText('''
 class C {
   int f;
 }
 final v = (new C().f = 5);
 ''');
     _assertUnlinkedConst(variable.initializer.bodyExpr,
         isValidConst: false,
         operators: [
-          UnlinkedConstOperation.pushInt,
-          UnlinkedConstOperation.invokeConstructor,
-          UnlinkedConstOperation.assignToProperty,
+          UnlinkedExprOperation.pushInt,
+          UnlinkedExprOperation.invokeConstructor,
+          UnlinkedExprOperation.assignToProperty,
         ],
         assignmentOperators: [
           (UnlinkedExprAssignOperator.assign)
         ],
         ints: [
           5,
           0,
           0,
         ],
         strings: [
@@ skipping 11 matching lines @@
     }
     UnlinkedVariable variable = serializeVariableText('''
 class C {
   static int f;
 }
 final v = (C.f = 1);
 ''');
     _assertUnlinkedConst(variable.initializer.bodyExpr,
         isValidConst: false,
         operators: [
-          UnlinkedConstOperation.pushInt,
-          UnlinkedConstOperation.assignToRef,
+          UnlinkedExprOperation.pushInt,
+          UnlinkedExprOperation.assignToRef,
         ],
         assignmentOperators: [
           (UnlinkedExprAssignOperator.assign)
         ],
         ints: [
           1,
         ],
         strings: [],
         referenceValidators: [
           (EntityRef r) => checkTypeRef(r, null, null, 'f',
@@ skipping 17 matching lines @@
 }
 class C {
   int f;
 }
 A a = new A();
 final v = (a.b.c.f = 1);
 ''');
     _assertUnlinkedConst(variable.initializer.bodyExpr,
         isValidConst: false,
         operators: [
-          UnlinkedConstOperation.pushInt,
-          UnlinkedConstOperation.assignToRef,
+          UnlinkedExprOperation.pushInt,
+          UnlinkedExprOperation.assignToRef,
         ],
         assignmentOperators: [
           (UnlinkedExprAssignOperator.assign)
         ],
         ints: [
           1,
         ],
         strings: [],
         referenceValidators: [
           (EntityRef r) => checkTypeRef(r, null, null, 'f',
@@ skipping 31 matching lines @@
     if (skipNonConstInitializers) {
       return;
     }
     UnlinkedVariable variable = serializeVariableText('''
 int a = 0;
 final v = (a = 1);
 ''');
     _assertUnlinkedConst(variable.initializer.bodyExpr,
         isValidConst: false,
         operators: [
-          UnlinkedConstOperation.pushInt,
-          UnlinkedConstOperation.assignToRef,
+          UnlinkedExprOperation.pushInt,
+          UnlinkedExprOperation.assignToRef,
         ],
         assignmentOperators: [
           (UnlinkedExprAssignOperator.assign)
         ],
         ints: [
           1,
         ],
         strings: [],
         referenceValidators: [
           (EntityRef r) => checkTypeRef(r, null, null, 'a',
@@ skipping 10 matching lines @@
         '''
 int a = 0;
 ''');
     UnlinkedVariable variable = serializeVariableText('''
 import 'a.dart';
 final v = (a = 1);
 ''');
     _assertUnlinkedConst(variable.initializer.bodyExpr,
         isValidConst: false,
         operators: [
-          UnlinkedConstOperation.pushInt,
-          UnlinkedConstOperation.assignToRef,
+          UnlinkedExprOperation.pushInt,
+          UnlinkedExprOperation.assignToRef,
         ],
         assignmentOperators: [
           (UnlinkedExprAssignOperator.assign)
         ],
         ints: [
           1,
         ],
         strings: [],
         referenceValidators: [
           (EntityRef r) => checkTypeRef(r, absUri('/a.dart'), 'a.dart', 'a',
@@ skipping 10 matching lines @@
         '''
 int a = 0;
 ''');
     UnlinkedVariable variable = serializeVariableText('''
 import 'a.dart' as p;
 final v = (p.a = 1);
 ''');
     _assertUnlinkedConst(variable.initializer.bodyExpr,
         isValidConst: false,
         operators: [
-          UnlinkedConstOperation.pushInt,
-          UnlinkedConstOperation.assignToRef,
+          UnlinkedExprOperation.pushInt,
+          UnlinkedExprOperation.assignToRef,
         ],
         assignmentOperators: [
           (UnlinkedExprAssignOperator.assign)
         ],
         ints: [
           1,
         ],
         strings: [],
         referenceValidators: [
           (EntityRef r) {
@@ skipping 11 matching lines @@
     UnlinkedVariable variable = serializeVariableText('''
 class C {
   List<int> items;
 }
 final C c = new C();
 final v = c.items..[1] = 2;
 ''');
     _assertUnlinkedConst(variable.initializer.bodyExpr,
         isValidConst: false,
         operators: [
-          UnlinkedConstOperation.pushReference,
+          UnlinkedExprOperation.pushReference,
           //   ..[1] = 2
-          UnlinkedConstOperation.cascadeSectionBegin,
-          UnlinkedConstOperation.pushInt,
-          UnlinkedConstOperation.pushInt,
-          UnlinkedConstOperation.assignToIndex,
+          UnlinkedExprOperation.cascadeSectionBegin,
+          UnlinkedExprOperation.pushInt,
+          UnlinkedExprOperation.pushInt,
+          UnlinkedExprOperation.assignToIndex,
           // c
-          UnlinkedConstOperation.cascadeSectionEnd,
+          UnlinkedExprOperation.cascadeSectionEnd,
         ],
         assignmentOperators: [
           UnlinkedExprAssignOperator.assign,
         ],
         ints: [
           2,
           1
         ],
         strings: [],
         referenceValidators: [
@@ skipping 14 matching lines @@
 class C {
   int f1 = 0;
   int f2 = 0;
 }
 final v = new C()..f1 = 1..f2 += 2;
 ''');
     _assertUnlinkedConst(variable.initializer.bodyExpr,
         isValidConst: false,
         operators: [
           // new C()
-          UnlinkedConstOperation.invokeConstructor,
+          UnlinkedExprOperation.invokeConstructor,
           //   ..f1 = 1
-          UnlinkedConstOperation.cascadeSectionBegin,
-          UnlinkedConstOperation.pushInt,
-          UnlinkedConstOperation.assignToProperty,
+          UnlinkedExprOperation.cascadeSectionBegin,
+          UnlinkedExprOperation.pushInt,
+          UnlinkedExprOperation.assignToProperty,
           // C
-          UnlinkedConstOperation.cascadeSectionEnd,
+          UnlinkedExprOperation.cascadeSectionEnd,
           //   ..f2 += 2
-          UnlinkedConstOperation.cascadeSectionBegin,
-          UnlinkedConstOperation.pushInt,
-          UnlinkedConstOperation.assignToProperty,
+          UnlinkedExprOperation.cascadeSectionBegin,
+          UnlinkedExprOperation.pushInt,
+          UnlinkedExprOperation.assignToProperty,
           // C
-          UnlinkedConstOperation.cascadeSectionEnd,
+          UnlinkedExprOperation.cascadeSectionEnd,
         ],
         assignmentOperators: [
           UnlinkedExprAssignOperator.assign,
           UnlinkedExprAssignOperator.plus,
         ],
         ints: [
           0, 0, // new C()
           1, // f1 = 1
           2, // f2 += 2
         ],
@@ skipping 22 matching lines @@
 }
 final v = new A()
   ..fa1 = 1
   ..b = (new B()..fb = 2)
   ..fa2 = 3;
 ''');
     _assertUnlinkedConst(variable.initializer.bodyExpr,
         isValidConst: false,
         operators: [
           // new A()
-          UnlinkedConstOperation.invokeConstructor,
+          UnlinkedExprOperation.invokeConstructor,
           // ..fa1 = 1
-          UnlinkedConstOperation.cascadeSectionBegin,
-          UnlinkedConstOperation.pushInt,
-          UnlinkedConstOperation.assignToProperty,
-          UnlinkedConstOperation.cascadeSectionEnd,
+          UnlinkedExprOperation.cascadeSectionBegin,
+          UnlinkedExprOperation.pushInt,
+          UnlinkedExprOperation.assignToProperty,
+          UnlinkedExprOperation.cascadeSectionEnd,
           // ..b
-          UnlinkedConstOperation.cascadeSectionBegin,
+          UnlinkedExprOperation.cascadeSectionBegin,
           //   new B()
-          UnlinkedConstOperation.invokeConstructor,
+          UnlinkedExprOperation.invokeConstructor,
           //   ..fb = 2
-          UnlinkedConstOperation.cascadeSectionBegin,
-          UnlinkedConstOperation.pushInt,
-          UnlinkedConstOperation.assignToProperty,
-          UnlinkedConstOperation.cascadeSectionEnd,
+          UnlinkedExprOperation.cascadeSectionBegin,
+          UnlinkedExprOperation.pushInt,
+          UnlinkedExprOperation.assignToProperty,
+          UnlinkedExprOperation.cascadeSectionEnd,
           // ..b = <pop value>
-          UnlinkedConstOperation.assignToProperty,
-          UnlinkedConstOperation.cascadeSectionEnd,
+          UnlinkedExprOperation.assignToProperty,
+          UnlinkedExprOperation.cascadeSectionEnd,
           // ..fa2 = 3
-          UnlinkedConstOperation.cascadeSectionBegin,
-          UnlinkedConstOperation.pushInt,
-          UnlinkedConstOperation.assignToProperty,
-          UnlinkedConstOperation.cascadeSectionEnd,
+          UnlinkedExprOperation.cascadeSectionBegin,
+          UnlinkedExprOperation.pushInt,
+          UnlinkedExprOperation.assignToProperty,
+          UnlinkedExprOperation.cascadeSectionEnd,
         ],
         assignmentOperators: [
           UnlinkedExprAssignOperator.assign,
           UnlinkedExprAssignOperator.assign,
           UnlinkedExprAssignOperator.assign,
           UnlinkedExprAssignOperator.assign,
         ],
         ints: [
           0,
           0,
@@ skipping 25 matching lines @@
 class A {
   int m(int _) => 0;
 }
 final A a = new A();
 final v = a..m(5).abs()..m(6);
 ''');
     _assertUnlinkedConst(variable.initializer.bodyExpr,
         isValidConst: false,
         operators: [
           // a
-          UnlinkedConstOperation.pushReference,
+          UnlinkedExprOperation.pushReference,
           //   ..m(5)
-          UnlinkedConstOperation.cascadeSectionBegin,
-          UnlinkedConstOperation.pushInt,
-          UnlinkedConstOperation.invokeMethod,
+          UnlinkedExprOperation.cascadeSectionBegin,
+          UnlinkedExprOperation.pushInt,
+          UnlinkedExprOperation.invokeMethod,
           //   ..abs()
-          UnlinkedConstOperation.invokeMethod,
+          UnlinkedExprOperation.invokeMethod,
           // a
-          UnlinkedConstOperation.cascadeSectionEnd,
+          UnlinkedExprOperation.cascadeSectionEnd,
           //   ..m(6)
-          UnlinkedConstOperation.cascadeSectionBegin,
-          UnlinkedConstOperation.pushInt,
-          UnlinkedConstOperation.invokeMethod,
+          UnlinkedExprOperation.cascadeSectionBegin,
+          UnlinkedExprOperation.pushInt,
+          UnlinkedExprOperation.invokeMethod,
           // a
-          UnlinkedConstOperation.cascadeSectionEnd,
+          UnlinkedExprOperation.cascadeSectionEnd,
         ],
         ints: [
           5, 0, 1, 0, // m(5)
           0, 0, 0, // abs()
           6, 0, 1, 0, // m(5)
         ],
         strings: [
           'm',
           'abs',
           'm',
@@ skipping 10 matching lines @@
     }
     UnlinkedVariable variable = serializeVariableText('''
 class C {
   List<int> get items => null;
 }
 final v = new C().items[5];
 ''');
     _assertUnlinkedConst(variable.initializer.bodyExpr,
         isValidConst: false,
         operators: [
-          UnlinkedConstOperation.invokeConstructor,
-          UnlinkedConstOperation.extractProperty,
-          UnlinkedConstOperation.pushInt,
-          UnlinkedConstOperation.extractIndex,
+          UnlinkedExprOperation.invokeConstructor,
+          UnlinkedExprOperation.extractProperty,
+          UnlinkedExprOperation.pushInt,
+          UnlinkedExprOperation.extractIndex,
         ],
         ints: [
           0,
           0,
           5
         ],
         strings: [
           'items'
         ],
         referenceValidators: [
           (EntityRef r) => checkTypeRef(r, null, null, 'C',
               expectedKind: ReferenceKind.classOrEnum)
         ]);
   }
 
   test_expr_extractProperty_ofInvokeConstructor() {
     if (skipNonConstInitializers) {
       return;
     }
     UnlinkedVariable variable = serializeVariableText('''
 class C {
   int f = 0;
 }
 final v = new C().f;
 ''');
     _assertUnlinkedConst(variable.initializer.bodyExpr,
         isValidConst: false,
         operators: [
-          UnlinkedConstOperation.invokeConstructor,
-          UnlinkedConstOperation.extractProperty,
+          UnlinkedExprOperation.invokeConstructor,
+          UnlinkedExprOperation.extractProperty,
         ],
         ints: [
           0,
           0
         ],
         strings: [
           'f'
         ],
         referenceValidators: [
           (EntityRef r) => checkTypeRef(r, null, 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: [
-          UnlinkedConstOperation.pushInt,
-          UnlinkedConstOperation.pushLocalFunctionReference,
-          UnlinkedConstOperation.invokeMethodRef
+          UnlinkedExprOperation.pushInt,
+          UnlinkedExprOperation.pushLocalFunctionReference,
+          UnlinkedExprOperation.invokeMethodRef
         ],
         ints: [
           5,
           0,
           0,
           0,
           2,
           0
         ],
         referenceValidators: [
           (EntityRef r) => checkTypeRef(r, null, 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: [
-          UnlinkedConstOperation.pushInt,
-          UnlinkedConstOperation.pushLocalFunctionReference,
-          UnlinkedConstOperation.pushLocalFunctionReference,
-          UnlinkedConstOperation.invokeMethodRef
+          UnlinkedExprOperation.pushInt,
+          UnlinkedExprOperation.pushLocalFunctionReference,
+          UnlinkedExprOperation.pushLocalFunctionReference,
+          UnlinkedExprOperation.invokeMethodRef
         ],
         ints: [
           5,
           0,
           0,
           0,
           1,
           0,
           3,
           0
         ],
         referenceValidators: [
           (EntityRef r) => checkTypeRef(r, null, null, 'foo',
               expectedKind: ReferenceKind.topLevelFunction)
         ]);
   }
 
   test_expr_functionExpression_withBlockBody() {
     if (skipNonConstInitializers) {
       return;
     }
     UnlinkedVariable variable = serializeVariableText('''
 final v = () { return 42; };
 ''');
     _assertUnlinkedConst(variable.initializer.bodyExpr,
         isValidConst: false,
-        operators: [UnlinkedConstOperation.pushLocalFunctionReference],
+        operators: [UnlinkedExprOperation.pushLocalFunctionReference],
         ints: [0, 0]);
   }
 
   test_expr_functionExpression_withExpressionBody() {
     if (skipNonConstInitializers) {
       return;
     }
     UnlinkedVariable variable = serializeVariableText('''
 final v = () => 42;
 ''');
     _assertUnlinkedConst(variable.initializer.bodyExpr,
         isValidConst: false,
-        operators: [UnlinkedConstOperation.pushLocalFunctionReference],
+        operators: [UnlinkedExprOperation.pushLocalFunctionReference],
         ints: [0, 0]);
   }
 
   test_expr_functionExpressionInvocation_withBlockBody() {
     if (skipNonConstInitializers) {
       return;
     }
     UnlinkedVariable variable = serializeVariableText('''
 final v = ((a, b) {return 42;})(1, 2);
 ''');
     _assertUnlinkedConst(variable.initializer.bodyExpr,
-        isValidConst: false, operators: [UnlinkedConstOperation.pushNull]);
+        isValidConst: false, operators: [UnlinkedExprOperation.pushNull]);
   }
 
   test_expr_functionExpressionInvocation_withExpressionBody() {
     if (skipNonConstInitializers) {
       return;
     }
     UnlinkedVariable variable = serializeVariableText('''
 final v = ((a, b) => 42)(1, 2);
 ''');
     _assertUnlinkedConst(variable.initializer.bodyExpr,
-        isValidConst: false, operators: [UnlinkedConstOperation.pushNull]);
+        isValidConst: false, operators: [UnlinkedExprOperation.pushNull]);
   }
 
   test_expr_inClosure() {
     if (skipNonConstInitializers) {
       return;
     }
     UnlinkedVariable variable = serializeVariableText('var v = () => 1;');
     _assertUnlinkedConst(variable.initializer.localFunctions[0].bodyExpr,
-        operators: [UnlinkedConstOperation.pushInt], ints: [1]);
+        operators: [UnlinkedExprOperation.pushInt], ints: [1]);
   }
 
   test_expr_inClosure_noTypeInferenceNeeded() {
     // We don't serialize closure body expressions for closures that don't need
     // to participate in type inference.
     UnlinkedVariable variable = serializeVariableText('Object v = () => 1;');
     expect(variable.initializer.localFunctions[0].bodyExpr, isNull);
   }
 
   test_expr_inClosure_refersToOuterParam() {
     if (skipNonConstInitializers) {
       return;
     }
     UnlinkedVariable variable =
         serializeVariableText('var v = (x) => (y) => x;');
     _assertUnlinkedConst(
         variable.initializer.localFunctions[0].localFunctions[0].bodyExpr,
-        operators: [UnlinkedConstOperation.pushParameter],
+        operators: [UnlinkedExprOperation.pushParameter],
         strings: ['x']);
   }
 
   test_expr_inClosure_refersToParam() {
     if (skipNonConstInitializers) {
       return;
     }
     UnlinkedVariable variable = serializeVariableText('var v = (x) => x;');
     _assertUnlinkedConst(variable.initializer.localFunctions[0].bodyExpr,
-        operators: [UnlinkedConstOperation.pushParameter], strings: ['x']);
+        operators: [UnlinkedExprOperation.pushParameter], strings: ['x']);
   }
 
   test_expr_inClosure_refersToParam_methodCall() {
     if (skipNonConstInitializers) {
       return;
     }
     UnlinkedVariable variable = serializeVariableText('var v = (x) => x.f();');
     _assertUnlinkedConst(variable.initializer.localFunctions[0].bodyExpr,
         isValidConst: false,
         operators: [
-          UnlinkedConstOperation.pushParameter,
-          UnlinkedConstOperation.invokeMethod
+          UnlinkedExprOperation.pushParameter,
+          UnlinkedExprOperation.invokeMethod
         ],
         strings: [
           'x',
           'f'
         ],
         ints: [
           0,
           0,
           0
         ]);
   }
 
   test_expr_inClosure_refersToParam_methodCall_prefixed() {
     if (skipNonConstInitializers) {
       return;
     }
     UnlinkedVariable variable =
         serializeVariableText('var v = (x) => x.y.f();');
     _assertUnlinkedConst(variable.initializer.localFunctions[0].bodyExpr,
         isValidConst: false,
         operators: [
-          UnlinkedConstOperation.pushParameter,
-          UnlinkedConstOperation.extractProperty,
-          UnlinkedConstOperation.invokeMethod
+          UnlinkedExprOperation.pushParameter,
+          UnlinkedExprOperation.extractProperty,
+          UnlinkedExprOperation.invokeMethod
         ],
         strings: [
           'x',
           'y',
           'f'
         ],
         ints: [
           0,
           0,
           0
         ]);
   }
 
   test_expr_inClosure_refersToParam_outOfScope() {
     if (skipNonConstInitializers) {
       return;
     }
     UnlinkedVariable variable =
         serializeVariableText('var x; var v = (b) => (b ? (x) => x : x);');
     _assertUnlinkedConst(variable.initializer.localFunctions[0].bodyExpr,
         isValidConst: false,
         operators: [
-          UnlinkedConstOperation.pushParameter,
-          UnlinkedConstOperation.pushLocalFunctionReference,
-          UnlinkedConstOperation.pushReference,
-          UnlinkedConstOperation.conditional,
+          UnlinkedExprOperation.pushParameter,
+          UnlinkedExprOperation.pushLocalFunctionReference,
+          UnlinkedExprOperation.pushReference,
+          UnlinkedExprOperation.conditional,
         ],
         strings: [
           'b'
         ],
         ints: [
           0,
           0
         ],
         referenceValidators: [
           (EntityRef r) => checkTypeRef(r, null, null, 'x',
               expectedKind: ReferenceKind.topLevelPropertyAccessor)
         ]);
   }
 
   test_expr_inClosure_refersToParam_prefixedIdentifier() {
     if (skipNonConstInitializers) {
       return;
     }
     UnlinkedVariable variable = serializeVariableText('var v = (x) => x.y;');
     _assertUnlinkedConst(variable.initializer.localFunctions[0].bodyExpr,
         operators: [
-          UnlinkedConstOperation.pushParameter,
-          UnlinkedConstOperation.extractProperty
+          UnlinkedExprOperation.pushParameter,
+          UnlinkedExprOperation.extractProperty
         ],
         strings: [
           'x',
           'y'
         ]);
   }
 
   test_expr_inClosure_refersToParam_prefixedIdentifier_assign() {
     if (skipNonConstInitializers) {
       return;
     }
     UnlinkedVariable variable =
         serializeVariableText('var v = (x) => x.y = null;');
     _assertUnlinkedConst(variable.initializer.localFunctions[0].bodyExpr,
         isValidConst: false,
         operators: [
-          UnlinkedConstOperation.pushNull,
-          UnlinkedConstOperation.pushParameter,
-          UnlinkedConstOperation.assignToProperty
+          UnlinkedExprOperation.pushNull,
+          UnlinkedExprOperation.pushParameter,
+          UnlinkedExprOperation.assignToProperty
         ],
         strings: [
           'x',
           'y'
         ],
         assignmentOperators: [
           UnlinkedExprAssignOperator.assign
         ]);
   }
 
   test_expr_inClosure_refersToParam_prefixedPrefixedIdentifier() {
     if (skipNonConstInitializers) {
       return;
     }
     UnlinkedVariable variable = serializeVariableText('var v = (x) => x.y.z;');
     _assertUnlinkedConst(variable.initializer.localFunctions[0].bodyExpr,
         operators: [
-          UnlinkedConstOperation.pushParameter,
-          UnlinkedConstOperation.extractProperty,
-          UnlinkedConstOperation.extractProperty
+          UnlinkedExprOperation.pushParameter,
+          UnlinkedExprOperation.extractProperty,
+          UnlinkedExprOperation.extractProperty
         ],
         strings: [
           'x',
           'y',
           'z'
         ]);
   }
 
   test_expr_inClosure_refersToParam_prefixedPrefixedIdentifier_assign() {
     if (skipNonConstInitializers) {
       return;
     }
     UnlinkedVariable variable =
         serializeVariableText('var v = (x) => x.y.z = null;');
     _assertUnlinkedConst(variable.initializer.localFunctions[0].bodyExpr,
         isValidConst: false,
         operators: [
-          UnlinkedConstOperation.pushNull,
-          UnlinkedConstOperation.pushParameter,
-          UnlinkedConstOperation.extractProperty,
-          UnlinkedConstOperation.assignToProperty
+          UnlinkedExprOperation.pushNull,
+          UnlinkedExprOperation.pushParameter,
+          UnlinkedExprOperation.extractProperty,
+          UnlinkedExprOperation.assignToProperty
         ],
         strings: [
           'x',
           'y',
           'z'
         ],
         assignmentOperators: [
           UnlinkedExprAssignOperator.assign
         ]);
   }
 
   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: [
-          UnlinkedConstOperation.invokeConstructor,
-          UnlinkedConstOperation.pushInt,
-          UnlinkedConstOperation.pushInt,
-          UnlinkedConstOperation.pushInt,
-          UnlinkedConstOperation.invokeMethod,
+          UnlinkedExprOperation.invokeConstructor,
+          UnlinkedExprOperation.pushInt,
+          UnlinkedExprOperation.pushInt,
+          UnlinkedExprOperation.pushInt,
+          UnlinkedExprOperation.invokeMethod,
         ],
         ints: [
           0,
           0,
           1,
           2,
           3,
           2,
           1,
           0
@@ skipping 15 matching lines @@
     }
     UnlinkedVariable variable = serializeVariableText('''
 class C {
   f<T, U>() => null;
 }
 final v = new C().f<int, String>();
 ''');
     _assertUnlinkedConst(variable.initializer.bodyExpr,
         isValidConst: false,
         operators: [
-          UnlinkedConstOperation.invokeConstructor,
-          UnlinkedConstOperation.invokeMethod
+          UnlinkedExprOperation.invokeConstructor,
+          UnlinkedExprOperation.invokeMethod
         ],
         ints: [
           0,
           0,
           0,
           0,
           2
         ],
         strings: [
           'f'
@@ skipping 18 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: [
-          UnlinkedConstOperation.pushInt,
-          UnlinkedConstOperation.pushInt,
-          UnlinkedConstOperation.invokeMethodRef,
+          UnlinkedExprOperation.pushInt,
+          UnlinkedExprOperation.pushInt,
+          UnlinkedExprOperation.invokeMethodRef,
         ],
         ints: [
           10,
           20,
           0,
           2,
           0
         ],
         strings: [],
         referenceValidators: [
@@ skipping 19 matching lines @@
   static int m() => 42;
 }
 ''');
     UnlinkedVariable variable = serializeVariableText('''
 import 'a.dart' as p;
 final v = p.C.m();
 ''');
     _assertUnlinkedConst(variable.initializer.bodyExpr,
         isValidConst: false,
         operators: [
-          UnlinkedConstOperation.invokeMethodRef,
+          UnlinkedExprOperation.invokeMethodRef,
         ],
         ints: [
           0,
           0,
           0
         ],
         strings: [],
         referenceValidators: [
           (EntityRef r) => checkTypeRef(r, null, null, 'm',
                   expectedKind: ReferenceKind.method,
@@ skipping 10 matching lines @@
       return;
     }
     UnlinkedVariable variable = serializeVariableText('''
 f(x) => null;
 final u = null;
 final v = f(u);
 ''');
     _assertUnlinkedConst(variable.initializer.bodyExpr,
         isValidConst: false,
         operators: [
-          UnlinkedConstOperation.pushReference,
-          UnlinkedConstOperation.invokeMethodRef
+          UnlinkedExprOperation.pushReference,
+          UnlinkedExprOperation.invokeMethodRef
         ],
         ints: [
           0,
           1,
           0
         ],
         referenceValidators: [
           (EntityRef r) => checkTypeRef(r, null, null, 'u',
               expectedKind: ReferenceKind.topLevelPropertyAccessor),
           (EntityRef r) => checkTypeRef(r, null, null, 'f',
               expectedKind: ReferenceKind.topLevelFunction)
         ]);
   }
 
   test_expr_invokeMethodRef_withTypeParameters() {
     if (skipNonConstInitializers) {
       return;
     }
     UnlinkedVariable variable = serializeVariableText('''
 f<T, U>() => null;
 final v = f<int, String>();
 ''');
     _assertUnlinkedConst(variable.initializer.bodyExpr,
         isValidConst: false,
         operators: [
-          UnlinkedConstOperation.invokeMethodRef
+          UnlinkedExprOperation.invokeMethodRef
         ],
         ints: [
           0,
           0,
           2
         ],
         referenceValidators: [
           (EntityRef r) => checkTypeRef(r, null, null, 'f',
               expectedKind: ReferenceKind.topLevelFunction,
               numTypeParameters: 2),
           (EntityRef r) => checkTypeRef(r, 'dart:core', 'dart:core', 'int'),
           (EntityRef r) => checkTypeRef(r, 'dart:core', 'dart:core', 'String')
         ]);
   }
 
   test_expr_throwException() {
     if (skipNonConstInitializers) {
       return;
     }
     UnlinkedVariable variable = serializeVariableText('''
 final v = throw 1 + 2;
 ''');
     _assertUnlinkedConst(variable.initializer.bodyExpr,
         isValidConst: false,
         operators: [
-          UnlinkedConstOperation.pushInt,
-          UnlinkedConstOperation.pushInt,
-          UnlinkedConstOperation.add,
-          UnlinkedConstOperation.throwException,
+          UnlinkedExprOperation.pushInt,
+          UnlinkedExprOperation.pushInt,
+          UnlinkedExprOperation.add,
+          UnlinkedExprOperation.throwException,
         ],
         ints: [
           1,
           2
         ]);
   }
 
   test_expr_typeCast() {
     if (skipNonConstInitializers) {
       return;
     }
     UnlinkedVariable variable = serializeVariableText('''
 final v = 42 as num;
 ''');
     _assertUnlinkedConst(variable.initializer.bodyExpr,
         isValidConst: false,
         operators: [
-          UnlinkedConstOperation.pushInt,
-          UnlinkedConstOperation.typeCast,
+          UnlinkedExprOperation.pushInt,
+          UnlinkedExprOperation.typeCast,
         ],
         ints: [
           42
         ],
         referenceValidators: [
           (EntityRef r) => checkTypeRef(r, 'dart:core', 'dart:core', 'num',
               expectedKind: ReferenceKind.classOrEnum)
         ]);
   }
 
   test_expr_typeCheck() {
     if (skipNonConstInitializers) {
       return;
     }
     UnlinkedVariable variable = serializeVariableText('''
 final v = 42 is num;
 ''');
     _assertUnlinkedConst(variable.initializer.bodyExpr,
         isValidConst: false,
         operators: [
-          UnlinkedConstOperation.pushInt,
-          UnlinkedConstOperation.typeCheck,
+          UnlinkedExprOperation.pushInt,
+          UnlinkedExprOperation.typeCheck,
         ],
         ints: [
           42
         ],
         referenceValidators: [
           (EntityRef r) => checkTypeRef(r, 'dart:core', 'dart:core', 'num',
               expectedKind: ReferenceKind.classOrEnum)
         ]);
   }
 
@@ skipping 10 matching lines @@
     expect(unlinkedUnits[0].publicNamespace.names, hasLength(1));
     expect(unlinkedUnits[0].publicNamespace.names[0].name, 'C');
     expect(unlinkedUnits[0].publicNamespace.names[0].members, isEmpty);
   }
 
   test_field_const() {
     UnlinkedVariable variable =
         serializeClassText('class C { static const int i = 0; }').fields[0];
     expect(variable.isConst, isTrue);
     _assertUnlinkedConst(variable.initializer.bodyExpr,
-        operators: [UnlinkedConstOperation.pushInt], ints: [0]);
+        operators: [UnlinkedExprOperation.pushInt], ints: [0]);
   }
 
   test_field_documented() {
     String text = '''
 class C {
   /**
    * Docs
    */
   var v;
 }''';
     UnlinkedVariable variable = serializeClassText(text).fields[0];
     expect(variable.documentationComment, isNotNull);
     checkDocumentationComment(variable.documentationComment, text);
   }
 
   test_field_final() {
     UnlinkedVariable variable =
         serializeClassText('class C { final int i = 0; }').fields[0];
     expect(variable.isFinal, isTrue);
     _assertUnlinkedConst(variable.initializer.bodyExpr,
-        operators: [UnlinkedConstOperation.pushInt], ints: [0]);
+        operators: [UnlinkedExprOperation.pushInt], ints: [0]);
   }
 
   test_field_final_notConstExpr() {
     UnlinkedVariable variable = serializeClassText(r'''
 class C {
   final int f = 1 + m();
   static int m() => 42;
 }''').fields[0];
     expect(variable.isFinal, isTrue);
     _assertUnlinkedConst(variable.initializer.bodyExpr,
         isValidConst: false,
         operators: [
-          UnlinkedConstOperation.pushInt,
-          UnlinkedConstOperation.invokeMethodRef,
-          UnlinkedConstOperation.add,
+          UnlinkedExprOperation.pushInt,
+          UnlinkedExprOperation.invokeMethodRef,
+          UnlinkedExprOperation.add,
         ],
         ints: [
           1,
           0,
           0,
           0
         ],
         strings: [],
         referenceValidators: [
           (EntityRef r) => checkTypeRef(r, null, null, 'm',
                   expectedKind: ReferenceKind.method,
                   prefixExpectations: [
                     new _PrefixExpectation(ReferenceKind.classOrEnum, 'C')
                   ])
         ]);
   }
 
   test_field_final_typeParameter() {
     UnlinkedVariable variable = serializeClassText(r'''
 class C<T> {
   final f = <T>[];
 }''').fields[0];
     expect(variable.isFinal, isTrue);
     _assertUnlinkedConst(variable.initializer.bodyExpr,
-        operators: [UnlinkedConstOperation.makeTypedList],
+        operators: [UnlinkedExprOperation.makeTypedList],
         ints: [0],
         referenceValidators: [(EntityRef r) => checkParamTypeRef(r, 1)]);
   }
 
   test_field_formal_param_inferred_type_explicit() {
     UnlinkedClass cls = serializeClassText(
         'class C extends D { var v; C(int this.v); }'
         ' abstract class D { num get v; }',
         className: 'C');
     checkInferredTypeSlot(
@@ skipping 1013 matching lines @@
             'const a = null; @a class C = D with E; class D {} class E {}',
             className: 'C')
         .annotations);
   }
 
   test_metadata_constructor_call_named() {
     UnlinkedClass cls = serializeClassText(
         'class A { const A.named(); } @A.named() class C {}');
     expect(cls.annotations, hasLength(1));
     _assertUnlinkedConst(cls.annotations[0], operators: [
-      UnlinkedConstOperation.invokeConstructor,
+      UnlinkedExprOperation.invokeConstructor,
     ], ints: [
       0,
       0
     ], referenceValidators: [
       (EntityRef r) => checkTypeRef(r, null, null, 'named',
               expectedKind: ReferenceKind.constructor,
               prefixExpectations: [
                 new _PrefixExpectation(ReferenceKind.classOrEnum, 'A')
               ])
     ]);
   }
 
   test_metadata_constructor_call_named_prefixed() {
     addNamedSource('/foo.dart', 'class A { const A.named(); }');
     UnlinkedClass cls = serializeClassText(
         'import "foo.dart" as foo; @foo.A.named() class C {}');
     expect(cls.annotations, hasLength(1));
     _assertUnlinkedConst(cls.annotations[0], operators: [
-      UnlinkedConstOperation.invokeConstructor,
+      UnlinkedExprOperation.invokeConstructor,
     ], ints: [
       0,
       0
     ], referenceValidators: [
       (EntityRef r) => checkTypeRef(r, null, null, 'named',
               expectedKind: ReferenceKind.constructor,
               prefixExpectations: [
                 new _PrefixExpectation(ReferenceKind.classOrEnum, 'A',
                     absoluteUri: absUri('/foo.dart'), relativeUri: 'foo.dart'),
                 new _PrefixExpectation(ReferenceKind.prefix, 'foo')
               ])
     ]);
   }
 
   test_metadata_constructor_call_named_prefixed_unresolved_class() {
     addNamedSource('/foo.dart', '');
     UnlinkedClass cls = serializeClassText(
         'import "foo.dart" as foo; @foo.A.named() class C {}',
         allowErrors: true);
     expect(cls.annotations, hasLength(1));
     _assertUnlinkedConst(cls.annotations[0], operators: [
-      UnlinkedConstOperation.invokeConstructor,
+      UnlinkedExprOperation.invokeConstructor,
     ], ints: [
       0,
       0
     ], referenceValidators: [
       (EntityRef r) => checkTypeRef(r, null, null, 'named',
               expectedKind: ReferenceKind.unresolved,
               prefixExpectations: [
                 new _PrefixExpectation(ReferenceKind.unresolved, 'A'),
                 new _PrefixExpectation(ReferenceKind.prefix, 'foo')
               ])
     ]);
   }
 
   test_metadata_constructor_call_named_prefixed_unresolved_constructor() {
     addNamedSource('/foo.dart', 'class A {}');
     UnlinkedClass cls = serializeClassText(
         'import "foo.dart" as foo; @foo.A.named() class C {}',
         allowErrors: true);
     expect(cls.annotations, hasLength(1));
     _assertUnlinkedConst(cls.annotations[0], operators: [
-      UnlinkedConstOperation.invokeConstructor,
+      UnlinkedExprOperation.invokeConstructor,
     ], ints: [
       0,
       0
     ], referenceValidators: [
       (EntityRef r) => checkTypeRef(r, null, null, 'named',
               expectedKind: ReferenceKind.unresolved,
               prefixExpectations: [
                 new _PrefixExpectation(ReferenceKind.classOrEnum, 'A',
                     absoluteUri: absUri('/foo.dart'), relativeUri: 'foo.dart'),
                 new _PrefixExpectation(ReferenceKind.prefix, 'foo')
               ])
     ]);
   }
 
   test_metadata_constructor_call_named_unresolved_class() {
     UnlinkedClass cls =
         serializeClassText('@A.named() class C {}', allowErrors: true);
     expect(cls.annotations, hasLength(1));
     _assertUnlinkedConst(cls.annotations[0], operators: [
-      UnlinkedConstOperation.invokeConstructor,
+      UnlinkedExprOperation.invokeConstructor,
     ], ints: [
       0,
       0
     ], referenceValidators: [
       (EntityRef r) => checkTypeRef(r, null, null, 'named',
               expectedKind: ReferenceKind.unresolved,
               prefixExpectations: [
                 new _PrefixExpectation(ReferenceKind.unresolved, 'A')
               ])
     ]);
   }
 
   test_metadata_constructor_call_named_unresolved_constructor() {
     UnlinkedClass cls = serializeClassText('class A {} @A.named() class C {}',
         allowErrors: true);
     expect(cls.annotations, hasLength(1));
     _assertUnlinkedConst(cls.annotations[0], operators: [
-      UnlinkedConstOperation.invokeConstructor,
+      UnlinkedExprOperation.invokeConstructor,
     ], ints: [
       0,
       0
     ], referenceValidators: [
       (EntityRef r) => checkTypeRef(r, null, null, 'named',
               expectedKind: ReferenceKind.unresolved,
               prefixExpectations: [
                 new _PrefixExpectation(ReferenceKind.classOrEnum, 'A')
               ])
     ]);
   }
 
   test_metadata_constructor_call_unnamed() {
     UnlinkedClass cls =
         serializeClassText('class A { const A(); } @A() class C {}');
     expect(cls.annotations, hasLength(1));
     _assertUnlinkedConst(cls.annotations[0], operators: [
-      UnlinkedConstOperation.invokeConstructor,
+      UnlinkedExprOperation.invokeConstructor,
     ], ints: [
       0,
       0
     ], referenceValidators: [
       (EntityRef r) => checkTypeRef(r, null, null, 'A',
           expectedKind: ReferenceKind.classOrEnum)
     ]);
   }
 
   test_metadata_constructor_call_unnamed_prefixed() {
     addNamedSource('/foo.dart', 'class A { const A(); }');
     UnlinkedClass cls =
         serializeClassText('import "foo.dart" as foo; @foo.A() class C {}');
     expect(cls.annotations, hasLength(1));
     _assertUnlinkedConst(cls.annotations[0], operators: [
-      UnlinkedConstOperation.invokeConstructor,
+      UnlinkedExprOperation.invokeConstructor,
     ], ints: [
       0,
       0
     ], referenceValidators: [
       (EntityRef r) => checkTypeRef(r, absUri('/foo.dart'), 'foo.dart', 'A',
           expectedKind: ReferenceKind.classOrEnum, expectedPrefix: 'foo')
     ]);
   }
 
   test_metadata_constructor_call_unnamed_prefixed_unresolved() {
     addNamedSource('/foo.dart', '');
     UnlinkedClass cls = serializeClassText(
         'import "foo.dart" as foo; @foo.A() class C {}',
         allowErrors: true);
     expect(cls.annotations, hasLength(1));
     _assertUnlinkedConst(cls.annotations[0], operators: [
-      UnlinkedConstOperation.invokeConstructor,
+      UnlinkedExprOperation.invokeConstructor,
     ], ints: [
       0,
       0
     ], referenceValidators: [
       (EntityRef r) => checkTypeRef(r, null, null, 'A',
           expectedKind: ReferenceKind.unresolved, expectedPrefix: 'foo')
     ]);
   }
 
   test_metadata_constructor_call_unnamed_unresolved() {
     UnlinkedClass cls =
         serializeClassText('@A() class C {}', allowErrors: true);
     expect(cls.annotations, hasLength(1));
     _assertUnlinkedConst(cls.annotations[0], operators: [
-      UnlinkedConstOperation.invokeConstructor,
+      UnlinkedExprOperation.invokeConstructor,
     ], ints: [
       0,
       0
     ], referenceValidators: [
       (EntityRef r) => checkTypeRef(r, null, null, 'A',
           expectedKind: ReferenceKind.unresolved)
     ]);
   }
 
   test_metadata_constructor_call_with_args() {
     UnlinkedClass cls =
         serializeClassText('class A { const A(x); } @A(null) class C {}');
     expect(cls.annotations, hasLength(1));
     _assertUnlinkedConst(cls.annotations[0], operators: [
-      UnlinkedConstOperation.pushNull,
-      UnlinkedConstOperation.invokeConstructor,
+      UnlinkedExprOperation.pushNull,
+      UnlinkedExprOperation.invokeConstructor,
     ], ints: [
       0,
       1
     ], referenceValidators: [
       (EntityRef r) => checkTypeRef(r, null, null, 'A',
           expectedKind: ReferenceKind.classOrEnum)
     ]);
   }
 
   test_metadata_constructorDeclaration_named() {
@@ skipping 105 matching lines @@
   test_metadata_methodDeclaration_setter() {
     checkAnnotationA(
         serializeClassText('const a = null; class C { @a set m(value) {} }')
             .executables[0]
             .annotations);
   }
 
   test_metadata_multiple_annotations() {
     UnlinkedClass cls =
         serializeClassText('const a = null, b = null; @a @b class C {}');
-    List<UnlinkedConst> annotations = cls.annotations;
+    List<UnlinkedExpr> annotations = cls.annotations;
     expect(annotations, hasLength(2));
     _assertUnlinkedConst(annotations[0], operators: [
-      UnlinkedConstOperation.pushReference
+      UnlinkedExprOperation.pushReference
     ], referenceValidators: [
       (EntityRef r) => checkTypeRef(r, null, null, 'a',
           expectedKind: ReferenceKind.topLevelPropertyAccessor)
     ]);
     _assertUnlinkedConst(annotations[1], operators: [
-      UnlinkedConstOperation.pushReference
+      UnlinkedExprOperation.pushReference
     ], referenceValidators: [
       (EntityRef r) => checkTypeRef(r, null, null, 'b',
           expectedKind: ReferenceKind.topLevelPropertyAccessor)
     ]);
   }
 
   test_metadata_partDirective() {
     addNamedSource('/foo.dart', 'part of L;');
     serializeLibraryText('library L; @a part "foo.dart"; const a = null;');
     checkAnnotationA(unlinkedUnits[0].parts[0].annotations);
   }
 
   test_metadata_prefixed_variable() {
     addNamedSource('/a.dart', 'const b = null;');
     UnlinkedClass cls =
         serializeClassText('import "a.dart" as a; @a.b class C {}');
     expect(cls.annotations, hasLength(1));
     _assertUnlinkedConst(cls.annotations[0], operators: [
-      UnlinkedConstOperation.pushReference
+      UnlinkedExprOperation.pushReference
     ], referenceValidators: [
       (EntityRef r) => checkTypeRef(r, absUri('/a.dart'), 'a.dart', 'b',
           expectedKind: ReferenceKind.topLevelPropertyAccessor,
           expectedPrefix: 'a')
     ]);
   }
 
   test_metadata_prefixed_variable_unresolved() {
     addNamedSource('/a.dart', '');
     UnlinkedClass cls = serializeClassText(
         'import "a.dart" as a; @a.b class C {}',
         allowErrors: true);
     expect(cls.annotations, hasLength(1));
     _assertUnlinkedConst(cls.annotations[0], operators: [
-      UnlinkedConstOperation.pushReference
+      UnlinkedExprOperation.pushReference
     ], referenceValidators: [
       (EntityRef r) => checkTypeRef(r, null, null, 'b',
           expectedKind: ReferenceKind.unresolved, expectedPrefix: 'a')
     ]);
   }
 
   test_metadata_simpleFormalParameter() {
     checkAnnotationA(serializeExecutableText('const a = null; f(@a x) {}')
         .parameters[0]
         .annotations);
@@ skipping 34 matching lines @@
   test_metadata_typeParameter_ofTypedef() {
     checkAnnotationA(serializeTypedefText('const a = null; typedef F<@a T>();')
         .typeParameters[0]
         .annotations);
   }
 
   test_metadata_variable_unresolved() {
     UnlinkedClass cls = serializeClassText('@a class C {}', allowErrors: true);
     expect(cls.annotations, hasLength(1));
     _assertUnlinkedConst(cls.annotations[0], operators: [
-      UnlinkedConstOperation.pushReference
+      UnlinkedExprOperation.pushReference
     ], referenceValidators: [
       (EntityRef r) => checkTypeRef(r, null, null, 'a',
           expectedKind: ReferenceKind.unresolved)
     ]);
   }
 
   test_method_documented() {
     String text = '''
 class C {
   /**
@@ skipping 1124 matching lines @@
     if (skipNonConstInitializers) {
       return;
     }
     UnlinkedVariable variable = serializeVariableText('''
 int a = 0;
 final v = $expr;
     ''');
     _assertUnlinkedConst(variable.initializer.bodyExpr,
         isValidConst: false,
         operators: [
-          UnlinkedConstOperation.pushInt,
-          UnlinkedConstOperation.pushInt,
-          UnlinkedConstOperation.add,
-          UnlinkedConstOperation.assignToRef,
-          UnlinkedConstOperation.pushInt,
-          UnlinkedConstOperation.add,
+          UnlinkedExprOperation.pushInt,
+          UnlinkedExprOperation.pushInt,
+          UnlinkedExprOperation.add,
+          UnlinkedExprOperation.assignToRef,
+          UnlinkedExprOperation.pushInt,
+          UnlinkedExprOperation.add,
         ],
         assignmentOperators: [
           expectedAssignOperator
         ],
         ints: [
           1,
           2,
           3
         ],
         strings: [],
@@ skipping 41 matching lines @@
     if (skipNonConstInitializers) {
       return;
     }
     UnlinkedVariable variable = serializeVariableText('''
 int a = 0;
 final v = $expr;
 ''');
     _assertUnlinkedConst(variable.initializer.bodyExpr,
         isValidConst: false,
         operators: [
-          UnlinkedConstOperation.assignToRef,
-          UnlinkedConstOperation.pushInt,
-          UnlinkedConstOperation.add,
+          UnlinkedExprOperation.assignToRef,
+          UnlinkedExprOperation.pushInt,
+          UnlinkedExprOperation.add,
         ],
         assignmentOperators: [
           expectedAssignmentOperator
         ],
         ints: [
           2
         ],
         strings: [],
         referenceValidators: [
           (EntityRef r) => checkTypeRef(r, null, null, 'a',
               expectedKind: ReferenceKind.topLevelPropertyAccessor)
         ]);
   }
 
   /**
    * TODO(scheglov) rename "Const" to "Expr" everywhere
    */
-  void _assertUnlinkedConst(UnlinkedConst constExpr,
+  void _assertUnlinkedConst(UnlinkedExpr constExpr,
       {bool isValidConst: true,
-      List<UnlinkedConstOperation> operators: const <UnlinkedConstOperation>[],
+      List<UnlinkedExprOperation> operators: const <UnlinkedExprOperation>[],
       List<UnlinkedExprAssignOperator> assignmentOperators:
           const <UnlinkedExprAssignOperator>[],
       List<int> ints: const <int>[],
       List<double> doubles: const <double>[],
       List<String> strings: const <String>[],
       List<_EntityRefValidator> referenceValidators:
           const <_EntityRefValidator>[]}) {
     expect(constExpr, isNotNull);
     expect(constExpr.isValidConst, isValidConst);
     expect(constExpr.operations, operators);
@@ skipping 23 matching lines @@
 class _PrefixExpectation {
   final ReferenceKind kind;
   final String name;
   final String absoluteUri;
   final String relativeUri;
   final int numTypeParameters;
 
   _PrefixExpectation(this.kind, this.name,
       {this.absoluteUri, this.relativeUri, this.numTypeParameters: 0});
 }