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, operators: [
+    _assertUnlinkedConst(variable.constExpr, isValidConst: false, operators: [
       UnlinkedConstOperation.pushReference,
       //   ..[1] = 2
       UnlinkedConstOperation.cascadeSectionBegin,
       UnlinkedConstOperation.pushInt,
       UnlinkedConstOperation.pushInt,
       UnlinkedConstOperation.assignToIndex,
       // c
       UnlinkedConstOperation.cascadeSectionEnd,
     ], assignmentOperators: [
       UnlinkedExprAssignOperator.assign,
@@ skipping 14 matching lines @@
     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 28 matching lines @@
   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_functionExpression_asArgument() {
     if (skipNonConstInitializers) {
       return;
     }
     UnlinkedVariable variable = serializeVariableText('''
 final v = foo(5, () => 42);
 foo(a, b) {}
 ''');
-    _assertUnlinkedConst(variable.constExpr, operators: [
+    _assertUnlinkedConst(variable.constExpr, isValidConst: false, operators: [
       UnlinkedConstOperation.pushInt,
       UnlinkedConstOperation.pushNull,
       UnlinkedConstOperation.invokeMethodRef
     ], ints: [
       5,
       0,
       2
     ], 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,
-        operators: [UnlinkedConstOperation.pushNull]);
+        isValidConst: false, operators: [UnlinkedConstOperation.pushNull]);
   }
 
   test_expr_functionExpression_withExpressionBody() {
     if (skipNonConstInitializers) {
       return;
     }
     UnlinkedVariable variable = serializeVariableText('''
 final v = () => 42;
 ''');
     _assertUnlinkedConst(variable.constExpr,
-        operators: [UnlinkedConstOperation.pushNull]);
+        isValidConst: false, operators: [UnlinkedConstOperation.pushNull]);
   }
 
   test_expr_functionExpressionInvocation_withBlockBody() {
     if (skipNonConstInitializers) {
       return;
     }
     UnlinkedVariable variable = serializeVariableText('''
 final v = ((a, b) {return 42;})(1, 2);
 ''');
     _assertUnlinkedConst(variable.constExpr,
-        operators: [UnlinkedConstOperation.pushNull]);
+        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,
-        operators: [UnlinkedConstOperation.pushNull]);
+        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, 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'),
                 new _PrefixExpectation(ReferenceKind.prefix, 'p')
               ])
     ]);
   }
 
   test_expr_throwException() {
     if (skipNonConstInitializers) {
       return;
     }
     UnlinkedVariable variable = serializeVariableText('''
 final v = throw 1 + 2;
 ''');
-    _assertUnlinkedConst(variable.constExpr, operators: [
+    _assertUnlinkedConst(variable.constExpr, 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, operators: [
+    _assertUnlinkedConst(variable.constExpr, isValidConst: false, operators: [
       UnlinkedConstOperation.pushInt,
       UnlinkedConstOperation.pushReference,
       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, operators: [
+    _assertUnlinkedConst(variable.constExpr, isValidConst: false, operators: [
       UnlinkedConstOperation.pushInt,
       UnlinkedConstOperation.pushReference,
       UnlinkedConstOperation.typeCheck,
     ], ints: [
       42
     ], referenceValidators: [
       (EntityRef r) => checkTypeRef(r, 'dart:core', 'dart:core', 'num',
           expectedKind: ReferenceKind.classOrEnum)
     ]);
   }
@@ skipping 39 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});
 }