Migrate UnlinkedVariable.constExpr to UnlinkedExecutable.bodyExpr.

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/dart/element/element.dart';
 import 'package:analyzer/src/dart/scanner/reader.dart';
@@ skipping 1466 matching lines @@
     checkInferredTypeSlot(executable.localFunctions[0].inferredReturnTypeSlot,
         absUri('/b.dart'), 'b.dart', 'D',
         onlyInStrongMode: false);
     if (!skipFullyLinkedData) {
       checkHasDependency(absUri('/b.dart'), 'b.dart', fullyLinked: true);
     }
   }
 
   test_constExpr_binary_add() {
     UnlinkedVariable variable = serializeVariableText('const v = 1 + 2;');
-    _assertUnlinkedConst(variable.constExpr, operators: [
+    _assertUnlinkedConst(variable.initializer.bodyExpr, operators: [
       UnlinkedConstOperation.pushInt,
       UnlinkedConstOperation.pushInt,
       UnlinkedConstOperation.add
     ], ints: [
       1,
       2
     ]);
   }
 
   test_constExpr_binary_and() {
     UnlinkedVariable variable =
         serializeVariableText('const v = true && false;');
-    _assertUnlinkedConst(variable.constExpr, operators: [
+    _assertUnlinkedConst(variable.initializer.bodyExpr, operators: [
       UnlinkedConstOperation.pushTrue,
       UnlinkedConstOperation.pushFalse,
       UnlinkedConstOperation.and
     ]);
   }
 
   test_constExpr_binary_bitAnd() {
     UnlinkedVariable variable = serializeVariableText('const v = 1 & 2;');
-    _assertUnlinkedConst(variable.constExpr, operators: [
+    _assertUnlinkedConst(variable.initializer.bodyExpr, operators: [
       UnlinkedConstOperation.pushInt,
       UnlinkedConstOperation.pushInt,
       UnlinkedConstOperation.bitAnd
     ], ints: [
       1,
       2
     ]);
   }
 
   test_constExpr_binary_bitOr() {
     UnlinkedVariable variable = serializeVariableText('const v = 1 | 2;');
-    _assertUnlinkedConst(variable.constExpr, operators: [
+    _assertUnlinkedConst(variable.initializer.bodyExpr, operators: [
       UnlinkedConstOperation.pushInt,
       UnlinkedConstOperation.pushInt,
       UnlinkedConstOperation.bitOr
     ], ints: [
       1,
       2
     ]);
   }
 
   test_constExpr_binary_bitShiftLeft() {
     UnlinkedVariable variable = serializeVariableText('const v = 1 << 2;');
-    _assertUnlinkedConst(variable.constExpr, operators: [
+    _assertUnlinkedConst(variable.initializer.bodyExpr, operators: [
       UnlinkedConstOperation.pushInt,
       UnlinkedConstOperation.pushInt,
       UnlinkedConstOperation.bitShiftLeft
     ], ints: [
       1,
       2
     ]);
   }
 
   test_constExpr_binary_bitShiftRight() {
     UnlinkedVariable variable = serializeVariableText('const v = 1 >> 2;');
-    _assertUnlinkedConst(variable.constExpr, operators: [
+    _assertUnlinkedConst(variable.initializer.bodyExpr, operators: [
       UnlinkedConstOperation.pushInt,
       UnlinkedConstOperation.pushInt,
       UnlinkedConstOperation.bitShiftRight
     ], ints: [
       1,
       2
     ]);
   }
 
   test_constExpr_binary_bitXor() {
     UnlinkedVariable variable = serializeVariableText('const v = 1 ^ 2;');
-    _assertUnlinkedConst(variable.constExpr, operators: [
+    _assertUnlinkedConst(variable.initializer.bodyExpr, operators: [
       UnlinkedConstOperation.pushInt,
       UnlinkedConstOperation.pushInt,
       UnlinkedConstOperation.bitXor
     ], ints: [
       1,
       2
     ]);
   }
 
   test_constExpr_binary_divide() {
     UnlinkedVariable variable = serializeVariableText('const v = 1 / 2;');
-    _assertUnlinkedConst(variable.constExpr, operators: [
+    _assertUnlinkedConst(variable.initializer.bodyExpr, operators: [
       UnlinkedConstOperation.pushInt,
       UnlinkedConstOperation.pushInt,
       UnlinkedConstOperation.divide
     ], ints: [
       1,
       2
     ]);
   }
 
   test_constExpr_binary_equal() {
     UnlinkedVariable variable = serializeVariableText('const v = 1 == 2;');
-    _assertUnlinkedConst(variable.constExpr, operators: [
+    _assertUnlinkedConst(variable.initializer.bodyExpr, operators: [
       UnlinkedConstOperation.pushInt,
       UnlinkedConstOperation.pushInt,
       UnlinkedConstOperation.equal
     ], ints: [
       1,
       2
     ]);
   }
 
   test_constExpr_binary_equal_not() {
     UnlinkedVariable variable = serializeVariableText('const v = 1 != 2;');
-    _assertUnlinkedConst(variable.constExpr, operators: [
+    _assertUnlinkedConst(variable.initializer.bodyExpr, operators: [
       UnlinkedConstOperation.pushInt,
       UnlinkedConstOperation.pushInt,
       UnlinkedConstOperation.notEqual
     ], ints: [
       1,
       2
     ]);
   }
 
   test_constExpr_binary_floorDivide() {
     UnlinkedVariable variable = serializeVariableText('const v = 1 ~/ 2;');
-    _assertUnlinkedConst(variable.constExpr, operators: [
+    _assertUnlinkedConst(variable.initializer.bodyExpr, operators: [
       UnlinkedConstOperation.pushInt,
       UnlinkedConstOperation.pushInt,
       UnlinkedConstOperation.floorDivide
     ], ints: [
       1,
       2
     ]);
   }
 
   test_constExpr_binary_greater() {
     UnlinkedVariable variable = serializeVariableText('const v = 1 > 2;');
-    _assertUnlinkedConst(variable.constExpr, operators: [
+    _assertUnlinkedConst(variable.initializer.bodyExpr, operators: [
       UnlinkedConstOperation.pushInt,
       UnlinkedConstOperation.pushInt,
       UnlinkedConstOperation.greater
     ], ints: [
       1,
       2
     ]);
   }
 
   test_constExpr_binary_greaterEqual() {
     UnlinkedVariable variable = serializeVariableText('const v = 1 >= 2;');
-    _assertUnlinkedConst(variable.constExpr, operators: [
+    _assertUnlinkedConst(variable.initializer.bodyExpr, operators: [
       UnlinkedConstOperation.pushInt,
       UnlinkedConstOperation.pushInt,
       UnlinkedConstOperation.greaterEqual
     ], ints: [
       1,
       2
     ]);
   }
 
   test_constExpr_binary_less() {
     UnlinkedVariable variable = serializeVariableText('const v = 1 < 2;');
-    _assertUnlinkedConst(variable.constExpr, operators: [
+    _assertUnlinkedConst(variable.initializer.bodyExpr, operators: [
       UnlinkedConstOperation.pushInt,
       UnlinkedConstOperation.pushInt,
       UnlinkedConstOperation.less
     ], ints: [
       1,
       2
     ]);
   }
 
   test_constExpr_binary_lessEqual() {
     UnlinkedVariable variable = serializeVariableText('const v = 1 <= 2;');
-    _assertUnlinkedConst(variable.constExpr, operators: [
+    _assertUnlinkedConst(variable.initializer.bodyExpr, operators: [
       UnlinkedConstOperation.pushInt,
       UnlinkedConstOperation.pushInt,
       UnlinkedConstOperation.lessEqual
     ], ints: [
       1,
       2
     ]);
   }
 
   test_constExpr_binary_modulo() {
     UnlinkedVariable variable = serializeVariableText('const v = 1 % 2;');
-    _assertUnlinkedConst(variable.constExpr, operators: [
+    _assertUnlinkedConst(variable.initializer.bodyExpr, operators: [
       UnlinkedConstOperation.pushInt,
       UnlinkedConstOperation.pushInt,
       UnlinkedConstOperation.modulo
     ], ints: [
       1,
       2
     ]);
   }
 
   test_constExpr_binary_multiply() {
     UnlinkedVariable variable = serializeVariableText('const v = 1 * 2;');
-    _assertUnlinkedConst(variable.constExpr, operators: [
+    _assertUnlinkedConst(variable.initializer.bodyExpr, operators: [
       UnlinkedConstOperation.pushInt,
       UnlinkedConstOperation.pushInt,
       UnlinkedConstOperation.multiply
     ], ints: [
       1,
       2
     ]);
   }
 
   test_constExpr_binary_or() {
     UnlinkedVariable variable =
         serializeVariableText('const v = false || true;');
-    _assertUnlinkedConst(variable.constExpr, operators: [
+    _assertUnlinkedConst(variable.initializer.bodyExpr, operators: [
       UnlinkedConstOperation.pushFalse,
       UnlinkedConstOperation.pushTrue,
       UnlinkedConstOperation.or
     ]);
   }
 
   test_constExpr_binary_subtract() {
     UnlinkedVariable variable = serializeVariableText('const v = 1 - 2;');
-    _assertUnlinkedConst(variable.constExpr, operators: [
+    _assertUnlinkedConst(variable.initializer.bodyExpr, operators: [
       UnlinkedConstOperation.pushInt,
       UnlinkedConstOperation.pushInt,
       UnlinkedConstOperation.subtract
     ], ints: [
       1,
       2
     ]);
   }
 
   test_constExpr_classMember_shadows_typeParam() {
@@ skipping 19 matching lines @@
                   prefixExpectations: [
                     new _PrefixExpectation(ReferenceKind.classOrEnum, 'C',
                         numTypeParameters: 1)
                   ])
         ]);
   }
 
   test_constExpr_conditional() {
     UnlinkedVariable variable =
         serializeVariableText('const v = true ? 1 : 2;', allowErrors: true);
-    _assertUnlinkedConst(variable.constExpr, operators: [
+    _assertUnlinkedConst(variable.initializer.bodyExpr, operators: [
       UnlinkedConstOperation.pushTrue,
       UnlinkedConstOperation.pushInt,
       UnlinkedConstOperation.pushInt,
       UnlinkedConstOperation.conditional
     ], ints: [
       1,
       2
     ]);
   }
 
@@ skipping 23 matching lines @@
   }
 
   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.constExpr, isValidConst: false, operators: [
-      UnlinkedConstOperation.pushInt,
-      UnlinkedConstOperation.pushLocalFunctionReference,
-      UnlinkedConstOperation.invokeMethodRef
-    ], ints: [
-      5,
-      0,
-      0,
-      0,
-      2
-    ], referenceValidators: [
-      (EntityRef r) => checkTypeRef(r, null, null, 'foo',
-          expectedKind: ReferenceKind.topLevelFunction)
-    ]);
+    _assertUnlinkedConst(variable.initializer.bodyExpr,
+        isValidConst: false,
+        operators: [
+          UnlinkedConstOperation.pushInt,
+          UnlinkedConstOperation.pushLocalFunctionReference,
+          UnlinkedConstOperation.invokeMethodRef
+        ],
+        ints: [
+          5,
+          0,
+          0,
+          0,
+          2
+        ],
+        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.constExpr, isValidConst: false, operators: [
-      UnlinkedConstOperation.pushInt,
-      UnlinkedConstOperation.pushLocalFunctionReference,
-      UnlinkedConstOperation.pushLocalFunctionReference,
-      UnlinkedConstOperation.invokeMethodRef
-    ], ints: [
-      5,
-      0,
-      0,
-      0,
-      1,
-      0,
-      3
-    ], referenceValidators: [
-      (EntityRef r) => checkTypeRef(r, null, null, 'foo',
-          expectedKind: ReferenceKind.topLevelFunction)
-    ]);
+    _assertUnlinkedConst(variable.initializer.bodyExpr,
+        isValidConst: false,
+        operators: [
+          UnlinkedConstOperation.pushInt,
+          UnlinkedConstOperation.pushLocalFunctionReference,
+          UnlinkedConstOperation.pushLocalFunctionReference,
+          UnlinkedConstOperation.invokeMethodRef
+        ],
+        ints: [
+          5,
+          0,
+          0,
+          0,
+          1,
+          0,
+          3
+        ],
+        referenceValidators: [
+          (EntityRef r) => checkTypeRef(r, null, null, 'foo',
+              expectedKind: ReferenceKind.topLevelFunction)
+        ]);
   }
 
   test_constExpr_functionExpression_inConstructorInitializers() {
     // Even though function expressions are not allowed in constant
     // declarations, they might occur due to erroneous code, so make sure they
     // function correctly.
     UnlinkedExecutable executable = serializeClassText('''
 class C {
   final x, y;
   const C() : x = (() => 42), y = (() => 43);
@@ skipping 10 matching lines @@
         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.constExpr, operators: [
+    _assertUnlinkedConst(variable.initializer.bodyExpr, operators: [
       UnlinkedConstOperation.invokeConstructor,
     ], ints: [
       0,
       0
     ], referenceValidators: [
       (EntityRef r) {
         checkTypeRef(r, null, null, 'named',
             expectedKind: ReferenceKind.constructor,
             prefixExpectations: [
               new _PrefixExpectation(ReferenceKind.classOrEnum, 'C',
@@ skipping 11 matching lines @@
         '/a.dart',
         '''
 class C<K, V> {
   const C.named();
 }
 ''');
     UnlinkedVariable variable = serializeVariableText('''
 import 'a.dart';
 const v = const C<int, String>.named();
 ''');
-    _assertUnlinkedConst(variable.constExpr, operators: [
+    _assertUnlinkedConst(variable.initializer.bodyExpr, operators: [
       UnlinkedConstOperation.invokeConstructor,
     ], ints: [
       0,
       0
     ], referenceValidators: [
       (EntityRef r) {
         checkTypeRef(r, null, null, 'named',
             expectedKind: ReferenceKind.constructor,
             prefixExpectations: [
               new _PrefixExpectation(ReferenceKind.classOrEnum, 'C',
@@ skipping 13 matching lines @@
         '/a.dart',
         '''
 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.constExpr, operators: [
+    _assertUnlinkedConst(variable.initializer.bodyExpr, operators: [
       UnlinkedConstOperation.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.constExpr, operators: [
+    _assertUnlinkedConst(variable.initializer.bodyExpr, operators: [
       UnlinkedConstOperation.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.constExpr, operators: [
+    _assertUnlinkedConst(variable.initializer.bodyExpr, operators: [
       UnlinkedConstOperation.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.constExpr, operators: [
+    _assertUnlinkedConst(variable.initializer.bodyExpr, operators: [
       UnlinkedConstOperation.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.constExpr, operators: [
+    _assertUnlinkedConst(variable.initializer.bodyExpr, operators: [
       UnlinkedConstOperation.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.constExpr, operators: [
+    _assertUnlinkedConst(variable.initializer.bodyExpr, operators: [
       UnlinkedConstOperation.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.constExpr, operators: [
+    _assertUnlinkedConst(variable.initializer.bodyExpr, operators: [
       UnlinkedConstOperation.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.constExpr, operators: [
+    _assertUnlinkedConst(variable.initializer.bodyExpr, operators: [
       UnlinkedConstOperation.pushInt,
       UnlinkedConstOperation.pushInt,
       UnlinkedConstOperation.pushDouble,
       UnlinkedConstOperation.pushString,
       UnlinkedConstOperation.pushInt,
       UnlinkedConstOperation.pushString,
       UnlinkedConstOperation.pushInt,
       UnlinkedConstOperation.invokeConstructor,
     ], ints: [
       11,
@@ skipping 21 matching lines @@
         '/a.dart',
         '''
 class C {
   const C();
 }
 ''');
     UnlinkedVariable variable = serializeVariableText('''
 import 'a.dart';
 const v = const C();
 ''');
-    _assertUnlinkedConst(variable.constExpr, operators: [
+    _assertUnlinkedConst(variable.initializer.bodyExpr, operators: [
       UnlinkedConstOperation.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.constExpr, operators: [
+    _assertUnlinkedConst(variable.initializer.bodyExpr, operators: [
       UnlinkedConstOperation.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.constExpr, operators: [
+    _assertUnlinkedConst(variable.initializer.bodyExpr, operators: [
       UnlinkedConstOperation.invokeConstructor,
     ], ints: [
       0,
       0
     ], referenceValidators: [
       (EntityRef r) => checkTypeRef(r, null, null, 'foo',
               expectedKind: ReferenceKind.unresolved,
               checkAstDerivedDataOverride: true,
               prefixExpectations: [
                 new _PrefixExpectation(ReferenceKind.classOrEnum, 'C')
               ])
     ]);
   }
 
   test_constExpr_invokeConstructor_unresolved_named2() {
     UnlinkedVariable variable = serializeVariableText(
         '''
 const v = const C.foo();
 ''',
         allowErrors: true);
-    _assertUnlinkedConst(variable.constExpr, operators: [
+    _assertUnlinkedConst(variable.initializer.bodyExpr, operators: [
       UnlinkedConstOperation.invokeConstructor,
     ], ints: [
       0,
       0
     ], referenceValidators: [
       (EntityRef r) => checkTypeRef(r, null, null, 'foo',
               expectedKind: ReferenceKind.unresolved,
               checkAstDerivedDataOverride: true,
               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.constExpr, operators: [
+    _assertUnlinkedConst(variable.initializer.bodyExpr, operators: [
       UnlinkedConstOperation.invokeConstructor,
     ], ints: [
       0,
       0
     ], referenceValidators: [
       (EntityRef r) => checkTypeRef(r, null, null, 'foo',
               expectedKind: ReferenceKind.unresolved,
               checkAstDerivedDataOverride: true,
               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.constExpr, operators: [
+    _assertUnlinkedConst(variable.initializer.bodyExpr, operators: [
       UnlinkedConstOperation.invokeConstructor,
     ], ints: [
       0,
       0
     ], referenceValidators: [
       (EntityRef r) => checkTypeRef(r, null, null, 'foo',
               expectedKind: ReferenceKind.unresolved,
               checkAstDerivedDataOverride: true,
               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.constExpr, operators: [
+    _assertUnlinkedConst(variable.initializer.bodyExpr, operators: [
       UnlinkedConstOperation.invokeConstructor,
     ], ints: [
       0,
       0
     ], referenceValidators: [
       (EntityRef r) => checkTypeRef(r, null, null, 'Foo',
           expectedKind: ReferenceKind.unresolved,
           checkAstDerivedDataOverride: true)
     ]);
   }
 
   test_constExpr_invokeMethodRef_identical() {
     UnlinkedVariable variable =
         serializeVariableText('const v = identical(42, null);');
-    _assertUnlinkedConst(variable.constExpr, operators: [
+    _assertUnlinkedConst(variable.initializer.bodyExpr, operators: [
       UnlinkedConstOperation.pushInt,
       UnlinkedConstOperation.pushNull,
       UnlinkedConstOperation.invokeMethodRef
     ], ints: [
       42,
       0,
       2
     ], 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.constExpr, operators: [
+    _assertUnlinkedConst(variable.initializer.bodyExpr, operators: [
       UnlinkedConstOperation.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.constExpr, operators: [
+    _assertUnlinkedConst(variable.initializer.bodyExpr, operators: [
       UnlinkedConstOperation.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.constExpr, operators: [
+    _assertUnlinkedConst(variable.initializer.bodyExpr, operators: [
       UnlinkedConstOperation.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.constExpr, operators: [
+    _assertUnlinkedConst(variable.initializer.bodyExpr, operators: [
       UnlinkedConstOperation.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.constExpr, operators: [
+    _assertUnlinkedConst(variable.initializer.bodyExpr, operators: [
       UnlinkedConstOperation.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.constExpr, operators: [
+    _assertUnlinkedConst(variable.initializer.bodyExpr, operators: [
       UnlinkedConstOperation.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.constExpr, operators: [
+    _assertUnlinkedConst(variable.initializer.bodyExpr, operators: [
       UnlinkedConstOperation.pushString,
       UnlinkedConstOperation.pushString,
       UnlinkedConstOperation.add,
       UnlinkedConstOperation.extractProperty
     ], strings: [
       'abc',
       'edf',
       'length'
     ]);
   }
 
   test_constExpr_length_parenthesizedStringTarget() {
     UnlinkedVariable variable =
         serializeVariableText('const v = ("abc").length;');
-    _assertUnlinkedConst(variable.constExpr, operators: [
+    _assertUnlinkedConst(variable.initializer.bodyExpr, operators: [
       UnlinkedConstOperation.pushString,
       UnlinkedConstOperation.extractProperty
     ], strings: [
       'abc',
       'length'
     ]);
   }
 
   test_constExpr_length_stringLiteralTarget() {
     UnlinkedVariable variable =
         serializeVariableText('const v = "abc".length;');
-    _assertUnlinkedConst(variable.constExpr, operators: [
+    _assertUnlinkedConst(variable.initializer.bodyExpr, operators: [
       UnlinkedConstOperation.pushString,
       UnlinkedConstOperation.extractProperty
     ], strings: [
       'abc',
       'length'
     ]);
   }
 
   test_constExpr_makeSymbol() {
     UnlinkedVariable variable = serializeVariableText('const v = #a.bb.ccc;');
-    _assertUnlinkedConst(variable.constExpr,
+    _assertUnlinkedConst(variable.initializer.bodyExpr,
         operators: [UnlinkedConstOperation.makeSymbol], strings: ['a.bb.ccc']);
   }
 
   test_constExpr_makeTypedList() {
     UnlinkedVariable variable =
         serializeVariableText('const v = const <int>[11, 22, 33];');
-    _assertUnlinkedConst(variable.constExpr, operators: [
+    _assertUnlinkedConst(variable.initializer.bodyExpr, operators: [
       UnlinkedConstOperation.pushInt,
       UnlinkedConstOperation.pushInt,
       UnlinkedConstOperation.pushInt,
       UnlinkedConstOperation.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.constExpr, operators: [
+    _assertUnlinkedConst(variable.initializer.bodyExpr, operators: [
       UnlinkedConstOperation.pushInt,
       UnlinkedConstOperation.pushInt,
       UnlinkedConstOperation.pushInt,
       UnlinkedConstOperation.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.constExpr, operators: [
+    _assertUnlinkedConst(variable.initializer.bodyExpr, operators: [
       UnlinkedConstOperation.pushInt,
       UnlinkedConstOperation.pushString,
       UnlinkedConstOperation.pushInt,
       UnlinkedConstOperation.pushString,
       UnlinkedConstOperation.pushInt,
       UnlinkedConstOperation.pushString,
       UnlinkedConstOperation.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.constExpr, operators: [
+    _assertUnlinkedConst(variable.initializer.bodyExpr, operators: [
       UnlinkedConstOperation.pushInt,
       UnlinkedConstOperation.pushString,
       UnlinkedConstOperation.pushInt,
       UnlinkedConstOperation.pushString,
       UnlinkedConstOperation.pushInt,
       UnlinkedConstOperation.pushString,
       UnlinkedConstOperation.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.constExpr, operators: [
+    _assertUnlinkedConst(variable.initializer.bodyExpr, operators: [
       UnlinkedConstOperation.pushInt,
       UnlinkedConstOperation.pushInt,
       UnlinkedConstOperation.pushInt,
       UnlinkedConstOperation.makeUntypedList
     ], ints: [
       11,
       22,
       33,
       3
     ]);
   }
 
   test_constExpr_makeUntypedMap() {
     UnlinkedVariable variable = serializeVariableText(
         'const v = const {11: "aaa", 22: "bbb", 33: "ccc"};');
-    _assertUnlinkedConst(variable.constExpr, operators: [
+    _assertUnlinkedConst(variable.initializer.bodyExpr, operators: [
       UnlinkedConstOperation.pushInt,
       UnlinkedConstOperation.pushString,
       UnlinkedConstOperation.pushInt,
       UnlinkedConstOperation.pushString,
       UnlinkedConstOperation.pushInt,
       UnlinkedConstOperation.pushString,
       UnlinkedConstOperation.makeUntypedMap
     ], ints: [
       11,
       22,
       33,
       3
     ], strings: [
       'aaa',
       'bbb',
       'ccc'
     ]);
   }
 
   test_constExpr_parenthesized() {
     UnlinkedVariable variable = serializeVariableText('const v = (1 + 2) * 3;');
-    _assertUnlinkedConst(variable.constExpr, operators: [
+    _assertUnlinkedConst(variable.initializer.bodyExpr, operators: [
       UnlinkedConstOperation.pushInt,
       UnlinkedConstOperation.pushInt,
       UnlinkedConstOperation.add,
       UnlinkedConstOperation.pushInt,
       UnlinkedConstOperation.multiply,
     ], ints: [
       1,
       2,
       3
     ]);
   }
 
   test_constExpr_prefix_complement() {
     UnlinkedVariable variable = serializeVariableText('const v = ~2;');
-    _assertUnlinkedConst(variable.constExpr, operators: [
+    _assertUnlinkedConst(variable.initializer.bodyExpr, operators: [
       UnlinkedConstOperation.pushInt,
       UnlinkedConstOperation.complement
     ], ints: [
       2
     ]);
   }
 
   test_constExpr_prefix_negate() {
     UnlinkedVariable variable = serializeVariableText('const v = -(2);');
-    _assertUnlinkedConst(variable.constExpr, operators: [
+    _assertUnlinkedConst(variable.initializer.bodyExpr, operators: [
       UnlinkedConstOperation.pushInt,
       UnlinkedConstOperation.negate
     ], ints: [
       2
     ]);
   }
 
   test_constExpr_prefix_not() {
     UnlinkedVariable variable = serializeVariableText('const v = !true;');
-    _assertUnlinkedConst(variable.constExpr, operators: [
+    _assertUnlinkedConst(variable.initializer.bodyExpr, operators: [
       UnlinkedConstOperation.pushTrue,
       UnlinkedConstOperation.not
     ]);
   }
 
   test_constExpr_pushDouble() {
     UnlinkedVariable variable = serializeVariableText('const v = 123.4567;');
-    _assertUnlinkedConst(variable.constExpr,
+    _assertUnlinkedConst(variable.initializer.bodyExpr,
         operators: [UnlinkedConstOperation.pushDouble], doubles: [123.4567]);
   }
 
   test_constExpr_pushFalse() {
     UnlinkedVariable variable = serializeVariableText('const v = false;');
-    _assertUnlinkedConst(variable.constExpr,
+    _assertUnlinkedConst(variable.initializer.bodyExpr,
         operators: [UnlinkedConstOperation.pushFalse]);
   }
 
   test_constExpr_pushInt() {
     UnlinkedVariable variable = serializeVariableText('const v = 1;');
-    _assertUnlinkedConst(variable.constExpr,
+    _assertUnlinkedConst(variable.initializer.bodyExpr,
         operators: [UnlinkedConstOperation.pushInt], ints: [1]);
   }
 
   test_constExpr_pushInt_max() {
     UnlinkedVariable variable = serializeVariableText('const v = 0xFFFFFFFF;');
-    _assertUnlinkedConst(variable.constExpr,
+    _assertUnlinkedConst(variable.initializer.bodyExpr,
         operators: [UnlinkedConstOperation.pushInt,], ints: [0xFFFFFFFF]);
   }
 
   test_constExpr_pushInt_negative() {
     UnlinkedVariable variable = serializeVariableText('const v = -5;');
-    _assertUnlinkedConst(variable.constExpr, operators: [
+    _assertUnlinkedConst(variable.initializer.bodyExpr, operators: [
       UnlinkedConstOperation.pushInt,
       UnlinkedConstOperation.negate
     ], ints: [
       5
     ]);
   }
 
   test_constExpr_pushLongInt() {
     UnlinkedVariable variable =
         serializeVariableText('const v = 0xA123456789ABCDEF012345678;');
-    _assertUnlinkedConst(variable.constExpr,
+    _assertUnlinkedConst(variable.initializer.bodyExpr,
         operators: [UnlinkedConstOperation.pushLongInt],
         ints: [4, 0xA, 0x12345678, 0x9ABCDEF0, 0x12345678]);
   }
 
   test_constExpr_pushLongInt_min2() {
     UnlinkedVariable variable = serializeVariableText('const v = 0x100000000;');
-    _assertUnlinkedConst(variable.constExpr,
+    _assertUnlinkedConst(variable.initializer.bodyExpr,
         operators: [UnlinkedConstOperation.pushLongInt], ints: [2, 1, 0,]);
   }
 
   test_constExpr_pushLongInt_min3() {
     UnlinkedVariable variable =
         serializeVariableText('const v = 0x10000000000000000;');
-    _assertUnlinkedConst(variable.constExpr,
+    _assertUnlinkedConst(variable.initializer.bodyExpr,
         operators: [UnlinkedConstOperation.pushLongInt], ints: [3, 1, 0, 0,]);
   }
 
   test_constExpr_pushNull() {
     UnlinkedVariable variable = serializeVariableText('const v = null;');
-    _assertUnlinkedConst(variable.constExpr,
+    _assertUnlinkedConst(variable.initializer.bodyExpr,
         operators: [UnlinkedConstOperation.pushNull]);
   }
 
   test_constExpr_pushReference_class() {
     UnlinkedVariable variable = serializeVariableText('''
 class C {}
 const v = C;
 ''');
-    _assertUnlinkedConst(variable.constExpr, operators: [
+    _assertUnlinkedConst(variable.initializer.bodyExpr, operators: [
       UnlinkedConstOperation.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.constExpr, operators: [
+    _assertUnlinkedConst(variable.initializer.bodyExpr, operators: [
       UnlinkedConstOperation.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.constExpr, operators: [
+    _assertUnlinkedConst(variable.initializer.bodyExpr, operators: [
       UnlinkedConstOperation.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.constExpr, operators: [
+    _assertUnlinkedConst(variable.initializer.bodyExpr, operators: [
       UnlinkedConstOperation.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.constExpr, operators: [
+    _assertUnlinkedConst(variable.initializer.bodyExpr, operators: [
       UnlinkedConstOperation.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.constExpr, operators: [
+    _assertUnlinkedConst(variable.initializer.bodyExpr, operators: [
       UnlinkedConstOperation.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.constExpr, operators: [
+    _assertUnlinkedConst(variable.initializer.bodyExpr, operators: [
       UnlinkedConstOperation.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.constExpr, operators: [
+    _assertUnlinkedConst(variable.initializer.bodyExpr, operators: [
       UnlinkedConstOperation.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.constExpr, operators: [
+    _assertUnlinkedConst(variable.initializer.bodyExpr, operators: [
       UnlinkedConstOperation.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.constExpr, operators: [
+    _assertUnlinkedConst(variable.initializer.bodyExpr, operators: [
       UnlinkedConstOperation.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.constExpr, operators: [
+    _assertUnlinkedConst(variable.initializer.bodyExpr, operators: [
       UnlinkedConstOperation.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.constExpr, operators: [
+    _assertUnlinkedConst(variable.initializer.bodyExpr, operators: [
       UnlinkedConstOperation.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.constExpr, operators: [
+    _assertUnlinkedConst(variable.initializer.bodyExpr, operators: [
       UnlinkedConstOperation.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.constExpr, operators: [
+    _assertUnlinkedConst(variable.initializer.bodyExpr, operators: [
       UnlinkedConstOperation.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.constExpr, operators: [
+    _assertUnlinkedConst(variable.initializer.bodyExpr, operators: [
       UnlinkedConstOperation.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.constExpr, operators: [
+    _assertUnlinkedConst(variable.initializer.bodyExpr, operators: [
       UnlinkedConstOperation.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.constExpr, operators: [
+    _assertUnlinkedConst(variable.initializer.bodyExpr, operators: [
       UnlinkedConstOperation.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.constExpr, operators: [
+    _assertUnlinkedConst(variable.initializer.bodyExpr, operators: [
       UnlinkedConstOperation.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.constExpr, operators: [
+    _assertUnlinkedConst(variable.initializer.bodyExpr, operators: [
       UnlinkedConstOperation.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.constExpr, operators: [
+    _assertUnlinkedConst(variable.initializer.bodyExpr, operators: [
       UnlinkedConstOperation.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.constExpr, operators: [
+    _assertUnlinkedConst(variable.initializer.bodyExpr, operators: [
       UnlinkedConstOperation.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.constExpr, operators: [
+    _assertUnlinkedConst(variable.initializer.bodyExpr, operators: [
       UnlinkedConstOperation.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.constExpr, operators: [
+    _assertUnlinkedConst(variable.initializer.bodyExpr, operators: [
       UnlinkedConstOperation.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.constExpr, operators: [
+    _assertUnlinkedConst(variable.initializer.bodyExpr, operators: [
       UnlinkedConstOperation.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.constExpr, operators: [
+    _assertUnlinkedConst(variable.initializer.bodyExpr, operators: [
       UnlinkedConstOperation.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.constExpr, operators: [
+    _assertUnlinkedConst(variable.initializer.bodyExpr, operators: [
       UnlinkedConstOperation.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.constExpr, operators: [
+    _assertUnlinkedConst(variable.initializer.bodyExpr, operators: [
       UnlinkedConstOperation.pushReference
     ], referenceValidators: [
       (EntityRef r) {
         return checkParamTypeRef(r, 1);
       }
     ]);
   }
 
   test_constExpr_pushReference_unresolved_prefix0() {
     UnlinkedVariable variable = serializeVariableText(
         '''
 const v = foo;
 ''',
         allowErrors: true);
-    _assertUnlinkedConst(variable.constExpr, operators: [
+    _assertUnlinkedConst(variable.initializer.bodyExpr, operators: [
       UnlinkedConstOperation.pushReference
     ], referenceValidators: [
       (EntityRef r) => checkTypeRef(r, null, null, 'foo',
           expectedKind: ReferenceKind.unresolved,
           checkAstDerivedDataOverride: true)
     ]);
   }
 
   test_constExpr_pushReference_unresolved_prefix1() {
     UnlinkedVariable variable = serializeVariableText(
         '''
 class C {}
 const v = C.foo;
 ''',
         allowErrors: true);
-    _assertUnlinkedConst(variable.constExpr, operators: [
+    _assertUnlinkedConst(variable.initializer.bodyExpr, operators: [
       UnlinkedConstOperation.pushReference
     ], referenceValidators: [
       (EntityRef r) => checkTypeRef(r, null, null, 'foo',
               expectedKind: ReferenceKind.unresolved,
               checkAstDerivedDataOverride: true,
               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.constExpr, operators: [
+    _assertUnlinkedConst(variable.initializer.bodyExpr, operators: [
       UnlinkedConstOperation.pushReference
     ], referenceValidators: [
       (EntityRef r) => checkTypeRef(r, null, null, 'foo',
               expectedKind: ReferenceKind.unresolved,
               checkAstDerivedDataOverride: true,
               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.constExpr,
+    _assertUnlinkedConst(variable.initializer.bodyExpr,
         operators: [UnlinkedConstOperation.pushString], strings: ['aaabccc']);
   }
 
   test_constExpr_pushString_adjacent_interpolation() {
     UnlinkedVariable variable =
         serializeVariableText(r'const v = "aaa" "bb ${42} bbb" "cccc";');
-    _assertUnlinkedConst(variable.constExpr, operators: [
+    _assertUnlinkedConst(variable.initializer.bodyExpr, operators: [
       UnlinkedConstOperation.pushString,
       UnlinkedConstOperation.pushString,
       UnlinkedConstOperation.pushInt,
       UnlinkedConstOperation.pushString,
       UnlinkedConstOperation.concatenate,
       UnlinkedConstOperation.pushString,
       UnlinkedConstOperation.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.constExpr, operators: [
+    _assertUnlinkedConst(variable.initializer.bodyExpr, operators: [
       UnlinkedConstOperation.pushString,
       UnlinkedConstOperation.pushInt,
       UnlinkedConstOperation.pushString,
       UnlinkedConstOperation.concatenate
     ], ints: [
       42,
       3
     ], strings: [
       'aaa ',
       ' bbb'
     ]);
   }
 
   test_constExpr_pushString_simple() {
     UnlinkedVariable variable = serializeVariableText('const v = "abc";');
-    _assertUnlinkedConst(variable.constExpr,
+    _assertUnlinkedConst(variable.initializer.bodyExpr,
         operators: [UnlinkedConstOperation.pushString], strings: ['abc']);
   }
 
   test_constExpr_pushTrue() {
     UnlinkedVariable variable = serializeVariableText('const v = true;');
-    _assertUnlinkedConst(variable.constExpr,
+    _assertUnlinkedConst(variable.initializer.bodyExpr,
         operators: [UnlinkedConstOperation.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);
@@ skipping 2981 matching lines @@
 }
 class B {
   C c;
 }
 class C {
   List<int> f = <int>[0, 1, 2];
 }
 A a = new A();
 final v = (a.b.c.f[1] = 5);
 ''');
-    _assertUnlinkedConst(variable.constExpr, isValidConst: false, operators: [
-      UnlinkedConstOperation.pushInt,
-      UnlinkedConstOperation.pushReference,
-      UnlinkedConstOperation.pushInt,
-      UnlinkedConstOperation.assignToIndex,
-    ], assignmentOperators: [
-      (UnlinkedExprAssignOperator.assign)
-    ], ints: [
-      5,
-      1
-    ], strings: [], referenceValidators: [
-      (EntityRef r) => checkTypeRef(r, null, null, 'f',
-              expectedKind: ReferenceKind.unresolved,
-              prefixExpectations: [
-                new _PrefixExpectation(ReferenceKind.unresolved, 'c'),
-                new _PrefixExpectation(ReferenceKind.unresolved, 'b'),
-                new _PrefixExpectation(
-                    ReferenceKind.topLevelPropertyAccessor, 'a')
-              ])
-    ]);
+    _assertUnlinkedConst(variable.initializer.bodyExpr,
+        isValidConst: false,
+        operators: [
+          UnlinkedConstOperation.pushInt,
+          UnlinkedConstOperation.pushReference,
+          UnlinkedConstOperation.pushInt,
+          UnlinkedConstOperation.assignToIndex,
+        ],
+        assignmentOperators: [
+          (UnlinkedExprAssignOperator.assign)
+        ],
+        ints: [
+          5,
+          1
+        ],
+        strings: [],
+        referenceValidators: [
+          (EntityRef r) => checkTypeRef(r, null, null, 'f',
+                  expectedKind: ReferenceKind.unresolved,
+                  prefixExpectations: [
+                    new _PrefixExpectation(ReferenceKind.unresolved, 'c'),
+                    new _PrefixExpectation(ReferenceKind.unresolved, 'b'),
+                    new _PrefixExpectation(
+                        ReferenceKind.topLevelPropertyAccessor, 'a')
+                  ])
+        ]);
   }
 
   test_expr_assignToIndex_ofIndexExpression() {
     if (skipNonConstInitializers) {
       return;
     }
     UnlinkedVariable variable = serializeVariableText('''
 class A {
  List<B> b;
 }
 class B {
   List<C> c;
 }
 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.constExpr, isValidConst: false, operators: [
-      // 5
-      UnlinkedConstOperation.pushInt,
-      // a.b[1]
-      UnlinkedConstOperation.pushReference,
-      UnlinkedConstOperation.pushInt,
-      UnlinkedConstOperation.extractIndex,
-      // c[2]
-      UnlinkedConstOperation.extractProperty,
-      UnlinkedConstOperation.pushInt,
-      UnlinkedConstOperation.extractIndex,
-      // f[3] = 5
-      UnlinkedConstOperation.extractProperty,
-      UnlinkedConstOperation.pushInt,
-      UnlinkedConstOperation.assignToIndex,
-    ], assignmentOperators: [
-      (UnlinkedExprAssignOperator.assign)
-    ], ints: [
-      5,
-      1,
-      2,
-      3,
-    ], strings: [
-      'c',
-      'f'
-    ], referenceValidators: [
-      (EntityRef r) => checkTypeRef(r, null, null,
-              'b', expectedKind: ReferenceKind.unresolved, prefixExpectations: [
-            new _PrefixExpectation(ReferenceKind.topLevelPropertyAccessor, 'a')
-          ])
-    ]);
+    _assertUnlinkedConst(variable.initializer.bodyExpr,
+        isValidConst: false,
+        operators: [
+          // 5
+          UnlinkedConstOperation.pushInt,
+          // a.b[1]
+          UnlinkedConstOperation.pushReference,
+          UnlinkedConstOperation.pushInt,
+          UnlinkedConstOperation.extractIndex,
+          // c[2]
+          UnlinkedConstOperation.extractProperty,
+          UnlinkedConstOperation.pushInt,
+          UnlinkedConstOperation.extractIndex,
+          // f[3] = 5
+          UnlinkedConstOperation.extractProperty,
+          UnlinkedConstOperation.pushInt,
+          UnlinkedConstOperation.assignToIndex,
+        ],
+        assignmentOperators: [
+          (UnlinkedExprAssignOperator.assign)
+        ],
+        ints: [
+          5,
+          1,
+          2,
+          3,
+        ],
+        strings: [
+          'c',
+          'f'
+        ],
+        referenceValidators: [
+          (EntityRef r) => checkTypeRef(r, null, null, 'b',
+                  expectedKind: ReferenceKind.unresolved,
+                  prefixExpectations: [
+                    new _PrefixExpectation(
+                        ReferenceKind.topLevelPropertyAccessor, 'a')
+                  ])
+        ]);
   }
 
   test_expr_assignToIndex_ofTopLevelVariable() {
     if (skipNonConstInitializers) {
       return;
     }
     UnlinkedVariable variable = serializeVariableText('''
 List<int> a = <int>[0, 1, 2];
 final v = (a[1] = 5);
 ''');
-    _assertUnlinkedConst(variable.constExpr, isValidConst: false, operators: [
-      UnlinkedConstOperation.pushInt,
-      UnlinkedConstOperation.pushReference,
-      UnlinkedConstOperation.pushInt,
-      UnlinkedConstOperation.assignToIndex,
-    ], assignmentOperators: [
-      (UnlinkedExprAssignOperator.assign)
-    ], ints: [
-      5,
-      1,
-    ], strings: [], referenceValidators: [
-      (EntityRef r) => checkTypeRef(r, null, null, 'a',
-          expectedKind: ReferenceKind.topLevelPropertyAccessor)
-    ]);
+    _assertUnlinkedConst(variable.initializer.bodyExpr,
+        isValidConst: false,
+        operators: [
+          UnlinkedConstOperation.pushInt,
+          UnlinkedConstOperation.pushReference,
+          UnlinkedConstOperation.pushInt,
+          UnlinkedConstOperation.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.constExpr, isValidConst: false, operators: [
-      UnlinkedConstOperation.pushInt,
-      UnlinkedConstOperation.invokeConstructor,
-      UnlinkedConstOperation.assignToProperty,
-    ], assignmentOperators: [
-      (UnlinkedExprAssignOperator.assign)
-    ], ints: [
-      5,
-      0,
-      0,
-    ], strings: [
-      'f'
-    ], referenceValidators: [
-      (EntityRef r) => checkTypeRef(r, null, null, 'C',
-          expectedKind: ReferenceKind.classOrEnum)
-    ]);
+    _assertUnlinkedConst(variable.initializer.bodyExpr,
+        isValidConst: false,
+        operators: [
+          UnlinkedConstOperation.pushInt,
+          UnlinkedConstOperation.invokeConstructor,
+          UnlinkedConstOperation.assignToProperty,
+        ],
+        assignmentOperators: [
+          (UnlinkedExprAssignOperator.assign)
+        ],
+        ints: [
+          5,
+          0,
+          0,
+        ],
+        strings: [
+          'f'
+        ],
+        referenceValidators: [
+          (EntityRef r) => checkTypeRef(r, null, null, 'C',
+              expectedKind: ReferenceKind.classOrEnum)
+        ]);
   }
 
   test_expr_assignToRef_classStaticField() {
     if (skipNonConstInitializers) {
       return;
     }
     UnlinkedVariable variable = serializeVariableText('''
 class C {
   static int f;
 }
 final v = (C.f = 1);
 ''');
-    _assertUnlinkedConst(variable.constExpr, isValidConst: false, operators: [
-      UnlinkedConstOperation.pushInt,
-      UnlinkedConstOperation.assignToRef,
-    ], assignmentOperators: [
-      (UnlinkedExprAssignOperator.assign)
-    ], ints: [
-      1,
-    ], strings: [], referenceValidators: [
-      (EntityRef r) => checkTypeRef(r, null, null, 'f',
-              expectedKind: ReferenceKind.unresolved,
-              prefixExpectations: [
-                new _PrefixExpectation(ReferenceKind.classOrEnum, 'C')
-              ])
-    ]);
+    _assertUnlinkedConst(variable.initializer.bodyExpr,
+        isValidConst: false,
+        operators: [
+          UnlinkedConstOperation.pushInt,
+          UnlinkedConstOperation.assignToRef,
+        ],
+        assignmentOperators: [
+          (UnlinkedExprAssignOperator.assign)
+        ],
+        ints: [
+          1,
+        ],
+        strings: [],
+        referenceValidators: [
+          (EntityRef r) => checkTypeRef(r, null, null, 'f',
+                  expectedKind: ReferenceKind.unresolved,
+                  prefixExpectations: [
+                    new _PrefixExpectation(ReferenceKind.classOrEnum, 'C')
+                  ])
+        ]);
   }
 
   test_expr_assignToRef_fieldSequence() {
     if (skipNonConstInitializers) {
       return;
     }
     UnlinkedVariable variable = serializeVariableText('''
 class A {
   B b;
 }
 class B {
   C c;
 }
 class C {
   int f;
 }
 A a = new A();
 final v = (a.b.c.f = 1);
 ''');
-    _assertUnlinkedConst(variable.constExpr, isValidConst: false, operators: [
-      UnlinkedConstOperation.pushInt,
-      UnlinkedConstOperation.assignToRef,
-    ], assignmentOperators: [
-      (UnlinkedExprAssignOperator.assign)
-    ], ints: [
-      1,
-    ], strings: [], referenceValidators: [
-      (EntityRef r) => checkTypeRef(r, null, null, 'f',
-              expectedKind: ReferenceKind.unresolved,
-              prefixExpectations: [
-                new _PrefixExpectation(ReferenceKind.unresolved, 'c'),
-                new _PrefixExpectation(ReferenceKind.unresolved, 'b'),
-                new _PrefixExpectation(
-                    ReferenceKind.topLevelPropertyAccessor, 'a')
-              ])
-    ]);
+    _assertUnlinkedConst(variable.initializer.bodyExpr,
+        isValidConst: false,
+        operators: [
+          UnlinkedConstOperation.pushInt,
+          UnlinkedConstOperation.assignToRef,
+        ],
+        assignmentOperators: [
+          (UnlinkedExprAssignOperator.assign)
+        ],
+        ints: [
+          1,
+        ],
+        strings: [],
+        referenceValidators: [
+          (EntityRef r) => checkTypeRef(r, null, null, 'f',
+                  expectedKind: ReferenceKind.unresolved,
+                  prefixExpectations: [
+                    new _PrefixExpectation(ReferenceKind.unresolved, 'c'),
+                    new _PrefixExpectation(ReferenceKind.unresolved, 'b'),
+                    new _PrefixExpectation(
+                        ReferenceKind.topLevelPropertyAccessor, 'a')
+                  ])
+        ]);
   }
 
   test_expr_assignToRef_postfixDecrement() {
     _assertRefPrefixPostfixIncrementDecrement(
         'a-- + 2', UnlinkedExprAssignOperator.postfixDecrement);
   }
 
   test_expr_assignToRef_postfixIncrement() {
     _assertRefPrefixPostfixIncrementDecrement(
         'a++ + 2', UnlinkedExprAssignOperator.postfixIncrement);
@@ skipping 10 matching lines @@
   }
 
   test_expr_assignToRef_topLevelVariable() {
     if (skipNonConstInitializers) {
       return;
     }
     UnlinkedVariable variable = serializeVariableText('''
 int a = 0;
 final v = (a = 1);
 ''');
-    _assertUnlinkedConst(variable.constExpr, isValidConst: false, operators: [
-      UnlinkedConstOperation.pushInt,
-      UnlinkedConstOperation.assignToRef,
-    ], assignmentOperators: [
-      (UnlinkedExprAssignOperator.assign)
-    ], ints: [
-      1,
-    ], strings: [], referenceValidators: [
-      (EntityRef r) => checkTypeRef(r, null, null, 'a',
-          expectedKind: ReferenceKind.topLevelPropertyAccessor)
-    ]);
+    _assertUnlinkedConst(variable.initializer.bodyExpr,
+        isValidConst: false,
+        operators: [
+          UnlinkedConstOperation.pushInt,
+          UnlinkedConstOperation.assignToRef,
+        ],
+        assignmentOperators: [
+          (UnlinkedExprAssignOperator.assign)
+        ],
+        ints: [
+          1,
+        ],
+        strings: [],
+        referenceValidators: [
+          (EntityRef r) => checkTypeRef(r, null, null, 'a',
+              expectedKind: ReferenceKind.topLevelPropertyAccessor)
+        ]);
   }
 
   test_expr_assignToRef_topLevelVariable_imported() {
     if (skipNonConstInitializers) {
       return;
     }
     addNamedSource(
         '/a.dart',
         '''
 int a = 0;
 ''');
     UnlinkedVariable variable = serializeVariableText('''
 import 'a.dart';
 final v = (a = 1);
 ''');
-    _assertUnlinkedConst(variable.constExpr, isValidConst: false, operators: [
-      UnlinkedConstOperation.pushInt,
-      UnlinkedConstOperation.assignToRef,
-    ], assignmentOperators: [
-      (UnlinkedExprAssignOperator.assign)
-    ], ints: [
-      1,
-    ], strings: [], referenceValidators: [
-      (EntityRef r) => checkTypeRef(r, absUri('/a.dart'), 'a.dart', 'a',
-          expectedKind: ReferenceKind.topLevelPropertyAccessor)
-    ]);
+    _assertUnlinkedConst(variable.initializer.bodyExpr,
+        isValidConst: false,
+        operators: [
+          UnlinkedConstOperation.pushInt,
+          UnlinkedConstOperation.assignToRef,
+        ],
+        assignmentOperators: [
+          (UnlinkedExprAssignOperator.assign)
+        ],
+        ints: [
+          1,
+        ],
+        strings: [],
+        referenceValidators: [
+          (EntityRef r) => checkTypeRef(r, absUri('/a.dart'), 'a.dart', 'a',
+              expectedKind: ReferenceKind.topLevelPropertyAccessor)
+        ]);
   }
 
   test_expr_assignToRef_topLevelVariable_imported_withPrefix() {
     if (skipNonConstInitializers) {
       return;
     }
     addNamedSource(
         '/a.dart',
         '''
 int a = 0;
 ''');
     UnlinkedVariable variable = serializeVariableText('''
 import 'a.dart' as p;
 final v = (p.a = 1);
 ''');
-    _assertUnlinkedConst(variable.constExpr, isValidConst: false, operators: [
-      UnlinkedConstOperation.pushInt,
-      UnlinkedConstOperation.assignToRef,
-    ], assignmentOperators: [
-      (UnlinkedExprAssignOperator.assign)
-    ], ints: [
-      1,
-    ], strings: [], referenceValidators: [
-      (EntityRef r) {
-        return checkTypeRef(r, absUri('/a.dart'), 'a.dart', 'a',
-            expectedKind: ReferenceKind.topLevelPropertyAccessor,
-            expectedPrefix: 'p');
-      }
-    ]);
+    _assertUnlinkedConst(variable.initializer.bodyExpr,
+        isValidConst: false,
+        operators: [
+          UnlinkedConstOperation.pushInt,
+          UnlinkedConstOperation.assignToRef,
+        ],
+        assignmentOperators: [
+          (UnlinkedExprAssignOperator.assign)
+        ],
+        ints: [
+          1,
+        ],
+        strings: [],
+        referenceValidators: [
+          (EntityRef r) {
+            return checkTypeRef(r, absUri('/a.dart'), 'a.dart', 'a',
+                expectedKind: ReferenceKind.topLevelPropertyAccessor,
+                expectedPrefix: 'p');
+          }
+        ]);
   }
 
   test_expr_cascadeSection_assignToIndex() {
     if (skipNonConstInitializers) {
       return;
     }
     UnlinkedVariable variable = serializeVariableText('''
 class C {
   List<int> items;
 }
 final C c = new C();
 final v = c.items..[1] = 2;
 ''');
-    _assertUnlinkedConst(variable.constExpr, isValidConst: false, operators: [
-      UnlinkedConstOperation.pushReference,
-      //   ..[1] = 2
-      UnlinkedConstOperation.cascadeSectionBegin,
-      UnlinkedConstOperation.pushInt,
-      UnlinkedConstOperation.pushInt,
-      UnlinkedConstOperation.assignToIndex,
-      // c
-      UnlinkedConstOperation.cascadeSectionEnd,
-    ], assignmentOperators: [
-      UnlinkedExprAssignOperator.assign,
-    ], ints: [
-      2,
-      1
-    ], strings: [], referenceValidators: [
-      (EntityRef r) => checkTypeRef(r, null, null, 'items',
-              expectedKind: ReferenceKind.unresolved,
-              prefixExpectations: [
-                new _PrefixExpectation(
-                    ReferenceKind.topLevelPropertyAccessor, 'c'),
-              ])
-    ]);
+    _assertUnlinkedConst(variable.initializer.bodyExpr,
+        isValidConst: false,
+        operators: [
+          UnlinkedConstOperation.pushReference,
+          //   ..[1] = 2
+          UnlinkedConstOperation.cascadeSectionBegin,
+          UnlinkedConstOperation.pushInt,
+          UnlinkedConstOperation.pushInt,
+          UnlinkedConstOperation.assignToIndex,
+          // c
+          UnlinkedConstOperation.cascadeSectionEnd,
+        ],
+        assignmentOperators: [
+          UnlinkedExprAssignOperator.assign,
+        ],
+        ints: [
+          2,
+          1
+        ],
+        strings: [],
+        referenceValidators: [
+          (EntityRef r) => checkTypeRef(r, null, null, 'items',
+                  expectedKind: ReferenceKind.unresolved,
+                  prefixExpectations: [
+                    new _PrefixExpectation(
+                        ReferenceKind.topLevelPropertyAccessor, 'c'),
+                  ])
+        ]);
   }
 
   test_expr_cascadeSection_assignToProperty() {
     if (skipNonConstInitializers) {
       return;
     }
     UnlinkedVariable variable = serializeVariableText('''
 class C {
   int f1 = 0;
   int f2 = 0;
 }
 final v = new C()..f1 = 1..f2 += 2;
 ''');
-    _assertUnlinkedConst(variable.constExpr, isValidConst: false, operators: [
-      // new C()
-      UnlinkedConstOperation.invokeConstructor,
-      //   ..f1 = 1
-      UnlinkedConstOperation.cascadeSectionBegin,
-      UnlinkedConstOperation.pushInt,
-      UnlinkedConstOperation.assignToProperty,
-      // C
-      UnlinkedConstOperation.cascadeSectionEnd,
-      //   ..f2 += 2
-      UnlinkedConstOperation.cascadeSectionBegin,
-      UnlinkedConstOperation.pushInt,
-      UnlinkedConstOperation.assignToProperty,
-      // C
-      UnlinkedConstOperation.cascadeSectionEnd,
-    ], assignmentOperators: [
-      UnlinkedExprAssignOperator.assign,
-      UnlinkedExprAssignOperator.plus,
-    ], ints: [
-      0, 0, // new C()
-      1, // f1 = 1
-      2, // f2 += 2
-    ], strings: [
-      'f1',
-      'f2',
-    ], referenceValidators: [
-      (EntityRef r) => checkTypeRef(r, null, null, 'C',
-          expectedKind: ReferenceKind.classOrEnum)
-    ]);
+    _assertUnlinkedConst(variable.initializer.bodyExpr,
+        isValidConst: false,
+        operators: [
+          // new C()
+          UnlinkedConstOperation.invokeConstructor,
+          //   ..f1 = 1
+          UnlinkedConstOperation.cascadeSectionBegin,
+          UnlinkedConstOperation.pushInt,
+          UnlinkedConstOperation.assignToProperty,
+          // C
+          UnlinkedConstOperation.cascadeSectionEnd,
+          //   ..f2 += 2
+          UnlinkedConstOperation.cascadeSectionBegin,
+          UnlinkedConstOperation.pushInt,
+          UnlinkedConstOperation.assignToProperty,
+          // C
+          UnlinkedConstOperation.cascadeSectionEnd,
+        ],
+        assignmentOperators: [
+          UnlinkedExprAssignOperator.assign,
+          UnlinkedExprAssignOperator.plus,
+        ],
+        ints: [
+          0, 0, // new C()
+          1, // f1 = 1
+          2, // f2 += 2
+        ],
+        strings: [
+          'f1',
+          'f2',
+        ],
+        referenceValidators: [
+          (EntityRef r) => checkTypeRef(r, null, null, 'C',
+              expectedKind: ReferenceKind.classOrEnum)
+        ]);
   }
 
   test_expr_cascadeSection_embedded() {
     if (skipNonConstInitializers) {
       return;
     }
     UnlinkedVariable variable = serializeVariableText('''
 class A {
   int fa1;
   B b;
   int fa2;
 }
 class B {
   int fb;
 }
 final v = new A()
   ..fa1 = 1
   ..b = (new B()..fb = 2)
   ..fa2 = 3;
 ''');
-    _assertUnlinkedConst(variable.constExpr, isValidConst: false, operators: [
-      // new A()
-      UnlinkedConstOperation.invokeConstructor,
-      // ..fa1 = 1
-      UnlinkedConstOperation.cascadeSectionBegin,
-      UnlinkedConstOperation.pushInt,
-      UnlinkedConstOperation.assignToProperty,
-      UnlinkedConstOperation.cascadeSectionEnd,
-      // ..b
-      UnlinkedConstOperation.cascadeSectionBegin,
-      //   new B()
-      UnlinkedConstOperation.invokeConstructor,
-      //   ..fb = 2
-      UnlinkedConstOperation.cascadeSectionBegin,
-      UnlinkedConstOperation.pushInt,
-      UnlinkedConstOperation.assignToProperty,
-      UnlinkedConstOperation.cascadeSectionEnd,
-      // ..b = <pop value>
-      UnlinkedConstOperation.assignToProperty,
-      UnlinkedConstOperation.cascadeSectionEnd,
-      // ..fa2 = 3
-      UnlinkedConstOperation.cascadeSectionBegin,
-      UnlinkedConstOperation.pushInt,
-      UnlinkedConstOperation.assignToProperty,
-      UnlinkedConstOperation.cascadeSectionEnd,
-    ], assignmentOperators: [
-      UnlinkedExprAssignOperator.assign,
-      UnlinkedExprAssignOperator.assign,
-      UnlinkedExprAssignOperator.assign,
-      UnlinkedExprAssignOperator.assign,
-    ], ints: [
-      0,
-      0,
-      1,
-      0,
-      0,
-      2,
-      3,
-    ], strings: [
-      'fa1',
-      'fb',
-      'b',
-      'fa2',
-    ], referenceValidators: [
-      (EntityRef r) => checkTypeRef(r, null, null, 'A',
-          expectedKind: ReferenceKind.classOrEnum),
-      (EntityRef r) => checkTypeRef(r, null, null, 'B',
-          expectedKind: ReferenceKind.classOrEnum),
-    ]);
+    _assertUnlinkedConst(variable.initializer.bodyExpr,
+        isValidConst: false,
+        operators: [
+          // new A()
+          UnlinkedConstOperation.invokeConstructor,
+          // ..fa1 = 1
+          UnlinkedConstOperation.cascadeSectionBegin,
+          UnlinkedConstOperation.pushInt,
+          UnlinkedConstOperation.assignToProperty,
+          UnlinkedConstOperation.cascadeSectionEnd,
+          // ..b
+          UnlinkedConstOperation.cascadeSectionBegin,
+          //   new B()
+          UnlinkedConstOperation.invokeConstructor,
+          //   ..fb = 2
+          UnlinkedConstOperation.cascadeSectionBegin,
+          UnlinkedConstOperation.pushInt,
+          UnlinkedConstOperation.assignToProperty,
+          UnlinkedConstOperation.cascadeSectionEnd,
+          // ..b = <pop value>
+          UnlinkedConstOperation.assignToProperty,
+          UnlinkedConstOperation.cascadeSectionEnd,
+          // ..fa2 = 3
+          UnlinkedConstOperation.cascadeSectionBegin,
+          UnlinkedConstOperation.pushInt,
+          UnlinkedConstOperation.assignToProperty,
+          UnlinkedConstOperation.cascadeSectionEnd,
+        ],
+        assignmentOperators: [
+          UnlinkedExprAssignOperator.assign,
+          UnlinkedExprAssignOperator.assign,
+          UnlinkedExprAssignOperator.assign,
+          UnlinkedExprAssignOperator.assign,
+        ],
+        ints: [
+          0,
+          0,
+          1,
+          0,
+          0,
+          2,
+          3,
+        ],
+        strings: [
+          'fa1',
+          'fb',
+          'b',
+          'fa2',
+        ],
+        referenceValidators: [
+          (EntityRef r) => checkTypeRef(r, null, null, 'A',
+              expectedKind: ReferenceKind.classOrEnum),
+          (EntityRef r) => checkTypeRef(r, null, null, 'B',
+              expectedKind: ReferenceKind.classOrEnum),
+        ]);
   }
 
   test_expr_cascadeSection_invokeMethod() {
     if (skipNonConstInitializers) {
       return;
     }
     UnlinkedVariable variable = serializeVariableText('''
 class A {
   int m(int _) => 0;
 }
 final A a = new A();
 final v = a..m(5).abs()..m(6);
 ''');
-    _assertUnlinkedConst(variable.constExpr, isValidConst: false, operators: [
-      // a
-      UnlinkedConstOperation.pushReference,
-      //   ..m(5)
-      UnlinkedConstOperation.cascadeSectionBegin,
-      UnlinkedConstOperation.pushInt,
-      UnlinkedConstOperation.invokeMethod,
-      //   ..abs()
-      UnlinkedConstOperation.invokeMethod,
-      // a
-      UnlinkedConstOperation.cascadeSectionEnd,
-      //   ..m(6)
-      UnlinkedConstOperation.cascadeSectionBegin,
-      UnlinkedConstOperation.pushInt,
-      UnlinkedConstOperation.invokeMethod,
-      // a
-      UnlinkedConstOperation.cascadeSectionEnd,
-    ], ints: [
-      5, 0, 1, // m(5)
-      0, 0, // abs()
-      6, 0, 1, // m(5)
-    ], strings: [
-      'm',
-      'abs',
-      'm',
-    ], referenceValidators: [
-      (EntityRef r) => checkTypeRef(r, null, null, 'a',
-          expectedKind: ReferenceKind.topLevelPropertyAccessor),
-    ]);
+    _assertUnlinkedConst(variable.initializer.bodyExpr,
+        isValidConst: false,
+        operators: [
+          // a
+          UnlinkedConstOperation.pushReference,
+          //   ..m(5)
+          UnlinkedConstOperation.cascadeSectionBegin,
+          UnlinkedConstOperation.pushInt,
+          UnlinkedConstOperation.invokeMethod,
+          //   ..abs()
+          UnlinkedConstOperation.invokeMethod,
+          // a
+          UnlinkedConstOperation.cascadeSectionEnd,
+          //   ..m(6)
+          UnlinkedConstOperation.cascadeSectionBegin,
+          UnlinkedConstOperation.pushInt,
+          UnlinkedConstOperation.invokeMethod,
+          // a
+          UnlinkedConstOperation.cascadeSectionEnd,
+        ],
+        ints: [
+          5, 0, 1, // m(5)
+          0, 0, // abs()
+          6, 0, 1, // m(5)
+        ],
+        strings: [
+          'm',
+          'abs',
+          'm',
+        ],
+        referenceValidators: [
+          (EntityRef r) => checkTypeRef(r, null, null, 'a',
+              expectedKind: ReferenceKind.topLevelPropertyAccessor),
+        ]);
   }
 
   test_expr_extractIndex_ofClassField() {
     if (skipNonConstInitializers) {
       return;
     }
     UnlinkedVariable variable = serializeVariableText('''
 class C {
   List<int> get items => null;
 }
 final v = new C().items[5];
 ''');
-    _assertUnlinkedConst(variable.constExpr, isValidConst: false, operators: [
-      UnlinkedConstOperation.invokeConstructor,
-      UnlinkedConstOperation.extractProperty,
-      UnlinkedConstOperation.pushInt,
-      UnlinkedConstOperation.extractIndex,
-    ], ints: [
-      0,
-      0,
-      5
-    ], strings: [
-      'items'
-    ], referenceValidators: [
-      (EntityRef r) => checkTypeRef(r, null, null, 'C',
-          expectedKind: ReferenceKind.classOrEnum)
-    ]);
+    _assertUnlinkedConst(variable.initializer.bodyExpr,
+        isValidConst: false,
+        operators: [
+          UnlinkedConstOperation.invokeConstructor,
+          UnlinkedConstOperation.extractProperty,
+          UnlinkedConstOperation.pushInt,
+          UnlinkedConstOperation.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.constExpr, isValidConst: false, operators: [
-      UnlinkedConstOperation.invokeConstructor,
-      UnlinkedConstOperation.extractProperty,
-    ], ints: [
-      0,
-      0
-    ], strings: [
-      'f'
-    ], referenceValidators: [
-      (EntityRef r) => checkTypeRef(r, null, null, 'C',
-          expectedKind: ReferenceKind.classOrEnum)
-    ]);
+    _assertUnlinkedConst(variable.initializer.bodyExpr,
+        isValidConst: false,
+        operators: [
+          UnlinkedConstOperation.invokeConstructor,
+          UnlinkedConstOperation.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.constExpr, isValidConst: false, operators: [
-      UnlinkedConstOperation.pushInt,
-      UnlinkedConstOperation.pushLocalFunctionReference,
-      UnlinkedConstOperation.invokeMethodRef
-    ], ints: [
-      5,
-      0,
-      0,
-      0,
-      2
-    ], referenceValidators: [
-      (EntityRef r) => checkTypeRef(r, null, null, 'foo',
-          expectedKind: ReferenceKind.topLevelFunction)
-    ]);
+    _assertUnlinkedConst(variable.initializer.bodyExpr,
+        isValidConst: false,
+        operators: [
+          UnlinkedConstOperation.pushInt,
+          UnlinkedConstOperation.pushLocalFunctionReference,
+          UnlinkedConstOperation.invokeMethodRef
+        ],
+        ints: [
+          5,
+          0,
+          0,
+          0,
+          2
+        ],
+        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.constExpr, isValidConst: false, operators: [
-      UnlinkedConstOperation.pushInt,
-      UnlinkedConstOperation.pushLocalFunctionReference,
-      UnlinkedConstOperation.pushLocalFunctionReference,
-      UnlinkedConstOperation.invokeMethodRef
-    ], ints: [
-      5,
-      0,
-      0,
-      0,
-      1,
-      0,
-      3
-    ], referenceValidators: [
-      (EntityRef r) => checkTypeRef(r, null, null, 'foo',
-          expectedKind: ReferenceKind.topLevelFunction)
-    ]);
+    _assertUnlinkedConst(variable.initializer.bodyExpr,
+        isValidConst: false,
+        operators: [
+          UnlinkedConstOperation.pushInt,
+          UnlinkedConstOperation.pushLocalFunctionReference,
+          UnlinkedConstOperation.pushLocalFunctionReference,
+          UnlinkedConstOperation.invokeMethodRef
+        ],
+        ints: [
+          5,
+          0,
+          0,
+          0,
+          1,
+          0,
+          3
+        ],
+        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.constExpr,
+    _assertUnlinkedConst(variable.initializer.bodyExpr,
         isValidConst: false,
         operators: [UnlinkedConstOperation.pushLocalFunctionReference],
         ints: [0, 0]);
   }
 
   test_expr_functionExpression_withExpressionBody() {
     if (skipNonConstInitializers) {
       return;
     }
     UnlinkedVariable variable = serializeVariableText('''
 final v = () => 42;
 ''');
-    _assertUnlinkedConst(variable.constExpr,
+    _assertUnlinkedConst(variable.initializer.bodyExpr,
         isValidConst: false,
         operators: [UnlinkedConstOperation.pushLocalFunctionReference],
         ints: [0, 0]);
   }
 
   test_expr_functionExpressionInvocation_withBlockBody() {
     if (skipNonConstInitializers) {
       return;
     }
     UnlinkedVariable variable = serializeVariableText('''
 final v = ((a, b) {return 42;})(1, 2);
 ''');
-    _assertUnlinkedConst(variable.constExpr,
+    _assertUnlinkedConst(variable.initializer.bodyExpr,
         isValidConst: false, operators: [UnlinkedConstOperation.pushNull]);
   }
 
   test_expr_functionExpressionInvocation_withExpressionBody() {
     if (skipNonConstInitializers) {
       return;
     }
     UnlinkedVariable variable = serializeVariableText('''
 final v = ((a, b) => 42)(1, 2);
 ''');
-    _assertUnlinkedConst(variable.constExpr,
+    _assertUnlinkedConst(variable.initializer.bodyExpr,
         isValidConst: false, operators: [UnlinkedConstOperation.pushNull]);
   }
 
   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.constExpr, isValidConst: false, operators: [
-      UnlinkedConstOperation.invokeConstructor,
-      UnlinkedConstOperation.pushInt,
-      UnlinkedConstOperation.pushInt,
-      UnlinkedConstOperation.pushInt,
-      UnlinkedConstOperation.invokeMethod,
-    ], ints: [
-      0,
-      0,
-      1,
-      2,
-      3,
-      2,
-      1
-    ], strings: [
-      'b',
-      'c',
-      'm'
-    ], referenceValidators: [
-      (EntityRef r) => checkTypeRef(r, null, null, 'C',
-          expectedKind: ReferenceKind.classOrEnum)
-    ]);
+    _assertUnlinkedConst(variable.initializer.bodyExpr,
+        isValidConst: false,
+        operators: [
+          UnlinkedConstOperation.invokeConstructor,
+          UnlinkedConstOperation.pushInt,
+          UnlinkedConstOperation.pushInt,
+          UnlinkedConstOperation.pushInt,
+          UnlinkedConstOperation.invokeMethod,
+        ],
+        ints: [
+          0,
+          0,
+          1,
+          2,
+          3,
+          2,
+          1
+        ],
+        strings: [
+          'b',
+          'c',
+          'm'
+        ],
+        referenceValidators: [
+          (EntityRef r) => checkTypeRef(r, null, null, 'C',
+              expectedKind: ReferenceKind.classOrEnum)
+        ]);
   }
 
   test_expr_invokeMethodRef_instance() {
     if (skipNonConstInitializers) {
       return;
     }
     UnlinkedVariable variable = serializeVariableText('''
 class A {
   B b;
 }
 class B {
   C c;
 }
 class C {
   int m(int a, int b) => a + b;
 }
 A a = new A();
 final v = a.b.c.m(10, 20);
 ''');
-    _assertUnlinkedConst(variable.constExpr, isValidConst: false, operators: [
-      UnlinkedConstOperation.pushInt,
-      UnlinkedConstOperation.pushInt,
-      UnlinkedConstOperation.invokeMethodRef,
-    ], ints: [
-      10,
-      20,
-      0,
-      2
-    ], strings: [], referenceValidators: [
-      (EntityRef r) => checkTypeRef(r, null, null, 'm',
-              expectedKind: ReferenceKind.unresolved,
-              prefixExpectations: [
-                new _PrefixExpectation(ReferenceKind.unresolved, 'c'),
-                new _PrefixExpectation(ReferenceKind.unresolved, 'b'),
-                new _PrefixExpectation(
-                    ReferenceKind.topLevelPropertyAccessor, 'a')
-              ])
-    ]);
+    _assertUnlinkedConst(variable.initializer.bodyExpr,
+        isValidConst: false,
+        operators: [
+          UnlinkedConstOperation.pushInt,
+          UnlinkedConstOperation.pushInt,
+          UnlinkedConstOperation.invokeMethodRef,
+        ],
+        ints: [
+          10,
+          20,
+          0,
+          2
+        ],
+        strings: [],
+        referenceValidators: [
+          (EntityRef r) => checkTypeRef(r, null, null, 'm',
+                  expectedKind: ReferenceKind.unresolved,
+                  prefixExpectations: [
+                    new _PrefixExpectation(ReferenceKind.unresolved, 'c'),
+                    new _PrefixExpectation(ReferenceKind.unresolved, 'b'),
+                    new _PrefixExpectation(
+                        ReferenceKind.topLevelPropertyAccessor, 'a')
+                  ])
+        ]);
   }
 
   test_expr_invokeMethodRef_static_importedWithPrefix() {
     if (skipNonConstInitializers) {
       return;
     }
     addNamedSource(
         '/a.dart',
         '''
 class C {
   static int m() => 42;
 }
 ''');
     UnlinkedVariable variable = serializeVariableText('''
 import 'a.dart' as p;
 final v = p.C.m();
 ''');
-    _assertUnlinkedConst(variable.constExpr, isValidConst: false, operators: [
-      UnlinkedConstOperation.invokeMethodRef,
-    ], ints: [
-      0,
-      0
-    ], strings: [], 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')
-              ])
-    ]);
+    _assertUnlinkedConst(variable.initializer.bodyExpr,
+        isValidConst: false,
+        operators: [
+          UnlinkedConstOperation.invokeMethodRef,
+        ],
+        ints: [
+          0,
+          0
+        ],
+        strings: [],
+        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_expr_invokeMethodRef_with_reference_arg() {
     if (skipNonConstInitializers) {
       return;
     }
     UnlinkedVariable variable = serializeVariableText('''
 f(x) => null;
 final u = null;
 final v = f(u);
 ''');
-    _assertUnlinkedConst(variable.constExpr, isValidConst: false, operators: [
-      UnlinkedConstOperation.pushReference,
-      UnlinkedConstOperation.invokeMethodRef
-    ], ints: [
-      0,
-      1
-    ], referenceValidators: [
-      (EntityRef r) => checkTypeRef(r, null, null, 'u',
-          expectedKind: ReferenceKind.topLevelPropertyAccessor),
-      (EntityRef r) => checkTypeRef(r, null, null, 'f',
-          expectedKind: ReferenceKind.topLevelFunction)
-    ]);
+    _assertUnlinkedConst(variable.initializer.bodyExpr,
+        isValidConst: false,
+        operators: [
+          UnlinkedConstOperation.pushReference,
+          UnlinkedConstOperation.invokeMethodRef
+        ],
+        ints: [
+          0,
+          1
+        ],
+        referenceValidators: [
+          (EntityRef r) => checkTypeRef(r, null, null, 'u',
+              expectedKind: ReferenceKind.topLevelPropertyAccessor),
+          (EntityRef r) => checkTypeRef(r, null, null, 'f',
+              expectedKind: ReferenceKind.topLevelFunction)
+        ]);
   }
 
   test_expr_throwException() {
     if (skipNonConstInitializers) {
       return;
     }
     UnlinkedVariable variable = serializeVariableText('''
 final v = throw 1 + 2;
 ''');
-    _assertUnlinkedConst(variable.constExpr, isValidConst: false, operators: [
-      UnlinkedConstOperation.pushInt,
-      UnlinkedConstOperation.pushInt,
-      UnlinkedConstOperation.add,
-      UnlinkedConstOperation.throwException,
-    ], ints: [
-      1,
-      2
-    ]);
+    _assertUnlinkedConst(variable.initializer.bodyExpr,
+        isValidConst: false,
+        operators: [
+          UnlinkedConstOperation.pushInt,
+          UnlinkedConstOperation.pushInt,
+          UnlinkedConstOperation.add,
+          UnlinkedConstOperation.throwException,
+        ],
+        ints: [
+          1,
+          2
+        ]);
   }
 
   test_expr_typeCast() {
     if (skipNonConstInitializers) {
       return;
     }
     UnlinkedVariable variable = serializeVariableText('''
 final v = 42 as num;
 ''');
-    _assertUnlinkedConst(variable.constExpr, isValidConst: false, operators: [
-      UnlinkedConstOperation.pushInt,
-      UnlinkedConstOperation.typeCast,
-    ], ints: [
-      42
-    ], referenceValidators: [
-      (EntityRef r) => checkTypeRef(r, 'dart:core', 'dart:core', 'num',
-          expectedKind: ReferenceKind.classOrEnum)
-    ]);
+    _assertUnlinkedConst(variable.initializer.bodyExpr,
+        isValidConst: false,
+        operators: [
+          UnlinkedConstOperation.pushInt,
+          UnlinkedConstOperation.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.constExpr, isValidConst: false, operators: [
-      UnlinkedConstOperation.pushInt,
-      UnlinkedConstOperation.typeCheck,
-    ], ints: [
-      42
-    ], referenceValidators: [
-      (EntityRef r) => checkTypeRef(r, 'dart:core', 'dart:core', 'num',
-          expectedKind: ReferenceKind.classOrEnum)
-    ]);
+    _assertUnlinkedConst(variable.initializer.bodyExpr,
+        isValidConst: false,
+        operators: [
+          UnlinkedConstOperation.pushInt,
+          UnlinkedConstOperation.typeCheck,
+        ],
+        ints: [
+          42
+        ],
+        referenceValidators: [
+          (EntityRef r) => checkTypeRef(r, 'dart:core', 'dart:core', 'num',
+              expectedKind: ReferenceKind.classOrEnum)
+        ]);
   }
 
   test_field() {
     UnlinkedClass cls = serializeClassText('class C { int i; }');
     UnlinkedVariable variable = findVariable('i', variables: cls.fields);
     expect(variable, isNotNull);
     expect(variable.isConst, isFalse);
     expect(variable.isStatic, isFalse);
     expect(variable.isFinal, isFalse);
-    expect(variable.constExpr, isNull);
+    expect(variable.initializer, isNull);
     expect(findExecutable('i', executables: cls.executables), isNull);
     expect(findExecutable('i=', executables: cls.executables), isNull);
     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.constExpr,
+    _assertUnlinkedConst(variable.initializer.bodyExpr,
         operators: [UnlinkedConstOperation.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.constExpr,
+    _assertUnlinkedConst(variable.initializer.bodyExpr,
         operators: [UnlinkedConstOperation.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.constExpr, isValidConst: false, operators: [
-      UnlinkedConstOperation.pushInt,
-      UnlinkedConstOperation.invokeMethodRef,
-      UnlinkedConstOperation.add,
-    ], ints: [
-      1,
-      0,
-      0
-    ], strings: [], referenceValidators: [
-      (EntityRef r) => checkTypeRef(r, null, null, 'm',
-              expectedKind: ReferenceKind.method,
-              prefixExpectations: [
-                new _PrefixExpectation(ReferenceKind.classOrEnum, 'C')
-              ])
-    ]);
+    _assertUnlinkedConst(variable.initializer.bodyExpr,
+        isValidConst: false,
+        operators: [
+          UnlinkedConstOperation.pushInt,
+          UnlinkedConstOperation.invokeMethodRef,
+          UnlinkedConstOperation.add,
+        ],
+        ints: [
+          1,
+          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.constExpr,
+    _assertUnlinkedConst(variable.initializer.bodyExpr,
         operators: [UnlinkedConstOperation.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');
@@ skipping 67 matching lines @@
   test_field_propagated_type_final_immediate() {
     UnlinkedVariable v =
         serializeClassText('class C { final v = 0; }').fields[0];
     checkLinkedTypeSlot(v.propagatedTypeSlot, 'dart:core', 'dart:core', 'int');
   }
 
   test_field_static() {
     UnlinkedVariable variable =
         serializeClassText('class C { static int i; }').fields[0];
     expect(variable.isStatic, isTrue);
-    expect(variable.constExpr, isNull);
+    expect(variable.initializer, isNull);
     expect(unlinkedUnits[0].publicNamespace.names, hasLength(1));
     expect(unlinkedUnits[0].publicNamespace.names[0].name, 'C');
     expect(unlinkedUnits[0].publicNamespace.names[0].members, hasLength(1));
     expect(unlinkedUnits[0].publicNamespace.names[0].members[0].name, 'i');
     expect(unlinkedUnits[0].publicNamespace.names[0].members[0].kind,
         ReferenceKind.propertyAccessor);
     expect(
         unlinkedUnits[0].publicNamespace.names[0].members[0].numTypeParameters,
         0);
     expect(
         unlinkedUnits[0].publicNamespace.names[0].members[0].members, isEmpty);
   }
 
   test_field_static_final() {
     UnlinkedVariable variable =
         serializeClassText('class C { static final int i = 0; }').fields[0];
     expect(variable.isStatic, isTrue);
     expect(variable.isFinal, isTrue);
-    expect(variable.constExpr, isNull);
+    expect(variable.initializer.bodyExpr, isNull);
   }
 
   test_field_static_final_untyped() {
     if (!checkAstDerivedData) {
       // The element model doesn't contain the initializer expressions needed
       // for type inference.  TODO(paulberry): fix.
       return;
     }
     UnlinkedVariable variable =
         serializeClassText('class C { static final x = 0; }').fields[0];
-    expect(variable.constExpr, isNotNull);
+    expect(variable.initializer.bodyExpr, isNotNull);
   }
 
   test_field_untyped() {
     if (!checkAstDerivedData) {
       // The element model doesn't contain the initializer expressions needed
       // for type inference.  TODO(paulberry): fix.
       return;
     }
     UnlinkedVariable variable =
         serializeClassText('class C { var x = 0; }').fields[0];
-    expect(variable.constExpr, isNotNull);
+    expect(variable.initializer.bodyExpr, isNotNull);
   }
 
   test_fully_linked_references_follow_other_references() {
     if (skipFullyLinkedData) {
       return;
     }
     serializeLibraryText('final x = 0; String y;');
     checkLinkedTypeSlot(unlinkedUnits[0].variables[0].propagatedTypeSlot,
         'dart:core', 'dart:core', 'int');
     checkTypeRef(
@@ skipping 2388 matching lines @@
 
   test_variable_explicit_dynamic() {
     UnlinkedVariable variable = serializeVariableText('dynamic v;');
     checkDynamicTypeRef(variable.type);
   }
 
   test_variable_final_top_level() {
     UnlinkedVariable variable =
         serializeVariableText('final int i = 0;', variableName: 'i');
     expect(variable.isFinal, isTrue);
-    expect(variable.constExpr, isNull);
+    expect(variable.initializer.bodyExpr, isNull);
   }
 
   test_variable_final_top_level_untyped() {
     if (!checkAstDerivedData) {
       // The element model doesn't contain the initializer expressions needed
       // for type inference.  TODO(paulberry): fix.
       return;
     }
     UnlinkedVariable variable = serializeVariableText('final v = 0;');
-    expect(variable.constExpr, isNotNull);
+    expect(variable.initializer.bodyExpr, isNotNull);
   }
 
   test_variable_implicit_dynamic() {
     UnlinkedVariable variable = serializeVariableText('var v;');
     expect(variable.type, isNull);
   }
 
   test_variable_inferred_type_explicit_initialized() {
     UnlinkedVariable v = serializeVariableText('int v = 0;');
     expect(v.inferredTypeSlot, 0);
@@ skipping 214 matching lines @@
    */
   void _assertAssignmentOperator(
       String expr, UnlinkedExprAssignOperator expectedAssignOperator) {
     if (skipNonConstInitializers) {
       return;
     }
     UnlinkedVariable variable = serializeVariableText('''
 int a = 0;
 final v = $expr;
     ''');
-    _assertUnlinkedConst(variable.constExpr, isValidConst: false, operators: [
-      UnlinkedConstOperation.pushInt,
-      UnlinkedConstOperation.pushInt,
-      UnlinkedConstOperation.add,
-      UnlinkedConstOperation.assignToRef,
-      UnlinkedConstOperation.pushInt,
-      UnlinkedConstOperation.add,
-    ], assignmentOperators: [
-      expectedAssignOperator
-    ], ints: [
-      1,
-      2,
-      3
-    ], strings: [], referenceValidators: [
-      (EntityRef r) => checkTypeRef(r, null, null, 'a',
-          expectedKind: ReferenceKind.topLevelPropertyAccessor)
-    ]);
+    _assertUnlinkedConst(variable.initializer.bodyExpr,
+        isValidConst: false,
+        operators: [
+          UnlinkedConstOperation.pushInt,
+          UnlinkedConstOperation.pushInt,
+          UnlinkedConstOperation.add,
+          UnlinkedConstOperation.assignToRef,
+          UnlinkedConstOperation.pushInt,
+          UnlinkedConstOperation.add,
+        ],
+        assignmentOperators: [
+          expectedAssignOperator
+        ],
+        ints: [
+          1,
+          2,
+          3
+        ],
+        strings: [],
+        referenceValidators: [
+          (EntityRef r) => checkTypeRef(r, null, null, 'a',
+              expectedKind: ReferenceKind.topLevelPropertyAccessor)
+        ]);
   }
 
   void _assertCodeRange(CodeRange codeRange, int offset, int length) {
     expect(codeRange, isNotNull);
     expect(codeRange.offset, offset);
     expect(codeRange.length, length);
   }
 
   void _assertExecutableVisible(String code, UnlinkedExecutable f,
       String visibleBegin, String visibleEnd) {
@@ skipping 24 matching lines @@
    */
   void _assertRefPrefixPostfixIncrementDecrement(
       String expr, UnlinkedExprAssignOperator expectedAssignmentOperator) {
     if (skipNonConstInitializers) {
       return;
     }
     UnlinkedVariable variable = serializeVariableText('''
 int a = 0;
 final v = $expr;
 ''');
-    _assertUnlinkedConst(variable.constExpr, isValidConst: false, operators: [
-      UnlinkedConstOperation.assignToRef,
-      UnlinkedConstOperation.pushInt,
-      UnlinkedConstOperation.add,
-    ], assignmentOperators: [
-      expectedAssignmentOperator
-    ], ints: [
-      2
-    ], strings: [], referenceValidators: [
-      (EntityRef r) => checkTypeRef(r, null, null, 'a',
-          expectedKind: ReferenceKind.topLevelPropertyAccessor)
-    ]);
+    _assertUnlinkedConst(variable.initializer.bodyExpr,
+        isValidConst: false,
+        operators: [
+          UnlinkedConstOperation.assignToRef,
+          UnlinkedConstOperation.pushInt,
+          UnlinkedConstOperation.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,
       {bool isValidConst: true,
       List<UnlinkedConstOperation> operators: const <UnlinkedConstOperation>[],
       List<UnlinkedExprAssignOperator> assignmentOperators:
           const <UnlinkedExprAssignOperator>[],
@@ skipping 31 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});
 }