anchor.diff:    throw new StateError('Unexpected initializer type ${node.runtimeType}');
   }
   
  -/**
  - * Instances of this class keep track of intermediate state during
  - * serialization of a single constant [Expression].
  - */
  +/// 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.
  -   */
  +  /// 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].
  -   */
  +  /// See [UnlinkedExprBuilder.isValidConst].
     bool isValidConst = true;
   
  -  /**
  -   * See [UnlinkedExprBuilder.name].
  -   */
  +  /// See [UnlinkedExprBuilder.name].
     String name = null;
   
  -  /**
  -   * See [UnlinkedExprBuilder.operations].
  -   */
  +  /// See [UnlinkedExprBuilder.operations].
     final List<UnlinkedExprOperation> operations = <UnlinkedExprOperation>[];
   
  -  /**
  -   * See [UnlinkedExprBuilder.assignmentOperators].
  -   */
  +  /// See [UnlinkedExprBuilder.assignmentOperators].
     final List<UnlinkedExprAssignOperator> assignmentOperators =
         <UnlinkedExprAssignOperator>[];
   
  -  /**
  -   * See [UnlinkedExprBuilder.ints].
  -   */
  +  /// See [UnlinkedExprBuilder.ints].
     final List<int> ints = <int>[];
   
  -  /**
  -   * See [UnlinkedExprBuilder.doubles].
  -   */
  +  /// See [UnlinkedExprBuilder.doubles].
     final List<double> doubles = <double>[];
   
  -  /**
  -   * See [UnlinkedExprBuilder.strings].
  -   */
  +  /// See [UnlinkedExprBuilder.strings].
     final List<String> strings = <String>[];
   
  -  /**
  -   * See [UnlinkedExprBuilder.references].
  -   */
  +  /// See [UnlinkedExprBuilder.references].
     final List<EntityRefBuilder> references = <EntityRefBuilder>[];
   
     AbstractConstExprSerializer(this.forConst);
   
  -  /**
  -   * Return `true` if the given [name] is a parameter reference.
  -   */
  +  /// Return `true` if the given [name] is a parameter reference.
     bool isParameterName(String name);
   
  -  /**
  -   * Serialize the given [expr] expression into this serializer state.
  -   */
  +  /// Serialize the given [expr] expression into this serializer state.
     void serialize(Expression expr) {
       try {
         if (expr is NamedExpression) {
  
positive.code:     return false;
    }
  
    /**
     * Push the operation for the given assignable [expr].
     */
    void _pushAssignable(Expression expr) {
      if (_isIdentifierSequence(expr)) {
        EntityRefBuilder ref = serializeIdentifierSequence(expr);
  
negative.code:     }
    }
  
    /// 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 [typeName].
    EntityRefBuilder serializeConstructorRef(Identifier typeName,
        TypeArgumentList typeArguments, SimpleIdentifier name);
  
    /// Return a pair of ints showing how the given [functionExpression] is nested
    /// within the constant currently being serialized.  The first int indicates
    /// how many levels of function nesting must be popped in order to reach the
    /// parent of the [functionExpression].  The second int is the index of the
    /// [functionExpression] within its parent element.
    ///
    /// If the constant being summarized is in a context where local function
    /// references are not allowed, return `null`.
    List<int> serializeFunctionExpression(FunctionExpression functionExpression);
  
    /// Return [EntityRefBuilder] that corresponds to the [type], which is defined
    /// using generic function type syntax. These may appear as the type arguments
    /// of a const list, etc.
    EntityRefBuilder serializeGenericFunctionType(GenericFunctionType type);
  
    /// 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,
  