anchor.diff:    @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.
  -   */
  +  /// 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].
  -   */
  +  /// 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.
  -   */
  +  /// 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].
  -   */
  +  /// 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.
  -   */
  +  /// 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.
  -   */
  +  /// 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.
  -   */
  +  /// Return the name of the variable being declared.
     SimpleIdentifier get name;
   
  -  /**
  -   * Set the name of the variable being declared to the given [identifier].
  -   */
  +  /// 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.
  - */
  +/// 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.
  -   */
  +  /// 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.)
  -   */
  +  /// 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.
  -   */
  +  /// 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].
  -   */
  +  /// 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.
  -   */
  +  /// 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].
  -   */
  +  /// 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.
  -   */
  +  /// 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.
  - */
  +/// 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.
  -   */
  +  /// 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);
   
  -  /**
  -   * Return the variables being declared.
  -   */
  +  /// Return the variables being declared.
     VariableDeclarationList get variables;
   
  -  /**
  -   * Set the variables being declared to the given list of [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.
  - */
  +/// 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.
  -   */
  +  /// Return the body of the loop.
     Statement get body;
   
  -  /**
  -   * Set the body of the loop to the given [statement].
  -   */
  +  /// 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.
  -   */
  +  /// 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].
  -   */
  +  /// 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.
  -   */
  +  /// 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);
   
  -  /**
  -   * Return the token representing the 'while' keyword.
  -   */
  +  /// Return the token representing the 'while' keyword.
     Token get whileKeyword;
   
  -  /**
  -   * Set the token representing the 'while' keyword to the given [token].
  -   */
  +  /// 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.
  - */
  +/// 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.
  -   */
  +  /// Return the names of the mixins that were specified.
     NodeList<TypeName> get mixinTypes;
   
  -  /**
  -   * Return the token representing the 'with' keyword.
  -   */
  +  /// Return the token representing the 'with' keyword.
     Token get withKeyword;
   
  -  /**
  -   * Set the token representing the 'with' keyword to the given [token].
  -   */
  +  /// 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.
  - */
  +/// 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.
  -   */
  +  /// Return the expression whose value will be yielded.
     Expression get expression;
   
  -  /**
  -   * Set the expression whose value will be yielded to the given [expression].
  -   */
  +  /// Set the expression whose value will be yielded to the given [expression].
     void set expression(Expression expression);
   
  -  /**
  -   * Return the semicolon following the expression.
  -   */
  +  /// Return the semicolon following the expression.
     Token get semicolon;
   
  -  /**
  -   * Return the semicolon following the expression to the given [token].
  -   */
  +  /// Return the semicolon following the expression to the given [token].
     void set semicolon(Token token);
   
  -  /**
  -   * Return the star optionally following the 'yield' keyword.
  -   */
  +  /// Return the star optionally following the 'yield' keyword.
     Token get star;
   
  -  /**
  -   * Return the star optionally following the 'yield' keyword to the given [token].
  -   */
  +  /// Return the star optionally following the 'yield' keyword to the given
  +  /// [token].
     void set star(Token token);
   
  -  /**
  -   * Return the 'yield' keyword.
  -   */
  +  /// Return the 'yield' keyword.
     Token get yieldKeyword;
   
  -  /**
  -   * Return the 'yield' keyword to the given [token].
  -   */
  +  /// Return the 'yield' keyword to the given [token].
     void set yieldKeyword(Token token);
   }
  
positive.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);
  
  
negative.code:   @override
    LocalVariableElement get element;
  
    /// Return the name of the variable being declared.
    SimpleIdentifier get identifier;
  
    /// Set the name of the variable being declared to the given [identifier].
    void set identifier(SimpleIdentifier identifier);
  
    /// 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 token representing either the 'final', 'const' or 'var'
    /// keyword, or `null` if no keyword was used.
    Token get keyword;
  
    /// Set the token representing either the 'final', 'const' or 'var' keyword to
    /// the given [token].
    void set keyword(Token token);
  
    /// Return the name of the declared type of the parameter, or `null` if the
    /// parameter does not have a declared type.
    TypeAnnotation get type;
  
    /// Set the declared type of the parameter to the given [type].
    void set type(TypeAnnotation type);
  }
  
  /// A formal parameter with a default value. There are two kinds of parameters
  /// that are both represented by this class: named formal parameters and
  /// positional formal parameters.
  ///
  ///    defaultFormalParameter ::=
  ///        [NormalFormalParameter] ('=' [Expression])?
  ///
  ///    defaultNamedParameter ::=
  ///        [NormalFormalParameter] (':' [Expression])?
  ///
  /// Clients may not extend, implement or mix-in this class.
  abstract class DefaultFormalParameter implements FormalParameter {
    /// Return the expression computing the default value for the parameter, or
    /// `null` if there is no default value.
    Expression get defaultValue;
  
    /// Set the expression computing the default value for the parameter to the
    /// given [expression].
    void set defaultValue(Expression expression);
  
    /// Set the kind of this parameter to the given [kind].
    void set kind(ParameterKind kind);
  
    /// Return the formal parameter with which the default value is associated.
    NormalFormalParameter get parameter;
  
    /// Set the formal parameter with which the default value is associated to the
    /// given [formalParameter].
    void set parameter(NormalFormalParameter formalParameter);
  
    /// Return the token separating the parameter from the default value, or
    /// `null` if there is no default value.
    Token get separator;
  
    /// Set the token separating the parameter from the default value to the given
    /// [token].
    void set separator(Token token);
  }
  
  /// A node that represents a directive.
  ///
  ///    directive ::=
  ///        [ExportDirective]
  ///      | [ImportDirective]
  ///      | [LibraryDirective]
  ///      | [PartDirective]
  ///      | [PartOfDirective]
  ///
  /// Clients may not extend, implement or mix-in this class.
  abstract class Directive implements AnnotatedNode {
    /// Return the element associated with this directive, or `null` if the AST
    /// structure has not been resolved or if this directive could not be
    /// resolved.
    Element get element;
  
    /// Set the element associated with this directive to the given [element].
    void set element(Element element);
  
    /// Return the token representing the keyword that introduces this directive
    /// ('import', 'export', 'library' or 'part').
    Token get keyword;
  }
  
  /// A do statement.
  ///
  ///    doStatement ::=
  ///        'do' [Statement] 'while' '(' [Expression] ')' ';'
  ///
  /// Clients may not extend, implement or mix-in this class.
  abstract class DoStatement 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 condition that determines when the loop will terminate.
    Expression get condition;
  
    /// Set the condition that determines when the loop will terminate to the
    /// given [expression].
    void set condition(Expression expression);
  
    /// Return the token representing the 'do' keyword.
    Token get doKeyword;
  
    /// Set the token representing the 'do' keyword to the given [token].
    void set doKeyword(Token token);
  
    /// 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 semicolon terminating the statement.
    Token get semicolon;
  
    /// Set the semicolon terminating the statement to the given [token].
    void set semicolon(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);
  }
  
  /// A dotted name, used in a configuration within an import or export directive.
  ///
  ///    dottedName ::=
  ///        [SimpleIdentifier] ('.' [SimpleIdentifier])*
  ///
  /// Clients may not extend, implement or mix-in this class.
  abstract class DottedName implements AstNode {
    /// Return the components of the identifier.
    NodeList<SimpleIdentifier> get components;
  }
  
  /// A floating point literal expression.
  ///
  ///    doubleLiteral ::=
  ///        decimalDigit+ ('.' decimalDigit*)? exponent?
  ///      | '.' decimalDigit+ exponent?
  ///
  ///    exponent ::=
  ///        ('e' | 'E') ('+' | '-')? decimalDigit+
  ///
  /// Clients may not extend, implement or mix-in this class.
  abstract class DoubleLiteral implements Literal {
    /// Return the token representing the literal.
    Token get literal;
  
    /// Set the token representing the literal to the given [token].
    void set literal(Token token);
  
    /// Return the value of the literal.
    double get value;
  
    /// Set the value of the literal to the given [value].
    void set value(double value);
  }
  
  /// An empty function body, which can only appear in constructors or abstract
  /// methods.
  ///
  ///    emptyFunctionBody ::=
  ///        ';'
  ///
  /// Clients may not extend, implement or mix-in this class.
  abstract class EmptyFunctionBody implements FunctionBody {
    /// Return the token representing the semicolon that marks the end of the
    /// function body.
    Token get semicolon;
  
    /// Set the token representing the semicolon that marks the end of the
    /// function body to the given [token].
    void set semicolon(Token token);
  }
  
  /// An empty statement.
  ///
  ///    emptyStatement ::=
  ///        ';'
  ///
  /// Clients may not extend, implement or mix-in this class.
  abstract class EmptyStatement 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);
  }
  
  /// The declaration of an enum constant.
  ///
  /// Clients may not extend, implement or mix-in this class.
  abstract class EnumConstantDeclaration implements Declaration {
    /// Return the name of the constant.
    SimpleIdentifier get name;
  
    /// Set the name of the constant to the given [name].
    void set name(SimpleIdentifier name);
  }
  
  /// The declaration of an enumeration.
  ///
  ///    enumType ::=
  ///        metadata 'enum' [SimpleIdentifier] '{' [SimpleIdentifier] (',' [SimpleIdentifier])* (',')? '}'
  ///
  /// Clients may not extend, implement or mix-in this class.
  abstract class EnumDeclaration implements NamedCompilationUnitMember {
    /// Return the enumeration constants being declared.
    NodeList<EnumConstantDeclaration> get constants;
  
    @override
  