Fix handling of identifier sequences starting with a function parameter.

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/dart/element/type.dart' show DartType;
 import 'package:analyzer/src/summary/format.dart';
@@ skipping 199 matching lines @@
         _serialize(expr.target);
       }
       strings.add(expr.propertyName.name);
       operations.add(UnlinkedConstOperation.assignToProperty);
     } else if (expr is IndexExpression) {
       if (!expr.isCascaded) {
         _serialize(expr.target);
       }
       _serialize(expr.index);
       operations.add(UnlinkedConstOperation.assignToIndex);
+    } else if (expr is PrefixedIdentifier) {
+      strings.add(expr.prefix.name);
+      operations.add(UnlinkedConstOperation.pushParameter);
+      strings.add(expr.identifier.name);
+      operations.add(UnlinkedConstOperation.assignToProperty);
     } else {
       throw new StateError('Unsupported assignable: $expr');
     }
   }
 
   void _pushInt(int value) {
     assert(value >= 0);
     if (value >= (1 << 32)) {
       int numOfComponents = 0;
       ints.add(numOfComponents);
@@ skipping 32 matching lines @@
       _serializeString(expr);
     } else if (expr is SymbolLiteral) {
       strings.add(expr.components.map((token) => token.lexeme).join('.'));
       operations.add(UnlinkedConstOperation.makeSymbol);
     } else if (expr is NullLiteral) {
       operations.add(UnlinkedConstOperation.pushNull);
     } else if (expr is Identifier) {
       if (expr is SimpleIdentifier && isParameterName(expr.name)) {
         strings.add(expr.name);
         operations.add(UnlinkedConstOperation.pushParameter);
+      } else if (expr is PrefixedIdentifier && isParameterName(expr.prefix.name)) {
+        strings.add(expr.prefix.name);
+        operations.add(UnlinkedConstOperation.pushParameter);
+        strings.add(expr.identifier.name);
+        operations.add(UnlinkedConstOperation.extractProperty);
       } else {
         references.add(serializeIdentifier(expr));
         operations.add(UnlinkedConstOperation.pushReference);
       }
     } else if (expr is InstanceCreationExpression) {
       if (!expr.isConst) {
         isValidConst = false;
       }
       TypeName typeName = expr.constructorName.type;
       serializeInstanceCreation(
@@ skipping 310 matching lines @@
         }
       }
       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) {
+  bool _isIdentifierSequence(Expression expr) {
     while (expr != null) {
       if (expr is SimpleIdentifier) {
         AstNode parent = expr.parent;
         if (parent is MethodInvocation && parent.methodName == expr) {
           if (parent.isCascaded) {
             return false;
           }
           return parent.target == null || _isIdentifierSequence(parent.target);
         }
+        if (isParameterName(expr.name)) {
+          return false;
+        }
         return true;
       } else if (expr is PrefixedIdentifier) {
         expr = (expr as PrefixedIdentifier).prefix;
       } else if (expr is PropertyAccess) {
         expr = (expr as PropertyAccess).target;
       } else {
         return false;
       }
     }
     return false;
   }
 }