Replace 'length' with more generic 'extractProperty' operation.

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/dart/ast/ast.dart';
 import 'package:analyzer/dart/ast/token.dart';
 import 'package:analyzer/src/summary/format.dart';
 import 'package:analyzer/src/summary/idl.dart';
@@ skipping 67 matching lines @@
    * and the given [name] is a constructor parameter reference.
    */
   bool isConstructorParameterName(String name);
 
   /**
    * Serialize the given [expr] expression into this serializer state.
    */
   void serialize(Expression expr) {
     try {
       _serialize(expr);
-    } on StateError {
+    } on StateError catch (e, st) {
       isInvalid = true;
     }
   }
 
   /**
    * Serialize the given [annotation] into this serializer state.
    */
   void serializeAnnotation(Annotation annotation);
 
   /**
    * Return [EntityRefBuilder] that corresponds to the constructor having name
    * [name] in the class identified by [type].
    */
   EntityRefBuilder serializeConstructorName(
       TypeName type, SimpleIdentifier name);
 
   /**
    * Return [EntityRefBuilder] that corresponds to the given [identifier].
    */
   EntityRefBuilder serializeIdentifier(Identifier identifier);
 
+  /**
+   * Return [EntityRefBuilder] that corresponds to the given [expr], which
+   * must be a sequence of identifiers.
+   */
+  EntityRefBuilder serializeIdentifierSequence(Expression expr);
+
   void serializeInstanceCreation(
       EntityRefBuilder constructor, ArgumentList argumentList) {
     List<Expression> arguments = argumentList.arguments;
     // Serialize the arguments.
     List<String> argumentNames = <String>[];
     arguments.forEach((arg) {
       if (arg is NamedExpression) {
         argumentNames.add(arg.name.label.name);
         _serialize(arg.expression);
       } else {
         _serialize(arg);
       }
     });
     // Add the op-code and numbers of named and positional arguments.
     operations.add(UnlinkedConstOperation.invokeConstructor);
     ints.add(argumentNames.length);
     strings.addAll(argumentNames);
     ints.add(arguments.length - argumentNames.length);
     // Serialize the reference.
     references.add(constructor);
   }
 
   /**
-   * 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 the [UnlinkedConstBuilder] that corresponds to the state of this
    * serializer.
    */
   UnlinkedConstBuilder toBuilder() {
     if (isInvalid) {
@@ skipping 82 matching lines @@
     } 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) {
-      if (expr.target is! PrefixedIdentifier &&
-          expr.propertyName.name == 'length') {
-        _serialize(expr.target);
-        operations.add(UnlinkedConstOperation.length);
-      } else {
-        references.add(serializePropertyAccess(expr));
-        operations.add(UnlinkedConstOperation.pushReference);
-      }
+      _serializePropertyAccess(expr);
     } else if (expr is ParenthesizedExpression) {
       _serialize(expr.expression);
     } else {
       throw new StateError('Unknown expression type: $expr');
     }
   }
 
   void _serializeBinaryExpression(BinaryExpression expr) {
     _serialize(expr.leftOperand);
     _serialize(expr.rightOperand);
@@ skipping 77 matching lines @@
       operations.add(UnlinkedConstOperation.not);
     } else if (operator == TokenType.MINUS) {
       operations.add(UnlinkedConstOperation.negate);
     } else if (operator == TokenType.TILDE) {
       operations.add(UnlinkedConstOperation.complement);
     } else {
       throw new StateError('Unknown operator: $operator');
     }
   }
 
+  void _serializePropertyAccess(PropertyAccess expr) {
+    if (_isIdentifierSequence(expr)) {
+      EntityRefBuilder ref = serializeIdentifierSequence(expr);
+      references.add(ref);
+      operations.add(UnlinkedConstOperation.pushReference);
+    } else {
+      _serialize(expr.target);
+      strings.add(expr.propertyName.name);
+      operations.add(UnlinkedConstOperation.extractProperty);
+    }
+  }
+
   void _serializeString(StringLiteral expr) {
     if (expr is AdjacentStrings) {
       if (expr.strings.every((string) => string is SimpleStringLiteral)) {
         operations.add(UnlinkedConstOperation.pushString);
         strings.add(expr.stringValue);
       } else {
         expr.strings.forEach(_serializeString);
         operations.add(UnlinkedConstOperation.concatenate);
         ints.add(expr.strings.length);
       }
     } else if (expr is SimpleStringLiteral) {
       operations.add(UnlinkedConstOperation.pushString);
       strings.add(expr.value);
     } else {
       StringInterpolation interpolation = expr as StringInterpolation;
       for (InterpolationElement element in interpolation.elements) {
         if (element is InterpolationString) {
           operations.add(UnlinkedConstOperation.pushString);
           strings.add(element.value);
         } else {
           _serialize((element as InterpolationExpression).expression);
         }
       }
       operations.add(UnlinkedConstOperation.concatenate);
       ints.add(interpolation.elements.length);
     }
   }
+
+  /**
+   * Return `true` if the given [expr] is a sequence of identifiers.
+   */
+  static bool _isIdentifierSequence(Expression expr) {
+    while (expr != null) {
+      if (expr is SimpleIdentifier) {
+        return true;
+      }
+      if (expr is PrefixedIdentifier) {
+        expr = (expr as PrefixedIdentifier).prefix;
+      } else if (expr is PropertyAccess) {
+        expr = (expr as PropertyAccess).target;
+      } else {
+        return false;
+      }
+    }
+    return false;
+  }
 }