anchor.diff:          references: references);
     }
   
  -  /**
  -   * Return `true` if the given [expr] is a sequence of identifiers.
  -   */
  +  /// Return `true` if the given [expr] is a sequence of identifiers.
     bool _isIdentifierSequence(Expression expr) {
       while (expr != null) {
         if (expr is SimpleIdentifier) {
  
positive.code:         'Cannot serialize an instance of ${type.runtimeType}');
    }
  
    /**
     * Return [EntityRefBuilder] that corresponds to the type with the given
     * [name] and [arguments].
     */
    EntityRefBuilder serializeTypeName(
        Identifier name, TypeArgumentList arguments);
  
    /**
     * Return the [UnlinkedExprBuilder] that corresponds to the state of this
     * serializer.
     */
    UnlinkedExprBuilder toBuilder() {
      return new UnlinkedExprBuilder(
          isValidConst: isValidConst,
  
negative.code:   throw new StateError('Unexpected initializer type ${node.runtimeType}');
  }
  
  /// Instances of this class keep track of intermediate state during
  /// serialization of a single constant [Expression].
  abstract class AbstractConstExprSerializer {
    /// Whether an expression that should be a constant is being serialized.
    ///
    /// For constants we need to store more than we need just for type inference,
    /// because we need to be able to restore these AST to evaluate actual values
    /// of constants. So, we need to store constructor arguments, elements for
    /// list and map literals even if these literals are typed.
    final bool forConst;
  
    /// See [UnlinkedExprBuilder.isValidConst].
    bool isValidConst = true;
  
    /// See [UnlinkedExprBuilder.name].
    String name = null;
  
    /// See [UnlinkedExprBuilder.operations].
    final List<UnlinkedExprOperation> operations = <UnlinkedExprOperation>[];
  
    /// See [UnlinkedExprBuilder.assignmentOperators].
    final List<UnlinkedExprAssignOperator> assignmentOperators =
        <UnlinkedExprAssignOperator>[];
  
    /// See [UnlinkedExprBuilder.ints].
    final List<int> ints = <int>[];
  
    /// See [UnlinkedExprBuilder.doubles].
    final List<double> doubles = <double>[];
  
    /// See [UnlinkedExprBuilder.strings].
    final List<String> strings = <String>[];
  
    /// See [UnlinkedExprBuilder.references].
    final List<EntityRefBuilder> references = <EntityRefBuilder>[];
  
    AbstractConstExprSerializer(this.forConst);
  
    /// Return `true` if the given [name] is a parameter reference.
    bool isParameterName(String name);
  
    /// Serialize the given [expr] expression into this serializer state.
    void serialize(Expression expr) {
      try {
        if (expr is NamedExpression) {
  