Use isValidConst flag to distinguish between const / final expressions.

pkg/analyzer/test/src/summary/resynthesize_test.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 test.src.serialization.elements_test;
 
 import 'dart:convert';
 
 import 'package:analyzer/dart/ast/ast.dart';
 import 'package:analyzer/dart/constant/value.dart';
@@ skipping 129 matching lines @@
         context.computeLibraryElement(context.sourceFactory.forUri(uri));
     LibraryElementImpl resynthesized = resynthesizeLibraryElement(
         encodeLibraryElement(original), uri, original);
     checkLibraryElements(original, resynthesized);
   }
 }
 
 @reflectiveTest
 abstract class ResynthesizeTest extends AbstractSingleUnitTest {
   Set<Source> otherLibrarySources = new Set<Source>();
+  bool constantInitializersAreInvalid = false;
 
   bool get checkPropagatedTypes => true;
 
   void addLibrary(String uri) {
     otherLibrarySources.add(context.sourceFactory.forUri(uri));
   }
 
   void addLibrarySource(String filePath, String contents) {
     otherLibrarySources.add(addSource(filePath, contents));
   }
@@ skipping 263 matching lines @@
         expect(rItem.value, oItem.value);
       } else if (rItem is InterpolationExpression &&
           oItem is InterpolationExpression) {
         compareConstAsts(rItem.expression, oItem.expression, desc);
       } else if (rItem is MapLiteralEntry && oItem is MapLiteralEntry) {
         compareConstAsts(rItem.key, oItem.key, desc);
         compareConstAsts(rItem.value, oItem.value, desc);
       } else if (oItem is ConstructorFieldInitializer &&
           rItem is ConstructorFieldInitializer) {
         compareConstAsts(rItem.fieldName, oItem.fieldName, desc);
-        compareConstAsts(rItem.expression, oItem.expression, desc);
+        if (constantInitializersAreInvalid) {
+          _assertUnresolvedIdentifier(rItem.expression, desc);
+        } else {
+          compareConstAsts(rItem.expression, oItem.expression, desc);
+        }
       } else if (oItem is SuperConstructorInvocation &&
           rItem is SuperConstructorInvocation) {
         compareElements(rItem.staticElement, oItem.staticElement, desc);
         compareConstAsts(rItem.constructorName, oItem.constructorName, desc);
         compareConstAstLists(
             rItem.argumentList.arguments, oItem.argumentList.arguments, desc);
       } else if (oItem is RedirectingConstructorInvocation &&
           rItem is RedirectingConstructorInvocation) {
         compareElements(rItem.staticElement, oItem.staticElement, desc);
         compareConstAsts(rItem.constructorName, oItem.constructorName, desc);
@@ skipping 712 matching lines @@
     VariableElementImpl originalActual = getActualElement(original, desc);
     compareFunctionElements(resynthesizedActual.initializer,
         originalActual.initializer, '$desc initializer');
     if (originalActual is ConstVariableElement) {
       Element oEnclosing = original.enclosingElement;
       if (oEnclosing is ClassElement && oEnclosing.isEnum) {
         compareConstValues(
             resynthesized.constantValue, original.constantValue, desc);
       } else {
         Expression initializer = resynthesizedActual.constantInitializer;
-        compareConstAsts(initializer, originalActual.constantInitializer,
-            '$desc initializer');
+        if (constantInitializersAreInvalid) {
+          _assertUnresolvedIdentifier(initializer, desc);
+        } else {
+          compareConstAsts(initializer, originalActual.constantInitializer,
+              '$desc initializer');
+        }
       }
     }
     checkPossibleMember(resynthesized, original, desc);
     checkPossibleLocalElements(resynthesized, original);
   }
 
   DartSdk createDartSdk() => AbstractContextTest.SHARED_MOCK_SDK;
 
   /**
    * Determine the analysis options that should be used for this test.
@@ skipping 106 matching lines @@
       return false;
     }
   }
 
   @override
   void setUp() {
     super.setUp();
     prepareAnalysisContext(createOptions());
   }
 
-  test_const_invalid_field_const() {
-    checkLibrary(
-        r'''
-class C {
-  static const f = 1 + foo();
-}
-int foo() => 42;
-''',
-        allowErrors: true);
-  }
-
   test_class_abstract() {
     checkLibrary('abstract class C {}');
   }
 
   test_class_alias() {
     checkLibrary('class C = D with E, F; class D {} class E {} class F {}');
   }
 
   test_class_alias_abstract() {
     checkLibrary('abstract class C = D with E; class D {} class E {}');
@@ skipping 317 matching lines @@
 
   test_closure_executable_with_return_type_from_closure() {
     checkLibrary('''
 f() {
   print(() {});
   print(() => () => 0);
 }
 ''');
   }
 
-  test_const_invalid_field_final() {
+  test_const_invalid_field_const() {
+    constantInitializersAreInvalid = true;
     checkLibrary(
         r'''
 class C {
+  static const f = 1 + foo();
+}
+int foo() => 42;
+''',
+        allowErrors: true);
+  }
+
+  test_const_invalid_field_final() {
+    constantInitializersAreInvalid = true;
+    checkLibrary(
+        r'''
+class C {
   final f = 1 + foo();
 }
 int foo() => 42;
 ''',
         allowErrors: true);
   }
 
   test_const_invalid_topLevel() {
+    constantInitializersAreInvalid = true;
     checkLibrary(
         r'''
 const v = 1 + foo();
 int foo() => 42;
 ''',
         allowErrors: true);
   }
 
   test_const_invokeConstructor_generic_named() {
     checkLibrary(r'''
@@ skipping 722 matching lines @@
   test_constructor_initializers_field() {
     checkLibrary('''
 class C {
   final x;
   const C() : x = 42;
 }
 ''');
   }
 
   test_constructor_initializers_field_notConst() {
+    constantInitializersAreInvalid = true;
     checkLibrary(
         '''
 class C {
   final x;
   const A() : x = foo();
 }
 int foo() => 42;
 ''',
         allowErrors: true);
   }
@@ skipping 1880 matching lines @@
       fail('Unexpectedly tried to get unlinked summary for $uri');
     }
     return serializedUnit;
   }
 
   @override
   bool hasLibrarySummary(String uri) {
     return true;
   }
 }