anchor.diff:  import 'package:analyzer/src/generated/source.dart' show LineInfo, Source;
   import 'package:analyzer/src/generated/utilities_dart.dart';
   
  -/**
  - * Two or more string literals that are implicitly concatenated because of being
  - * adjacent (separated only by whitespace).
  - *
  - * While the grammar only allows adjacent strings when all of the strings are of
  - * the same kind (single line or multi-line), this class doesn't enforce that
  - * restriction.
  - *
  - *    adjacentStrings ::=
  - *        [StringLiteral] [StringLiteral]+
  - *
  - * Clients may not extend, implement or mix-in this class.
  - */
  +/// Two or more string literals that are implicitly concatenated because of
  +/// being adjacent (separated only by whitespace).
  +///
  +/// While the grammar only allows adjacent strings when all of the strings are
  +/// of the same kind (single line or multi-line), this class doesn't enforce
  +/// that restriction.
  +///
  +///    adjacentStrings ::=
  +///        [StringLiteral] [StringLiteral]+
  +///
  +/// Clients may not extend, implement or mix-in this class.
   abstract class AdjacentStrings implements StringLiteral {
  -  /**
  -   * Return the strings that are implicitly concatenated.
  -   */
  +  /// Return the strings that are implicitly concatenated.
     NodeList<StringLiteral> get strings;
   }
   
  -/**
  - * An AST node that can be annotated with both a documentation comment and a
  - * list of annotations.
  - *
  - * Clients may not extend, implement or mix-in this class.
  - */
  +/// An AST node that can be annotated with both a documentation comment and a
  +/// list of annotations.
  +///
  +/// Clients may not extend, implement or mix-in this class.
   abstract class AnnotatedNode implements AstNode {
  -  /**
  -   * Return the documentation comment associated with this node, or `null` if
  -   * this node does not have a documentation comment associated with it.
  -   */
  +  /// Return the documentation comment associated with this node, or `null` if
  +  /// this node does not have a documentation comment associated with it.
     Comment get documentationComment;
   
  -  /**
  -   * Set the documentation comment associated with this node to the given
  -   * [comment].
  -   */
  +  /// Set the documentation comment associated with this node to the given
  +  /// [comment].
     void set documentationComment(Comment comment);
   
  -  /**
  -   * Return the first token following the comment and metadata.
  -   */
  +  /// Return the first token following the comment and metadata.
     Token get firstTokenAfterCommentAndMetadata;
   
  -  /**
  -   * Return the annotations associated with this node.
  -   */
  +  /// Return the annotations associated with this node.
     NodeList<Annotation> get metadata;
   
  -  /**
  -   * Return a list containing the comment and annotations associated with this
  -   * node, sorted in lexical order.
  -   */
  +  /// Return a list containing the comment and annotations associated with this
  +  /// node, sorted in lexical order.
     List<AstNode> get sortedCommentAndAnnotations;
   }
   
  -/**
  - * An annotation that can be associated with an AST node.
  - *
  - *    metadata ::=
  - *        annotation*
  - *
  - *    annotation ::=
  - *        '@' [Identifier] ('.' [SimpleIdentifier])? [ArgumentList]?
  - *
  - * Clients may not extend, implement or mix-in this class.
  - */
  +/// An annotation that can be associated with an AST node.
  +///
  +///    metadata ::=
  +///        annotation*
  +///
  +///    annotation ::=
  +///        '@' [Identifier] ('.' [SimpleIdentifier])? [ArgumentList]?
  +///
  +/// Clients may not extend, implement or mix-in this class.
   abstract class Annotation implements AstNode {
  -  /**
  -   * Return the arguments to the constructor being invoked, or `null` if this
  -   * annotation is not the invocation of a constructor.
  -   */
  +  /// Return the arguments to the constructor being invoked, or `null` if this
  +  /// annotation is not the invocation of a constructor.
     ArgumentList get arguments;
   
  -  /**
  -   * Set the arguments to the constructor being invoked to the given [arguments].
  -   */
  +  /// Set the arguments to the constructor being invoked to the given
  +  /// [arguments].
     void set arguments(ArgumentList arguments);
   
  -  /**
  -   * Return the at sign that introduced the annotation.
  -   */
  +  /// Return the at sign that introduced the annotation.
     Token get atSign;
   
  -  /**
  -   * Set the at sign that introduced the annotation to the given [token].
  -   */
  +  /// Set the at sign that introduced the annotation to the given [token].
     void set atSign(Token token);
   
  -  /**
  -   * Return the name of the constructor being invoked, or `null` if this
  -   * annotation is not the invocation of a named constructor.
  -   */
  +  /// Return the name of the constructor being invoked, or `null` if this
  +  /// annotation is not the invocation of a named constructor.
     SimpleIdentifier get constructorName;
   
  -  /**
  -   * Set the name of the constructor being invoked to the given [name].
  -   */
  +  /// Set the name of the constructor being invoked to the given [name].
     void set constructorName(SimpleIdentifier name);
   
  -  /**
  -   * Return the element associated with this annotation, or `null` if the AST
  -   * structure has not been resolved or if this annotation could not be
  -   * resolved.
  -   */
  +  /// Return the element associated with this annotation, or `null` if the AST
  +  /// structure has not been resolved or if this annotation could not be
  +  /// resolved.
     Element get element;
   
  -  /**
  -   * Set the element associated with this annotation to the given [element].
  -   */
  +  /// Set the element associated with this annotation to the given [element].
     void set element(Element element);
   
  -  /**
  -   * Return the element annotation representing this annotation in the element model.
  -   */
  +  /// Return the element annotation representing this annotation in the element
  +  /// model.
     ElementAnnotation get elementAnnotation;
   
  -  /**
  -   * Set the element annotation representing this annotation in the element
  -   * model to the given [annotation].
  -   */
  +  /// Set the element annotation representing this annotation in the element
  +  /// model to the given [annotation].
     void set elementAnnotation(ElementAnnotation annotation);
   
  -  /**
  -   * Return the name of the class defining the constructor that is being invoked
  -   * or the name of the field that is being referenced.
  -   */
  +  /// Return the name of the class defining the constructor that is being
  +  /// invoked or the name of the field that is being referenced.
     Identifier get name;
   
  -  /**
  -   * Set the name of the class defining the constructor that is being invoked or
  -   * the name of the field that is being referenced to the given [name].
  -   */
  +  /// Set the name of the class defining the constructor that is being invoked
  +  /// or the name of the field that is being referenced to the given [name].
     void set name(Identifier name);
   
  -  /**
  -   * Return the period before the constructor name, or `null` if this annotation
  -   * is not the invocation of a named constructor.
  -   */
  +  /// Return the period before the constructor name, or `null` if this
  +  /// annotation is not the invocation of a named constructor.
     Token get period;
   
  -  /**
  -   * Set the period before the constructor name to the given [token].
  -   */
  +  /// Set the period before the constructor name to the given [token].
     void set period(Token token);
   }
   
  -/**
  - * A list of arguments in the invocation of an executable element (that is, a
  - * function, method, or constructor).
  - *
  - *    argumentList ::=
  - *        '(' arguments? ')'
  - *
  - *    arguments ::=
  - *        [NamedExpression] (',' [NamedExpression])*
  - *      | [Expression] (',' [Expression])* (',' [NamedExpression])*
  - *
  - * Clients may not extend, implement or mix-in this class.
  - */
  +/// A list of arguments in the invocation of an executable element (that is, a
  +/// function, method, or constructor).
  +///
  +///    argumentList ::=
  +///        '(' arguments? ')'
  +///
  +///    arguments ::=
  +///        [NamedExpression] (',' [NamedExpression])*
  +///      | [Expression] (',' [Expression])* (',' [NamedExpression])*
  +///
  +/// Clients may not extend, implement or mix-in this class.
   abstract class ArgumentList implements AstNode {
  -  /**
  -   * Return the expressions producing the values of the arguments. Although the
  -   * language requires that positional arguments appear before named arguments,
  -   * this class allows them to be intermixed.
  -   */
  +  /// Return the expressions producing the values of the arguments. Although the
  +  /// language requires that positional arguments appear before named arguments,
  +  /// this class allows them to be intermixed.
     NodeList<Expression> get arguments;
   
  -  /**
  -   * Set the parameter elements corresponding to each of the arguments in this
  -   * list to the given list of [parameters]. The list of parameters must be the
  -   * same length as the number of arguments, but can contain `null` entries if a
  -   * given argument does not correspond to a formal parameter.
  -   *
  -   * Deprecated: The analyzer no longer computes propagated type information.
  -   * Use [correspondingStaticParameters] instead.
  -   */
  +  /// Set the parameter elements corresponding to each of the arguments in this
  +  /// list to the given list of [parameters]. The list of parameters must be the
  +  /// same length as the number of arguments, but can contain `null` entries if
  +  /// a given argument does not correspond to a formal parameter.
  +  ///
  +  /// Deprecated: The analyzer no longer computes propagated type information.
  +  /// Use [correspondingStaticParameters] instead.
     @deprecated
     void set correspondingPropagatedParameters(List<ParameterElement> parameters);
   
  -  /**
  -   * Set the parameter elements corresponding to each of the arguments in this
  -   * list to the given list of [parameters]. The list of parameters must be the
  -   * same length as the number of arguments, but can contain `null` entries if a
  -   * given argument does not correspond to a formal parameter.
  -   */
  +  /// Set the parameter elements corresponding to each of the arguments in this
  +  /// list to the given list of [parameters]. The list of parameters must be the
  +  /// same length as the number of arguments, but can contain `null` entries if
  +  /// a given argument does not correspond to a formal parameter.
     void set correspondingStaticParameters(List<ParameterElement> parameters);
   
  -  /**
  -   * Return the left parenthesis.
  -   */
  +  /// Return the left parenthesis.
     Token get leftParenthesis;
   
  -  /**
  -   * Set the left parenthesis to the given [token].
  -   */
  +  /// Set the left parenthesis to the given [token].
     void set leftParenthesis(Token token);
   
  -  /**
  -   * Return the right parenthesis.
  -   */
  +  /// Return the right parenthesis.
     Token get rightParenthesis;
   
  -  /**
  -   * Set the right parenthesis to the given [token].
  -   */
  +  /// Set the right parenthesis to the given [token].
     void set rightParenthesis(Token token);
   }
   
  -/**
  - * An as expression.
  - *
  - *    asExpression ::=
  - *        [Expression] 'as' [TypeAnnotation]
  - *
  - * Clients may not extend, implement or mix-in this class.
  - */
  +/// An as expression.
  +///
  +///    asExpression ::=
  +///        [Expression] 'as' [TypeAnnotation]
  +///
  +/// Clients may not extend, implement or mix-in this class.
   abstract class AsExpression implements Expression {
  -  /**
  -   * Return the 'as' operator.
  -   */
  +  /// Return the 'as' operator.
     Token get asOperator;
   
  -  /**
  -   * Set the 'as' operator to the given [token].
  -   */
  +  /// Set the 'as' operator to the given [token].
     void set asOperator(Token token);
   
  -  /**
  -   * Return the expression used to compute the value being cast.
  -   */
  +  /// Return the expression used to compute the value being cast.
     Expression get expression;
   
  -  /**
  -   * Set the expression used to compute the value being cast to the given
  -   * [expression].
  -   */
  +  /// Set the expression used to compute the value being cast to the given
  +  /// [expression].
     void set expression(Expression expression);
   
  -  /**
  -   * Return the type being cast to.
  -   */
  +  /// Return the type being cast to.
     TypeAnnotation get type;
   
  -  /**
  -   * Set the type being cast to to the given [type].
  -   */
  +  /// Set the type being cast to to the given [type].
     void set type(TypeAnnotation type);
   }
   
  -/**
  - * An assert in the initializer list of a constructor.
  - *
  - *    assertInitializer ::=
  - *        'assert' '(' [Expression] (',' [Expression])? ')'
  - *
  - * Clients may not extend, implement or mix-in this class.
  - */
  +/// An assert in the initializer list of a constructor.
  +///
  +///    assertInitializer ::=
  +///        'assert' '(' [Expression] (',' [Expression])? ')'
  +///
  +/// Clients may not extend, implement or mix-in this class.
   abstract class AssertInitializer implements Assertion, ConstructorInitializer {}
   
  -/**
  - * An assertion, either in a block or in the initializer list of a constructor.
  - *
  - * Clients may not extend, implement or mix-in this class.
  - */
  +/// An assertion, either in a block or in the initializer list of a constructor.
  +///
  +/// Clients may not extend, implement or mix-in this class.
   abstract class Assertion implements AstNode {
  -  /**
  -   * Return the token representing the 'assert' keyword.
  -   */
  +  /// Return the token representing the 'assert' keyword.
     Token get assertKeyword;
   
  -  /**
  -   * Set the token representing the 'assert' keyword to the given [token].
  -   */
  +  /// Set the token representing the 'assert' keyword to the given [token].
     void set assertKeyword(Token token);
   
  -  /**
  -   * Return the comma between the [condition] and the [message], or `null` if no
  -   * message was supplied.
  -   */
  +  /// Return the comma between the [condition] and the [message], or `null` if
  +  /// no message was supplied.
     Token get comma;
   
  -  /**
  -   * Set the comma between the [condition] and the [message] to the given
  -   * [token].
  -   */
  +  /// Set the comma between the [condition] and the [message] to the given
  +  /// [token].
     void set comma(Token token);
   
  -  /**
  -   * Return the condition that is being asserted to be `true`.
  -   */
  +  /// Return the condition that is being asserted to be `true`.
     Expression get condition;
   
  -  /**
  -   * Set the condition that is being asserted to be `true` to the given
  -   * [condition].
  -   */
  +  /// Set the condition that is being asserted to be `true` to the given
  +  /// [condition].
     void set condition(Expression condition);
   
  -  /**
  -   * Return the left parenthesis.
  -   */
  +  /// Return the left parenthesis.
     Token get leftParenthesis;
   
  -  /**
  -   * Set the left parenthesis to the given [token].
  -   */
  +  /// Set the left parenthesis to the given [token].
     void set leftParenthesis(Token token);
   
  -  /**
  -   * Return the message to report if the assertion fails, or `null` if no
  -   * message was supplied.
  -   */
  +  /// Return the message to report if the assertion fails, or `null` if no
  +  /// message was supplied.
     Expression get message;
   
  -  /**
  -   * Set the message to report if the assertion fails to the given
  -   * [expression].
  -   */
  +  /// Set the message to report if the assertion fails to the given
  +  /// [expression].
     void set message(Expression expression);
   
  -  /**
  -   *  Return the right parenthesis.
  -   */
  +  ///  Return the right parenthesis.
     Token get rightParenthesis;
   
  -  /**
  -   *  Set the right parenthesis to the given [token].
  -   */
  +  ///  Set the right parenthesis to the given [token].
     void set rightParenthesis(Token token);
   }
   
  -/**
  - * An assert statement.
  - *
  - *    assertStatement ::=
  - *        'assert' '(' [Expression] (',' [Expression])? ')' ';'
  - *
  - * Clients may not extend, implement or mix-in this class.
  - */
  +/// An assert statement.
  +///
  +///    assertStatement ::=
  +///        'assert' '(' [Expression] (',' [Expression])? ')' ';'
  +///
  +/// Clients may not extend, implement or mix-in this class.
   abstract class AssertStatement implements Assertion, Statement {
  -  /**
  -   * Return the semicolon terminating the statement.
  -   */
  +  /// Return the semicolon terminating the statement.
     Token get semicolon;
   
  -  /**
  -   * Set the semicolon terminating the statement to the given [token].
  -   */
  +  /// Set the semicolon terminating the statement to the given [token].
     void set semicolon(Token token);
   }
   
  -/**
  - * An assignment expression.
  - *
  - *    assignmentExpression ::=
  - *        [Expression] operator [Expression]
  - *
  - * Clients may not extend, implement or mix-in this class.
  - */
  +/// An assignment expression.
  +///
  +///    assignmentExpression ::=
  +///        [Expression] operator [Expression]
  +///
  +/// Clients may not extend, implement or mix-in this class.
   abstract class AssignmentExpression
       implements Expression, MethodReferenceExpression {
  -  /**
  -   * Return the expression used to compute the left hand side.
  -   */
  +  /// Return the expression used to compute the left hand side.
     Expression get leftHandSide;
   
  -  /**
  -   * Return the expression used to compute the left hand side.
  -   */
  +  /// Return the expression used to compute the left hand side.
     void set leftHandSide(Expression expression);
   
  -  /**
  -   * Return the assignment operator being applied.
  -   */
  +  /// Return the assignment operator being applied.
     Token get operator;
   
  -  /**
  -   * Set the assignment operator being applied to the given [token].
  -   */
  +  /// Set the assignment operator being applied to the given [token].
     void set operator(Token token);
   
  -  /**
  -   * Return the expression used to compute the right hand side.
  -   */
  +  /// Return the expression used to compute the right hand side.
     Expression get rightHandSide;
   
  -  /**
  -   * Set the expression used to compute the left hand side to the given
  -   * [expression].
  -   */
  +  /// Set the expression used to compute the left hand side to the given
  +  /// [expression].
     void set rightHandSide(Expression expression);
   }
   
  -/**
  - * A node in the AST structure for a Dart program.
  - *
  - * Clients may not extend, implement or mix-in this class.
  - */
  +/// A node in the AST structure for a Dart program.
  +///
  +/// Clients may not extend, implement or mix-in this class.
   abstract class AstNode implements SyntacticEntity {
  -  /**
  -   * A comparator that can be used to sort AST nodes in lexical order. In other
  -   * words, `compare` will return a negative value if the offset of the first
  -   * node is less than the offset of the second node, zero (0) if the nodes have
  -   * the same offset, and a positive value if the offset of the first node is
  -   * greater than the offset of the second node.
  -   */
  +  /// A comparator that can be used to sort AST nodes in lexical order. In other
  +  /// words, `compare` will return a negative value if the offset of the first
  +  /// node is less than the offset of the second node, zero (0) if the nodes
  +  /// have the same offset, and a positive value if the offset of the first node
  +  /// is greater than the offset of the second node.
     static Comparator<AstNode> LEXICAL_ORDER =
         (AstNode first, AstNode second) => first.offset - second.offset;
   
  -  /**
  -   * Return the first token included in this node's source range.
  -   */
  +  /// Return the first token included in this node's source range.
     Token get beginToken;
   
  -  /**
  -   * Return an iterator that can be used to iterate through all the entities
  -   * (either AST nodes or tokens) that make up the contents of this node,
  -   * including doc comments but excluding other comments.
  -   */
  +  /// Return an iterator that can be used to iterate through all the entities
  +  /// (either AST nodes or tokens) that make up the contents of this node,
  +  /// including doc comments but excluding other comments.
     Iterable<SyntacticEntity> get childEntities;
   
  -  /**
  -   * Return the offset of the character immediately following the last character
  -   * of this node's source range. This is equivalent to
  -   * `node.getOffset() + node.getLength()`. For a compilation unit this will be
  -   * equal to the length of the unit's source. For synthetic nodes this will be
  -   * equivalent to the node's offset (because the length is zero (0) by
  -   * definition).
  -   */
  +  /// Return the offset of the character immediately following the last
  +  /// character of this node's source range. This is equivalent to
  +  /// `node.getOffset() + node.getLength()`. For a compilation unit this will be
  +  /// equal to the length of the unit's source. For synthetic nodes this will be
  +  /// equivalent to the node's offset (because the length is zero (0) by
  +  /// definition).
     @override
     int get end;
   
  -  /**
  -   * Return the last token included in this node's source range.
  -   */
  +  /// Return the last token included in this node's source range.
     Token get endToken;
   
  -  /**
  -   * Return `true` if this node is a synthetic node. A synthetic node is a node
  -   * that was introduced by the parser in order to recover from an error in the
  -   * code. Synthetic nodes always have a length of zero (`0`).
  -   */
  +  /// Return `true` if this node is a synthetic node. A synthetic node is a node
  +  /// that was introduced by the parser in order to recover from an error in the
  +  /// code. Synthetic nodes always have a length of zero (`0`).
     bool get isSynthetic;
   
     @override
  
positive.code:   @override
    VariableElement get element;
  
    /**
     * Return the equal sign separating the variable name from the initial value,
     * or `null` if the initial value was not specified.
     */
    Token get equals;
  
    /**
     * Set the equal sign separating the variable name from the initial value to
     * the given [token].
     */
    void set equals(Token token);
  
    /**
     * Return the expression used to compute the initial value for the variable,
     * or `null` if the initial value was not specified.
     */
    Expression get initializer;
  
    /**
     * Set the expression used to compute the initial value for the variable to
     * the given [expression].
     */
    void set initializer(Expression expression);
  
    /**
     * Return `true` if this variable was declared with the 'const' modifier.
     */
    bool get isConst;
  
    /**
     * Return `true` if this variable was declared with the 'final' modifier.
     * Variables that are declared with the 'const' modifier will return `false`
     * even though they are implicitly final.
     */
    bool get isFinal;
  
    /**
     * Return the name of the variable being declared.
     */
    SimpleIdentifier get name;
  
    /**
     * Set the name of the variable being declared to the given [identifier].
     */
    void set name(SimpleIdentifier identifier);
  }
  
  /**
   * The declaration of one or more variables of the same type.
   *
   *    variableDeclarationList ::=
   *        finalConstVarOrType [VariableDeclaration] (',' [VariableDeclaration])*
   *
   *    finalConstVarOrType ::=
   *      | 'final' [TypeAnnotation]?
   *      | 'const' [TypeAnnotation]?
   *      | 'var'
   *      | [TypeAnnotation]
   *
   * Clients may not extend, implement or mix-in this class.
   */
  abstract class VariableDeclarationList implements AnnotatedNode {
    /**
     * Return `true` if the variables in this list were declared with the 'const'
     * modifier.
     */
    bool get isConst;
  
    /**
     * Return `true` if the variables in this list were declared with the 'final'
     * modifier. Variables that are declared with the 'const' modifier will return
     * `false` even though they are implicitly final. (In other words, this is a
     * syntactic check rather than a semantic check.)
     */
    bool get isFinal;
  
    /**
     * Return the token representing the 'final', 'const' or 'var' keyword, or
     * `null` if no keyword was included.
     */
    Token get keyword;
  
    /**
     * Set the token representing the 'final', 'const' or 'var' keyword to the
     * given [token].
     */
    void set keyword(Token token);
  
    /**
     * Return the type of the variables being declared, or `null` if no type was
     * provided.
     */
    TypeAnnotation get type;
  
    /**
     * Set the type of the variables being declared to the given [type].
     */
    void set type(TypeAnnotation type);
  
    /**
     * Return a list containing the individual variables being declared.
     */
    NodeList<VariableDeclaration> get variables;
  }
  
  /**
   * A list of variables that are being declared in a context where a statement is
   * required.
   *
   *    variableDeclarationStatement ::=
   *        [VariableDeclarationList] ';'
   *
   * Clients may not extend, implement or mix-in this class.
   */
  abstract class VariableDeclarationStatement implements Statement {
    /**
     * Return the semicolon terminating the statement.
     */
    Token get semicolon;
  
    /**
     * Set the semicolon terminating the statement to the given [token].
     */
    void set semicolon(Token token);
  
    /**
     * Return the variables being declared.
     */
    VariableDeclarationList get variables;
  
    /**
     * Set the variables being declared to the given list of [variables].
     */
    void set variables(VariableDeclarationList variables);
  }
  
  /**
   * A while statement.
   *
   *    whileStatement ::=
   *        'while' '(' [Expression] ')' [Statement]
   *
   * Clients may not extend, implement or mix-in this class.
   */
  abstract class WhileStatement implements Statement {
    /**
     * Return the body of the loop.
     */
    Statement get body;
  
    /**
     * Set the body of the loop to the given [statement].
     */
    void set body(Statement statement);
  
    /**
     * Return the expression used to determine whether to execute the body of the
     * loop.
     */
    Expression get condition;
  
    /**
     * Set the expression used to determine whether to execute the body of the
     * loop to the given [expression].
     */
    void set condition(Expression expression);
  
    /**
     * Return the left parenthesis.
     */
    Token get leftParenthesis;
  
    /**
     * Set the left parenthesis to the given [token].
     */
    void set leftParenthesis(Token token);
  
    /**
     * Return the right parenthesis.
     */
    Token get rightParenthesis;
  
    /**
     * Set the right parenthesis to the given [token].
     */
    void set rightParenthesis(Token token);
  
    /**
     * Return the token representing the 'while' keyword.
     */
    Token get whileKeyword;
  
    /**
     * Set the token representing the 'while' keyword to the given [token].
     */
    void set whileKeyword(Token token);
  }
  
  /**
   * The with clause in a class declaration.
   *
   *    withClause ::=
   *        'with' [TypeName] (',' [TypeName])*
   *
   * Clients may not extend, implement or mix-in this class.
   */
  abstract class WithClause implements AstNode {
    /**
     * Return the names of the mixins that were specified.
     */
    NodeList<TypeName> get mixinTypes;
  
    /**
     * Return the token representing the 'with' keyword.
     */
    Token get withKeyword;
  
    /**
     * Set the token representing the 'with' keyword to the given [token].
     */
    void set withKeyword(Token token);
  }
  
  /**
   * A yield statement.
   *
   *    yieldStatement ::=
   *        'yield' '*'? [Expression] ‘;’
   *
   * Clients may not extend, implement or mix-in this class.
   */
  abstract class YieldStatement implements Statement {
    /**
     * Return the expression whose value will be yielded.
     */
    Expression get expression;
  
    /**
     * Set the expression whose value will be yielded to the given [expression].
     */
    void set expression(Expression expression);
  
    /**
     * Return the semicolon following the expression.
     */
    Token get semicolon;
  
    /**
     * Return the semicolon following the expression to the given [token].
     */
    void set semicolon(Token token);
  
    /**
     * Return the star optionally following the 'yield' keyword.
     */
    Token get star;
  
    /**
     * Return the star optionally following the 'yield' keyword to the given [token].
     */
    void set star(Token token);
  
    /**
     * Return the 'yield' keyword.
     */
    Token get yieldKeyword;
  
    /**
     * Return the 'yield' keyword to the given [token].
     */
    void set yieldKeyword(Token token);
  }
  
negative.code:   @override
    int get offset;
  
    /// Return this node's parent node, or `null` if this node is the root of an
    /// AST structure.
    ///
    /// Note that the relationship between an AST node and its parent node may
    /// change over the lifetime of a node.
    AstNode get parent;
  
    /// Return the node at the root of this node's AST structure. Note that this
    /// method's performance is linear with respect to the depth of the node in
    /// the AST structure (O(depth)).
    AstNode get root;
  
    /// Use the given [visitor] to visit this node. Return the value returned by
    /// the visitor as a result of visiting this node.
    E accept<E>(AstVisitor<E> visitor);
  
    /// Return the token before [target] or `null` if it cannot be found.
    Token findPrevious(Token target);
  
    /// Return the most immediate ancestor of this node for which the [predicate]
    /// returns `true`, or `null` if there is no such ancestor. Note that this
    /// node will never be returned.
    @deprecated
    E getAncestor<E extends AstNode>(Predicate<AstNode> predicate);
  
    /// Return the value of the property with the given [name], or `null` if this
    /// node does not have a property with the given name.
    E getProperty<E>(String name);
  
    /// Set the value of the property with the given [name] to the given [value].
    /// If the value is `null`, the property will effectively be removed.
    void setProperty(String name, Object value);
  
    /// Return either this node or the most immediate ancestor of this node for
    /// which the [predicate] returns `true`, or `null` if there is no such node.
    E thisOrAncestorMatching<E extends AstNode>(Predicate<AstNode> predicate);
  
    /// Return either this node or the most immediate ancestor of this node that
    /// has the given type, or `null` if there is no such node.
    T thisOrAncestorOfType<T extends AstNode>();
  
    /// Return a textual description of this node in a form approximating valid
    /// source. The returned string will not be valid source primarily in the case
    /// where the node itself is not well-formed.
    String toSource();
  
    /// Use the given [visitor] to visit all of the children of this node. The
    /// children will be visited in lexical order.
    void visitChildren(AstVisitor visitor);
  }
  
  /// An object that can be used to visit an AST structure.
  ///
  /// Clients may not extend, implement or mix-in this class. There are classes
  /// that implement this interface that provide useful default behaviors in
  /// `package:analyzer/dart/ast/visitor.dart`. A couple of the most useful
  /// include
  /// * SimpleAstVisitor which implements every visit method by doing nothing,
  /// * RecursiveAstVisitor which will cause every node in a structure to be
  ///   visited, and
  /// * ThrowingAstVisitor which implements every visit method by throwing an
  ///   exception.
  abstract class AstVisitor<R> {
    R visitAdjacentStrings(AdjacentStrings node);
  
  