Use isValidConst flag to distinguish between const / final expressions.

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 5939 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, operators: [
+    _assertUnlinkedConst(variable.constExpr, isValidConst: false, operators: [
       UnlinkedConstOperation.pushInt,
       UnlinkedConstOperation.pushReference,
       UnlinkedConstOperation.pushInt,
       UnlinkedConstOperation.assignToIndex,
     ], assignmentOperators: [
       (UnlinkedExprAssignOperator.assign)
     ], ints: [
       5,
       1
     ], strings: [], referenceValidators: [
@@ skipping 18 matching lines @@
 }
 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, operators: [
+    _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,
@@ skipping 20 matching lines @@
   }
 
   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, operators: [
+    _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)
     ]);
   }
 
   test_expr_assignToProperty_ofInstanceCreation() {
     if (skipNonConstInitializers) {
       return;
     }
     UnlinkedVariable variable = serializeVariableText('''
 class C {
   int f;
 }
 final v = (new C().f = 5);
 ''');
-    _assertUnlinkedConst(variable.constExpr, operators: [
+    _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)
     ]);
   }
 
   test_expr_assignToRef_classStaticField() {
     if (skipNonConstInitializers) {
       return;
     }
     UnlinkedVariable variable = serializeVariableText('''
 class C {
   static int f;
 }
 final v = (C.f = 1);
 ''');
-    _assertUnlinkedConst(variable.constExpr, operators: [
+    _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: [
@@ skipping 12 matching lines @@
 }
 class B {
   C c;
 }
 class C {
   int f;
 }
 A a = new A();
 final v = (a.b.c.f = 1);
 ''');
-    _assertUnlinkedConst(variable.constExpr, operators: [
+    _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: [
@@ skipping 26 matching lines @@
   }
 
   test_expr_assignToRef_topLevelVariable() {
     if (skipNonConstInitializers) {
       return;
     }
     UnlinkedVariable variable = serializeVariableText('''
 int a = 0;
 final v = (a = 1);
 ''');
-    _assertUnlinkedConst(variable.constExpr, operators: [
+    _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)
     ]);
   }
 
   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, operators: [
+    _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)
     ]);
   }
 
   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, operators: [
+    _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');
       }
     ]);
   }
 
+  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'),
+              ])
+    ]);
+  }
+
   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, operators: [
+    _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,
@@ skipping 10 matching lines @@
       2, // f2 += 2
     ], strings: [
       'f1',
       'f2',
     ], referenceValidators: [
       (EntityRef r) => checkTypeRef(r, null, null, 'C',
           expectedKind: ReferenceKind.classOrEnum)
     ]);
   }
 
-  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, 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_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, operators: [
+    _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()
@@ skipping 41 matching lines @@
     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, operators: [
+    _assertUnlinkedConst(variable.constExpr, isValidConst: false, operators: [
       // a
       UnlinkedConstOperation.pushReference,
       //   ..m(5)
       UnlinkedConstOperation.cascadeSectionBegin,
       UnlinkedConstOperation.pushInt,
       UnlinkedConstOperation.invokeMethod,
       //   ..abs()
       UnlinkedConstOperation.invokeMethod,
       // a
       UnlinkedConstOperation.cascadeSectionEnd,
@@ skipping 20 matching lines @@
   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, operators: [
+    _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)
     ]);
   }
 
   test_expr_extractProperty_ofInvokeConstructor() {
     if (skipNonConstInitializers) {
       return;
     }
     UnlinkedVariable variable = serializeVariableText('''
 class C {
   int f = 0;
 }
 final v = new C().f;
 ''');
-    _assertUnlinkedConst(variable.constExpr, operators: [
+    _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)
     ]);
   }
 
   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, operators: [
+    _assertUnlinkedConst(variable.constExpr, isValidConst: false, operators: [
       UnlinkedConstOperation.invokeConstructor,
       UnlinkedConstOperation.pushInt,
       UnlinkedConstOperation.pushInt,
       UnlinkedConstOperation.pushInt,
       UnlinkedConstOperation.invokeMethod,
     ], ints: [
       0,
       0,
       1,
       2,
@@ skipping 20 matching lines @@
 }
 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, operators: [
+    _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',
@@ skipping 15 matching lines @@
         '/a.dart',
         '''
 class C {
   static int m() => 42;
 }
 ''');
     UnlinkedVariable variable = serializeVariableText('''
 import 'a.dart' as p;
 final v = p.C.m();
 ''');
-    _assertUnlinkedConst(variable.constExpr, operators: [
+    _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'),
@@ skipping 43 matching lines @@
         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, operators: [
+    _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,
@@ skipping 2388 matching lines @@
    */
   void _assertAssignmentOperator(
       String expr, UnlinkedExprAssignOperator expectedAssignOperator) {
     if (skipNonConstInitializers) {
       return;
     }
     UnlinkedVariable variable = serializeVariableText('''
 int a = 0;
 final v = $expr;
     ''');
-    _assertUnlinkedConst(variable.constExpr, operators: [
+    _assertUnlinkedConst(variable.constExpr, isValidConst: false, operators: [
       UnlinkedConstOperation.pushInt,
       UnlinkedConstOperation.pushInt,
       UnlinkedConstOperation.add,
       UnlinkedConstOperation.assignToRef,
       UnlinkedConstOperation.pushInt,
       UnlinkedConstOperation.add,
     ], assignmentOperators: [
       expectedAssignOperator
     ], ints: [
       1,
@@ skipping 40 matching lines @@
    */
   void _assertRefPrefixPostfixIncrementDecrement(
       String expr, UnlinkedExprAssignOperator expectedAssignmentOperator) {
     if (skipNonConstInitializers) {
       return;
     }
     UnlinkedVariable variable = serializeVariableText('''
 int a = 0;
 final v = $expr;
 ''');
-    _assertUnlinkedConst(variable.constExpr, operators: [
+    _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)
     ]);
   }
 
   /**
    * TODO(scheglov) rename "Const" to "Expr" everywhere
    */
   void _assertUnlinkedConst(UnlinkedConst constExpr,
-      {bool isInvalid: false,
+      {bool isValidConst: true,
       List<UnlinkedConstOperation> operators: const <UnlinkedConstOperation>[],
       List<UnlinkedExprAssignOperator> assignmentOperators:
           const <UnlinkedExprAssignOperator>[],
       List<int> ints: const <int>[],
       List<double> doubles: const <double>[],
       List<String> strings: const <String>[],
       List<_EntityRefValidator> referenceValidators:
           const <_EntityRefValidator>[]}) {
     expect(constExpr, isNotNull);
-    expect(constExpr.isInvalid, isInvalid);
+    expect(constExpr.isValidConst, isValidConst);
     expect(constExpr.operations, operators);
     expect(constExpr.ints, ints);
     expect(constExpr.doubles, doubles);
     expect(constExpr.strings, strings);
     expect(constExpr.assignmentOperators, assignmentOperators);
     expect(constExpr.references, hasLength(referenceValidators.length));
     for (int i = 0; i < referenceValidators.length; i++) {
       referenceValidators[i](constExpr.references[i]);
     }
   }
@@ skipping 14 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});
 }