anchor.diff:    @deprecated
     ConstructorElement get element;
   
  -  /**
  -   * Set the element associated with this constructor to the given [element].
  -   */
  +  /// Set the element associated with this constructor to the given [element].
     void set element(ConstructorElement element);
   
  -  /**
  -   * Return the token for the 'external' keyword to the given [token].
  -   */
  +  /// Return the token for the 'external' keyword to the given [token].
     Token get externalKeyword;
   
  -  /**
  -   * Set the token for the 'external' keyword, or `null` if the constructor
  -   * is not external.
  -   */
  +  /// Set the token for the 'external' keyword, or `null` if the constructor
  +  /// is not external.
     void set externalKeyword(Token token);
   
  -  /**
  -   * Return the token for the 'factory' keyword, or `null` if the constructor is
  -   * not a factory constructor.
  -   */
  +  /// Return the token for the 'factory' keyword, or `null` if the constructor
  +  /// is not a factory constructor.
     Token get factoryKeyword;
   
  -  /**
  -   * Set the token for the 'factory' keyword to the given [token].
  -   */
  +  /// Set the token for the 'factory' keyword to the given [token].
     void set factoryKeyword(Token token);
   
  -  /**
  -   * Return the initializers associated with the constructor.
  -   */
  +  /// Return the initializers associated with the constructor.
     NodeList<ConstructorInitializer> get initializers;
   
  -  /**
  -   * Return the name of the constructor, or `null` if the constructor being
  -   * declared is unnamed.
  -   */
  +  /// Return the name of the constructor, or `null` if the constructor being
  +  /// declared is unnamed.
     SimpleIdentifier get name;
   
  -  /**
  -   * Set the name of the constructor to the given [identifier].
  -   */
  +  /// Set the name of the constructor to the given [identifier].
     void set name(SimpleIdentifier identifier);
   
  -  /**
  -   * Return the parameters associated with the constructor.
  -   */
  +  /// Return the parameters associated with the constructor.
     FormalParameterList get parameters;
   
  -  /**
  -   * Set the parameters associated with the constructor to the given list of
  -   * [parameters].
  -   */
  +  /// Set the parameters associated with the constructor to the given list of
  +  /// [parameters].
     void set parameters(FormalParameterList parameters);
   
  -  /**
  -   * Return the token for the period before the constructor name, or `null` if
  -   * the constructor being declared is unnamed.
  -   */
  +  /// Return the token for the period before the constructor name, or `null` if
  +  /// the constructor being declared is unnamed.
     Token get period;
   
  -  /**
  -   * Set the token for the period before the constructor name to the given
  -   * [token].
  -   */
  +  /// Set the token for the period before the constructor name to the given
  +  /// [token].
     void set period(Token token);
   
  -  /**
  -   * Return the name of the constructor to which this constructor will be
  -   * redirected, or `null` if this is not a redirecting factory constructor.
  -   */
  +  /// Return the name of the constructor to which this constructor will be
  +  /// redirected, or `null` if this is not a redirecting factory constructor.
     ConstructorName get redirectedConstructor;
   
  -  /**
  -   * Set the name of the constructor to which this constructor will be
  -   * redirected to the given [redirectedConstructor] name.
  -   */
  +  /// Set the name of the constructor to which this constructor will be
  +  /// redirected to the given [redirectedConstructor] name.
     void set redirectedConstructor(ConstructorName redirectedConstructor);
   
  -  /**
  -   * Return the type of object being created. This can be different than the
  -   * type in which the constructor is being declared if the constructor is the
  -   * implementation of a factory constructor.
  -   */
  +  /// Return the type of object being created. This can be different than the
  +  /// type in which the constructor is being declared if the constructor is the
  +  /// implementation of a factory constructor.
     Identifier get returnType;
   
  -  /**
  -   * Set the type of object being created to the given [typeName].
  -   */
  +  /// Set the type of object being created to the given [typeName].
     void set returnType(Identifier typeName);
   
  -  /**
  -   * Return the token for the separator (colon or equals) before the initializer
  -   * list or redirection, or `null` if there are no initializers.
  -   */
  +  /// Return the token for the separator (colon or equals) before the
  +  /// initializer list or redirection, or `null` if there are no initializers.
     Token get separator;
   
  -  /**
  -   * Set the token for the separator (colon or equals) before the initializer
  -   * list or redirection to the given [token].
  -   */
  +  /// Set the token for the separator (colon or equals) before the initializer
  +  /// list or redirection to the given [token].
     void set separator(Token token);
   }
   
  -/**
  - * The initialization of a field within a constructor's initialization list.
  - *
  - *    fieldInitializer ::=
  - *        ('this' '.')? [SimpleIdentifier] '=' [Expression]
  - *
  - * Clients may not extend, implement or mix-in this class.
  - */
  +/// The initialization of a field within a constructor's initialization list.
  +///
  +///    fieldInitializer ::=
  +///        ('this' '.')? [SimpleIdentifier] '=' [Expression]
  +///
  +/// Clients may not extend, implement or mix-in this class.
   abstract class ConstructorFieldInitializer implements ConstructorInitializer {
  -  /**
  -   * Return the token for the equal sign between the field name and the
  -   * expression.
  -   */
  +  /// Return the token for the equal sign between the field name and the
  +  /// expression.
     Token get equals;
   
  -  /**
  -   * Set the token for the equal sign between the field name and the
  -   * expression to the given [token].
  -   */
  +  /// Set the token for the equal sign between the field name and the
  +  /// expression to the given [token].
     void set equals(Token token);
   
  -  /**
  -   * Return the expression computing the value to which the field will be
  -   * initialized.
  -   */
  +  /// Return the expression computing the value to which the field will be
  +  /// initialized.
     Expression get expression;
   
  -  /**
  -   * Set the expression computing the value to which the field will be
  -   * initialized to the given [expression].
  -   */
  +  /// Set the expression computing the value to which the field will be
  +  /// initialized to the given [expression].
     void set expression(Expression expression);
   
  -  /**
  -   * Return the name of the field being initialized.
  -   */
  +  /// Return the name of the field being initialized.
     SimpleIdentifier get fieldName;
   
  -  /**
  -   * Set the name of the field being initialized to the given [identifier].
  -   */
  +  /// Set the name of the field being initialized to the given [identifier].
     void set fieldName(SimpleIdentifier identifier);
   
  -  /**
  -   * Return the token for the period after the 'this' keyword, or `null` if
  -   * there is no 'this' keyword.
  -   */
  +  /// Return the token for the period after the 'this' keyword, or `null` if
  +  /// there is no 'this' keyword.
     Token get period;
   
  -  /**
  -   * Set the token for the period after the 'this' keyword to the given [token].
  -   */
  +  /// Set the token for the period after the 'this' keyword to the given
  +  /// [token].
     void set period(Token token);
   
  -  /**
  -   * Return the token for the 'this' keyword, or `null` if there is no 'this'
  -   * keyword.
  -   */
  +  /// Return the token for the 'this' keyword, or `null` if there is no 'this'
  +  /// keyword.
     Token get thisKeyword;
   
  -  /**
  -   * Set the token for the 'this' keyword to the given [token].
  -   */
  +  /// Set the token for the 'this' keyword to the given [token].
     void set thisKeyword(Token token);
   }
   
  -/**
  - * A node that can occur in the initializer list of a constructor declaration.
  - *
  - *    constructorInitializer ::=
  - *        [SuperConstructorInvocation]
  - *      | [ConstructorFieldInitializer]
  - *      | [RedirectingConstructorInvocation]
  - *
  - * Clients may not extend, implement or mix-in this class.
  - */
  +/// A node that can occur in the initializer list of a constructor declaration.
  +///
  +///    constructorInitializer ::=
  +///        [SuperConstructorInvocation]
  +///      | [ConstructorFieldInitializer]
  +///      | [RedirectingConstructorInvocation]
  +///
  +/// Clients may not extend, implement or mix-in this class.
   abstract class ConstructorInitializer implements AstNode {}
   
  -/**
  - * The name of a constructor.
  - *
  - *    constructorName ::=
  - *        type ('.' identifier)?
  - *
  - * Clients may not extend, implement or mix-in this class.
  - */
  +/// The name of a constructor.
  +///
  +///    constructorName ::=
  +///        type ('.' identifier)?
  +///
  +/// Clients may not extend, implement or mix-in this class.
   abstract class ConstructorName implements AstNode, ConstructorReferenceNode {
  -  /**
  -   * Return the name of the constructor, or `null` if the specified constructor
  -   * is the unnamed constructor.
  -   */
  +  /// Return the name of the constructor, or `null` if the specified constructor
  +  /// is the unnamed constructor.
     SimpleIdentifier get name;
   
  -  /**
  -   * Set the name of the constructor to the given [name].
  -   */
  +  /// Set the name of the constructor to the given [name].
     void set name(SimpleIdentifier name);
   
  -  /**
  -   * Return the token for the period before the constructor name, or `null` if
  -   * the specified constructor is the unnamed constructor.
  -   */
  +  /// Return the token for the period before the constructor name, or `null` if
  +  /// the specified constructor is the unnamed constructor.
     Token get period;
   
  -  /**
  -   * Set the token for the period before the constructor name to the given
  -   * [token].
  -   */
  +  /// Set the token for the period before the constructor name to the given
  +  /// [token].
     void set period(Token token);
   
  -  /**
  -   * Return the name of the type defining the constructor.
  -   */
  +  /// Return the name of the type defining the constructor.
     TypeName get type;
   
  -  /**
  -   * Set the name of the type defining the constructor to the given [type] name.
  -   */
  +  /// Set the name of the type defining the constructor to the given [type]
  +  /// name.
     void set type(TypeName type);
   }
   
  -/**
  - * An AST node that makes reference to a constructor.
  - *
  - * Clients may not extend, implement or mix-in this class.
  - */
  +/// An AST node that makes reference to a constructor.
  +///
  +/// Clients may not extend, implement or mix-in this class.
   abstract class ConstructorReferenceNode implements AstNode {
  -  /**
  -   * Return the element associated with the referenced constructor based on
  -   * static type information, or `null` if the AST structure has not been
  -   * resolved or if the constructor could not be resolved.
  -   */
  +  /// Return the element associated with the referenced constructor based on
  +  /// static type information, or `null` if the AST structure has not been
  +  /// resolved or if the constructor could not be resolved.
     ConstructorElement get staticElement;
   
  -  /**
  -   * Set the element associated with the referenced constructor based on static
  -   * type information to the given [element].
  -   */
  +  /// Set the element associated with the referenced constructor based on static
  +  /// type information to the given [element].
     void set staticElement(ConstructorElement element);
   }
   
  -/**
  - * A continue statement.
  - *
  - *    continueStatement ::=
  - *        'continue' [SimpleIdentifier]? ';'
  - *
  - * Clients may not extend, implement or mix-in this class.
  - */
  +/// A continue statement.
  +///
  +///    continueStatement ::=
  +///        'continue' [SimpleIdentifier]? ';'
  +///
  +/// Clients may not extend, implement or mix-in this class.
   abstract class ContinueStatement implements Statement {
  -  /**
  -   * Return the token representing the 'continue' keyword.
  -   */
  +  /// Return the token representing the 'continue' keyword.
     Token get continueKeyword;
   
  -  /**
  -   * Set the token representing the 'continue' keyword to the given [token].
  -   */
  +  /// Set the token representing the 'continue' keyword to the given [token].
     void set continueKeyword(Token token);
   
  -  /**
  -   * Return the label associated with the statement, or `null` if there is no
  -   * label.
  -   */
  +  /// Return the label associated with the statement, or `null` if there is no
  +  /// label.
     SimpleIdentifier get label;
   
  -  /**
  -   * Set the label associated with the statement to the given [identifier].
  -   */
  +  /// Set the label associated with the statement to the given [identifier].
     void set label(SimpleIdentifier identifier);
   
  -  /**
  -   * 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 node to which this continue statement is continuing. This will
  -   * be either a [Statement] (in the case of continuing a loop), a
  -   * [SwitchMember] (in the case of continuing from one switch case to another),
  -   * or `null` if the AST has not yet been resolved or if the target could not
  -   * be resolved. Note that if the source code has errors, the target might be
  -   * invalid (e.g. the target may be in an enclosing function).
  -   */
  +  /// Return the node to which this continue statement is continuing. This will
  +  /// be either a [Statement] (in the case of continuing a loop), a
  +  /// [SwitchMember] (in the case of continuing from one switch case to
  +  /// another), or `null` if the AST has not yet been resolved or if the target
  +  /// could not be resolved. Note that if the source code has errors, the target
  +  /// might be invalid (e.g. the target may be in an enclosing function).
     AstNode get target;
   
  -  /**
  -   * Set the node to which this continue statement is continuing to the given
  -   * [node].
  -   */
  +  /// Set the node to which this continue statement is continuing to the given
  +  /// [node].
     void set target(AstNode node);
   }
   
  -/**
  - * A node that represents the declaration of one or more names. Each declared
  - * name is visible within a name scope.
  - *
  - * Clients may not extend, implement or mix-in this class.
  - */
  +/// A node that represents the declaration of one or more names. Each declared
  +/// name is visible within a name scope.
  +///
  +/// Clients may not extend, implement or mix-in this class.
   abstract class Declaration implements AnnotatedNode {
  -  /**
  -   * Return the element associated with this declaration, or `null` if either
  -   * this node corresponds to a list of declarations or if the AST structure has
  -   * not been resolved.
  -   */
  +  /// Return the element associated with this declaration, or `null` if either
  +  /// this node corresponds to a list of declarations or if the AST structure
  +  /// has not been resolved.
     Element get declaredElement;
   
  -  /**
  -   * Return the element associated with this declaration, or `null` if either
  -   * this node corresponds to a list of declarations or if the AST structure has
  -   * not been resolved.
  -   */
  +  /// Return the element associated with this declaration, or `null` if either
  +  /// this node corresponds to a list of declarations or if the AST structure
  +  /// has not been resolved.
     @deprecated
     Element get element;
   }
   
  -/**
  - * The declaration of a single identifier.
  - *
  - *    declaredIdentifier ::=
  - *        [Annotation] finalConstVarOrType [SimpleIdentifier]
  - *
  - * Clients may not extend, implement or mix-in this class.
  - */
  +/// The declaration of a single identifier.
  +///
  +///    declaredIdentifier ::=
  +///        [Annotation] finalConstVarOrType [SimpleIdentifier]
  +///
  +/// Clients may not extend, implement or mix-in this class.
   abstract class DeclaredIdentifier implements Declaration {
     @override
     LocalVariableElement get declaredElement;
  
positive.code: // 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.
  
  /**
   * Defines the AST model. The AST (Abstract Syntax Tree) model describes the
   * syntactic (as opposed to semantic) structure of Dart code. The semantic
   * structure of the code is modeled by the
   * [element model](../dart_element_element/dart_element_element-library.html).
   *
   * An AST consists of nodes (instances of a subclass of [AstNode]). The nodes
   * are organized in a tree structure in which the children of a node are the
   * smaller syntactic units from which the node is composed. For example, a
   * binary expression consists of two sub-expressions (the operands) and an
   * operator. The two expressions are represented as nodes. The operator is not
   * represented as a node.
   *
   * The AST is constructed by the parser based on the sequence of tokens produced
   * by the scanner. Most nodes provide direct access to the tokens used to build
   * the node. For example, the token for the operator in a binary expression can
   * be accessed from the node representing the binary expression.
   *
   * While any node can theoretically be the root of an AST structure, almost all
   * of the AST structures known to the analyzer have a [CompilationUnit] as the
   * root of the structure. A compilation unit represents all of the Dart code in
   * a single file.
   *
   * An AST can be either unresolved or resolved. When an AST is unresolved
   * certain properties will not have been computed and the accessors for those
   * properties will return `null`. The documentation for those getters should
   * describe that this is a possibility.
   *
   * When an AST is resolved, the identifiers in the AST will be associated with
   * the elements that they refer to and every expression in the AST will have a
   * type associated with it.
   */
  import 'package:analyzer/dart/ast/syntactic_entity.dart';
  import 'package:analyzer/dart/ast/token.dart';
  import 'package:analyzer/dart/element/element.dart';
  
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
  