Serialize static constant field references.

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

Index: pkg/analyzer/lib/src/summary/summarize_const_expr.dart
diff --git a/pkg/analyzer/lib/src/summary/summarize_const_expr.dart b/pkg/analyzer/lib/src/summary/summarize_const_expr.dart
index 9305cfbebfad883c1428d39337a8683da1afdb07..f9931c816579e56b6b8cdeb6b16f1dcb884ee108 100644
--- a/pkg/analyzer/lib/src/summary/summarize_const_expr.dart
+++ b/pkg/analyzer/lib/src/summary/summarize_const_expr.dart
@@ -92,9 +92,14 @@ abstract class AbstractConstExprSerializer {
       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 {
@@ -108,6 +113,11 @@ abstract class AbstractConstExprSerializer {
   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);