Finer grain control over specifying which variables have invalid constant initializers.

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 25 matching lines @@
   groupSep = ' | ';
   runReflectiveTests(ResynthesizeElementTest);
 }
 
 /**
  * Abstract base class for resynthesizing and comparing elements.
  */
 abstract class AbstractResynthesizeTest extends AbstractSingleUnitTest {
   Set<Source> otherLibrarySources = new Set<Source>();
 
+  /**
+   * Names of variables which have initializers that are not valid constants,
+   * so they are not resynthesized.
+   */
+  Set<String> variablesWithNotConstInitializers = new Set<String>();
+
   bool get checkPropagatedTypes => true;
 
   /**
    * Derived classes can override this getter to return `true` in order to
    * cause certain checks to be skipped if they are known to fail with
    * AST-based type inference.
    *
    * TODO(paulberry): remove this flag once AST-based type inference is fully
    * working.
    */
@@ skipping 271 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 (variablesWithNotConstInitializers.contains(rItem.fieldName.name)) {
+          _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 723 matching lines @@
       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 (variablesWithNotConstInitializers.contains(resynthesized.name)) {
+          _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 95 matching lines @@
       expect(type.isDynamic || type.isVoid, isTrue);
       return false;
     }
   }
 
   @override
   void setUp() {
     super.setUp();
     prepareAnalysisContext(createOptions());
   }
+
+  void _assertUnresolvedIdentifier(Expression initializer, String desc) {
+    expect(initializer, new isInstanceOf<SimpleIdentifier>(), reason: desc);
+    SimpleIdentifier identifier = initializer;
+    expect(identifier.staticElement, isNull, reason: desc);
+  }
 }
 
 @reflectiveTest
 class ResynthesizeElementTest extends ResynthesizeTest {
   @override
   LibraryElementImpl checkLibrary(String text,
       {bool allowErrors: false, bool dumpSummaries: false}) {
     Source source = addTestSource(text);
     LibraryElementImpl original = context.computeLibraryElement(source);
     LibraryElementImpl resynthesized = resynthesizeLibraryElement(
@@ skipping 442 matching lines @@
   test_closure_executable_with_return_type_from_closure() {
     checkLibrary('''
 f() {
   print(() {});
   print(() => () => 0);
 }
 ''');
   }
 
   test_const_invalid_field_const() {
+    variablesWithNotConstInitializers.add('f');
     checkLibrary(
         r'''
 class C {
   static const f = 1 + foo();
 }
 int foo() => 42;
 ''',
         allowErrors: true);
   }
 
   test_const_invalid_field_final() {
+    variablesWithNotConstInitializers.add('f');
     checkLibrary(
         r'''
 class C {
   final f = 1 + foo();
 }
 int foo() => 42;
 ''',
         allowErrors: true);
   }
 
   test_const_invalid_topLevel() {
+    variablesWithNotConstInitializers.add('v');
     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() {
+    variablesWithNotConstInitializers.add('x');
     checkLibrary(
         '''
 class C {
   final x;
   const A() : x = foo();
 }
 int foo() => 42;
 ''',
         allowErrors: true);
   }
@@ skipping 1917 matching lines @@
       fail('Unexpectedly tried to get unlinked summary for $uri');
     }
     return serializedUnit;
   }
 
   @override
   bool hasLibrarySummary(String uri) {
     return true;
   }
 }