All initializer expressions are serialized, even if not all of them are constants.

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 24 matching lines @@
 main() {
   groupSep = ' | ';
   runReflectiveTests(ResynthesizeElementTest);
 }
 
 /**
  * Abstract base class for resynthesizing and comparing elements.
  */
 abstract class AbstractResynthesizeTest extends AbstractSingleUnitTest {
   Set<Source> otherLibrarySources = new Set<Source>();
-  bool constantInitializersAreInvalid = false;
 
   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 272 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);
-        if (constantInitializersAreInvalid) {
-          _assertUnresolvedIdentifier(rItem.expression, desc);
-        } else {
-          compareConstAsts(rItem.expression, oItem.expression, desc);
-        }
+        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 51 matching lines @@
         // resynthesized as `topLevelVariableName.length`
         PrefixedIdentifier oTarget = o.target;
         checkElidablePrefix(oTarget.prefix);
         compareConstAsts(
             r, AstFactory.identifier(oTarget.identifier, o.propertyName), desc);
       } else if (o is PrefixedIdentifier && r is PrefixedIdentifier) {
         compareConstAsts(r.prefix, o.prefix, desc);
         compareConstAsts(r.identifier, o.identifier, desc);
       } else if (o is PropertyAccess && r is PropertyAccess) {
         compareConstAsts(r.target, o.target, desc);
-        expect(r.propertyName.name, o.propertyName.name, reason: desc);
-        compareElements(
-            r.propertyName.staticElement, o.propertyName.staticElement, desc);
+        String oName = o.propertyName.name;
+        String rName = r.propertyName.name;
+        expect(rName, oName, reason: desc);
+        if (oName == 'length') {
+          compareElements(
+              r.propertyName.staticElement, o.propertyName.staticElement, desc);
+        }
       } else if (o is PropertyAccess &&
           o.target is PrefixedIdentifier &&
           r is SimpleIdentifier) {
         // We don't resynthesize property access when it takes the form
         // `prefixName.className.staticMember`.  We just resynthesize a
         // SimpleIdentifier correctly resolved to the static member.
         PrefixedIdentifier oTarget = o.target;
         checkElidablePrefix(oTarget.prefix);
         checkElidablePrefix(oTarget.identifier);
         compareConstAsts(r, o.propertyName, desc);
@@ skipping 645 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;
-        if (constantInitializersAreInvalid) {
-          _assertUnresolvedIdentifier(initializer, desc);
-        } else {
-          compareConstAsts(initializer, originalActual.constantInitializer,
-              '$desc initializer');
-        }
+        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() {
-    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 1885 matching lines @@
       fail('Unexpectedly tried to get unlinked summary for $uri');
     }
     return serializedUnit;
   }
 
   @override
   bool hasLibrarySummary(String uri) {
     return true;
   }
 }