Serialize static constant field references.

pkg/analyzer/lib/src/summary/summarize_const_expr.dart

 // Copyright (c) 2016, 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 serialization.summarize_const_expr;
 
 import 'package:analyzer/src/generated/ast.dart';
 import 'package:analyzer/src/generated/scanner.dart';
 import 'package:analyzer/src/summary/format.dart';
 
@@ skipping 74 matching lines @@
       operations.add(UnlinkedConstOperation.identical);
     } else if (expr is BinaryExpression) {
       _serializeBinaryExpression(expr);
     } else if (expr is ConditionalExpression) {
       serialize(expr.condition);
       serialize(expr.thenExpression);
       serialize(expr.elseExpression);
       operations.add(UnlinkedConstOperation.conditional);
     } else if (expr is PrefixExpression) {
       _serializePrefixExpression(expr);
-    } else if (expr is PropertyAccess && expr.propertyName.name == 'length') {
-      serialize(expr.target);
-      operations.add(UnlinkedConstOperation.length);
+    } else if (expr is PropertyAccess) {
+      if (expr.propertyName.name == 'length') {
+        serialize(expr.target);

[Paul Berry, 2016/01/26 20:52:49]

There's two ambiguities with `length` that I think we need to be careful about:

const x = a.b.length;
const y = c.length;

Either of these could either be UnlinkedConstOperation.length, or a reference to
a static const field called `length`, depending on the definitions of `a`, `b`,
and `c`.  (`y` could also be a reference to a top level variable called
`length`, if `c` is an import prefix).  Since we want to be able to summarize an
AST without consulting resolution information, we need to provisionally resolve
the ambiguity one way, and then fix it up during resynthesis.

If I'm reading your code right, it looks like `a.b.length` will be encoded using
UnlinkedConstOperation.length, but `c.length` will be encoded using
UnlinkedConstOperation.pushReference (because it will be interpreted as a
prefixed identifier).

Personally, I'd prefer to consistently serialize these cases using
UnlinkedConstOperation.pushReference, because I think the fix up will be easier
in that direction.

If you want to just put in a TODO comment for now and return to this ambiguous
case later, that's fine with me.

[scheglov, 2016/01/26 21:02:29]

I added TODO and will fix it soon.

+        operations.add(UnlinkedConstOperation.length);
+      } else {
+        references.add(serializePropertyAccess(expr));
+        operations.add(UnlinkedConstOperation.pushReference);
+      }
     } else if (expr is ParenthesizedExpression) {
       serialize(expr.expression);
     } else {
       throw new _ConstExprSerializationError('Unknown expression type: $expr');
     }
   }
 
   /**
    * Return [EntityRefBuilder] that corresponds to the given [identifier].
    */
   EntityRefBuilder serializeIdentifier(Identifier identifier);
 
   /**
+   * Return [EntityRefBuilder] that corresponds to the given [access].
+   */
+  EntityRefBuilder serializePropertyAccess(PropertyAccess access);
+
+  /**
    * Return [EntityRefBuilder] that corresponds to the given [type].
    */
   EntityRefBuilder serializeType(TypeName type);
 
   /**
    * Return [EntityRefBuilder] that corresponds to the given [constructor].
    */
   EntityRefBuilder serializeConstructorName(ConstructorName constructor);
 
   /**
@@ skipping 167 matching lines @@
  * Error that describes a problem during a constant expression serialization.
  */
 class _ConstExprSerializationError {
   final String message;
 
   _ConstExprSerializationError(this.message);
 
   @override
   String toString() => message;
 }