anchor.diff:    @override
     ExecutableElement get element;
   
  -  /**
  -   * Return the token representing the 'external' keyword, or `null` if this is
  -   * not an external function.
  -   */
  +  /// Return the token representing the 'external' keyword, or `null` if this is
  +  /// not an external function.
     Token get externalKeyword;
   
  -  /**
  -   * Set the token representing the 'external' keyword to the given [token].
  -   */
  +  /// Set the token representing the 'external' keyword to the given [token].
     void set externalKeyword(Token token);
   
  -  /**
  -   * Return the function expression being wrapped.
  -   */
  +  /// Return the function expression being wrapped.
     FunctionExpression get functionExpression;
   
  -  /**
  -   * Set the function expression being wrapped to the given
  -   * [functionExpression].
  -   */
  +  /// Set the function expression being wrapped to the given
  +  /// [functionExpression].
     void set functionExpression(FunctionExpression functionExpression);
   
  -  /**
  -   * Return `true` if this function declares a getter.
  -   */
  +  /// Return `true` if this function declares a getter.
     bool get isGetter;
   
  -  /**
  -   * Return `true` if this function declares a setter.
  -   */
  +  /// Return `true` if this function declares a setter.
     bool get isSetter;
   
  -  /**
  -   * Return the token representing the 'get' or 'set' keyword, or `null` if this
  -   * is a function declaration rather than a property declaration.
  -   */
  +  /// Return the token representing the 'get' or 'set' keyword, or `null` if
  +  /// this is a function declaration rather than a property declaration.
     Token get propertyKeyword;
   
  -  /**
  -   * Set the token representing the 'get' or 'set' keyword to the given [token].
  -   */
  +  /// Set the token representing the 'get' or 'set' keyword to the given
  +  /// [token].
     void set propertyKeyword(Token token);
   
  -  /**
  -   * Return the return type of the function, or `null` if no return type was
  -   * declared.
  -   */
  +  /// Return the return type of the function, or `null` if no return type was
  +  /// declared.
     TypeAnnotation get returnType;
   
  -  /**
  -   * Set the return type of the function to the given [type].
  -   */
  +  /// Set the return type of the function to the given [type].
     void set returnType(TypeAnnotation type);
   }
   
  -/**
  - * A [FunctionDeclaration] used as a statement.
  - *
  - * Clients may not extend, implement or mix-in this class.
  - */
  +/// A [FunctionDeclaration] used as a statement.
  +///
  +/// Clients may not extend, implement or mix-in this class.
   abstract class FunctionDeclarationStatement implements Statement {
  -  /**
  -   * Return the function declaration being wrapped.
  -   */
  +  /// Return the function declaration being wrapped.
     FunctionDeclaration get functionDeclaration;
   
  -  /**
  -   * Set the function declaration being wrapped to the given
  -   * [functionDeclaration].
  -   */
  +  /// Set the function declaration being wrapped to the given
  +  /// [functionDeclaration].
     void set functionDeclaration(FunctionDeclaration functionDeclaration);
   }
   
  -/**
  - * A function expression.
  - *
  - *    functionExpression ::=
  - *        [TypeParameterList]? [FormalParameterList] [FunctionBody]
  - *
  - * Clients may not extend, implement or mix-in this class.
  - */
  +/// A function expression.
  +///
  +///    functionExpression ::=
  +///        [TypeParameterList]? [FormalParameterList] [FunctionBody]
  +///
  +/// Clients may not extend, implement or mix-in this class.
   abstract class FunctionExpression implements Expression {
  -  /**
  -   * Return the body of the function, or `null` if this is an external function.
  -   */
  +  /// Return the body of the function, or `null` if this is an external
  +  /// function.
     FunctionBody get body;
   
  -  /**
  -   * Set the body of the function to the given [functionBody].
  -   */
  +  /// Set the body of the function to the given [functionBody].
     void set body(FunctionBody functionBody);
   
  -  /**
  -   * Return the element associated with the function, or `null` if the AST
  -   * structure has not been resolved.
  -   */
  +  /// Return the element associated with the function, or `null` if the AST
  +  /// structure has not been resolved.
     ExecutableElement get declaredElement;
   
  -  /**
  -   * Return the element associated with the function, or `null` if the AST
  -   * structure has not been resolved.
  -   */
  +  /// Return the element associated with the function, or `null` if the AST
  +  /// structure has not been resolved.
     @deprecated
     ExecutableElement get element;
   
  -  /**
  -   * Set the element associated with the function to the given [element].
  -   */
  +  /// Set the element associated with the function to the given [element].
     void set element(ExecutableElement element);
   
  -  /**
  -   * Return the parameters associated with the function.
  -   */
  +  /// Return the parameters associated with the function.
     FormalParameterList get parameters;
   
  -  /**
  -   * Set the parameters associated with the function to the given list of
  -   * [parameters].
  -   */
  +  /// Set the parameters associated with the function to the given list of
  +  /// [parameters].
     void set parameters(FormalParameterList parameters);
   
  -  /**
  -   * Return the type parameters associated with this method, or `null` if this
  -   * method is not a generic method.
  -   */
  +  /// Return the type parameters associated with this method, or `null` if this
  +  /// method is not a generic method.
     TypeParameterList get typeParameters;
   
  -  /**
  -   * Set the type parameters associated with this method to the given
  -   * [typeParameters].
  -   */
  +  /// Set the type parameters associated with this method to the given
  +  /// [typeParameters].
     void set typeParameters(TypeParameterList typeParameters);
   }
   
  -/**
  - * The invocation of a function resulting from evaluating an expression.
  - * Invocations of methods and other forms of functions are represented by
  - * [MethodInvocation] nodes. Invocations of getters and setters are represented
  - * by either [PrefixedIdentifier] or [PropertyAccess] nodes.
  - *
  - *    functionExpressionInvocation ::=
  - *        [Expression] [TypeArgumentList]? [ArgumentList]
  - *
  - * Clients may not extend, implement or mix-in this class.
  - */
  +/// The invocation of a function resulting from evaluating an expression.
  +/// Invocations of methods and other forms of functions are represented by
  +/// [MethodInvocation] nodes. Invocations of getters and setters are represented
  +/// by either [PrefixedIdentifier] or [PropertyAccess] nodes.
  +///
  +///    functionExpressionInvocation ::=
  +///        [Expression] [TypeArgumentList]? [ArgumentList]
  +///
  +/// Clients may not extend, implement or mix-in this class.
   abstract class FunctionExpressionInvocation implements InvocationExpression {
  -  /**
  -   * Set the list of arguments to the method to the given [argumentList].
  -   */
  +  /// Set the list of arguments to the method to the given [argumentList].
     void set argumentList(ArgumentList argumentList);
   
  -  /**
  -   * Return the best element available for the function being invoked. If
  -   * resolution was able to find a better element based on type propagation,
  -   * that element will be returned. Otherwise, the element found using the
  -   * result of static analysis will be returned. If resolution has not been
  -   * performed, then `null` will be returned.
  -   *
  -   * Deprecated: The analyzer no longer computes propagated type information.
  -   * Use [staticElement] instead.
  -   */
  +  /// Return the best element available for the function being invoked. If
  +  /// resolution was able to find a better element based on type propagation,
  +  /// that element will be returned. Otherwise, the element found using the
  +  /// result of static analysis will be returned. If resolution has not been
  +  /// performed, then `null` will be returned.
  +  ///
  +  /// Deprecated: The analyzer no longer computes propagated type information.
  +  /// Use [staticElement] instead.
     @deprecated
     ExecutableElement get bestElement;
   
  -  /**
  -   * Return the expression producing the function being invoked.
  -   */
  +  /// Return the expression producing the function being invoked.
     @override
     Expression get function;
   
  -  /**
  -   * Set the expression producing the function being invoked to the given
  -   * [expression].
  -   */
  +  /// Set the expression producing the function being invoked to the given
  +  /// [expression].
     void set function(Expression expression);
   
  -  /**
  -   * Return the element associated with the function being invoked based on
  -   * propagated type information, or `null` if the AST structure has not been
  -   * resolved or the function could not be resolved.
  -   *
  -   * Deprecated: The analyzer no longer computes propagated type information.
  -   * Use [staticElement] instead.
  -   */
  +  /// Return the element associated with the function being invoked based on
  +  /// propagated type information, or `null` if the AST structure has not been
  +  /// resolved or the function could not be resolved.
  +  ///
  +  /// Deprecated: The analyzer no longer computes propagated type information.
  +  /// Use [staticElement] instead.
     @deprecated
     ExecutableElement get propagatedElement;
   
  -  /**
  -   * Set the element associated with the function being invoked based on
  -   * propagated type information to the given [element].
  -   *
  -   * Deprecated: The analyzer no longer computes propagated type information.
  -   * Use [staticElement] instead.
  -   */
  +  /// Set the element associated with the function being invoked based on
  +  /// propagated type information to the given [element].
  +  ///
  +  /// Deprecated: The analyzer no longer computes propagated type information.
  +  /// Use [staticElement] instead.
     @deprecated
     void set propagatedElement(ExecutableElement element);
   
  -  /**
  -   * Return the element associated with the function being invoked based on
  -   * static type information, or `null` if the AST structure has not been
  -   * resolved or the function could not be resolved.
  -   */
  +  /// Return the element associated with the function being invoked based on
  +  /// static type information, or `null` if the AST structure has not been
  +  /// resolved or the function could not be resolved.
     ExecutableElement get staticElement;
   
  -  /**
  -   * Set the element associated with the function being invoked based on static
  -   * type information to the given [element].
  -   */
  +  /// Set the element associated with the function being invoked based on static
  +  /// type information to the given [element].
     void set staticElement(ExecutableElement element);
   
  -  /**
  -   * Set the type arguments to be applied to the method being invoked to the
  -   * given [typeArguments].
  -   */
  +  /// Set the type arguments to be applied to the method being invoked to the
  +  /// given [typeArguments].
     void set typeArguments(TypeArgumentList typeArguments);
   }
   
  -/**
  - * A function type alias.
  - *
  - *    functionTypeAlias ::=
  - *        functionPrefix [TypeParameterList]? [FormalParameterList] ';'
  - *
  - *    functionPrefix ::=
  - *        [TypeAnnotation]? [SimpleIdentifier]
  - *
  - * Clients may not extend, implement or mix-in this class.
  - */
  +/// A function type alias.
  +///
  +///    functionTypeAlias ::=
  +///        functionPrefix [TypeParameterList]? [FormalParameterList] ';'
  +///
  +///    functionPrefix ::=
  +///        [TypeAnnotation]? [SimpleIdentifier]
  +///
  +/// Clients may not extend, implement or mix-in this class.
   abstract class FunctionTypeAlias implements TypeAlias {
  -  /**
  -   * Return the parameters associated with the function type.
  -   */
  +  /// Return the parameters associated with the function type.
     FormalParameterList get parameters;
   
  -  /**
  -   * Set the parameters associated with the function type to the given list of
  -   * [parameters].
  -   */
  +  /// Set the parameters associated with the function type to the given list of
  +  /// [parameters].
     void set parameters(FormalParameterList parameters);
   
  -  /**
  -   * Return the return type of the function type being defined, or `null` if no
  -   * return type was given.
  -   */
  +  /// Return the return type of the function type being defined, or `null` if no
  +  /// return type was given.
     TypeAnnotation get returnType;
   
  -  /**
  -   * Set the return type of the function type being defined to the given [type].
  -   */
  +  /// Set the return type of the function type being defined to the given
  +  /// [type].
     void set returnType(TypeAnnotation type);
   
  -  /**
  -   * Return the type parameters for the function type, or `null` if the function
  -   * type does not have any type parameters.
  -   */
  +  /// Return the type parameters for the function type, or `null` if the
  +  /// function type does not have any type parameters.
     TypeParameterList get typeParameters;
   
  -  /**
  -   * Set the type parameters for the function type to the given list of
  -   * [typeParameters].
  -   */
  +  /// Set the type parameters for the function type to the given list of
  +  /// [typeParameters].
     void set typeParameters(TypeParameterList typeParameters);
   }
   
  -/**
  - * A function-typed formal parameter.
  - *
  - *    functionSignature ::=
  - *        [TypeAnnotation]? [SimpleIdentifier] [TypeParameterList]? [FormalParameterList]
  - *
  - * Clients may not extend, implement or mix-in this class.
  - */
  +/// A function-typed formal parameter.
  +///
  +///    functionSignature ::=
  +///        [TypeAnnotation]? [SimpleIdentifier] [TypeParameterList]? [FormalParameterList]
  +///
  +/// Clients may not extend, implement or mix-in this class.
   abstract class FunctionTypedFormalParameter implements NormalFormalParameter {
  -  /**
  -   * Return the parameters of the function-typed parameter.
  -   */
  +  /// Return the parameters of the function-typed parameter.
     FormalParameterList get parameters;
   
  -  /**
  -   * Set the parameters of the function-typed parameter to the given
  -   * [parameters].
  -   */
  +  /// Set the parameters of the function-typed parameter to the given
  +  /// [parameters].
     void set parameters(FormalParameterList parameters);
   
  -  /**
  -   * Return the return type of the function, or `null` if the function does not
  -   * have a return type.
  -   */
  +  /// Return the return type of the function, or `null` if the function does not
  +  /// have a return type.
     TypeAnnotation get returnType;
   
  -  /**
  -   * Set the return type of the function to the given [type].
  -   */
  +  /// Set the return type of the function to the given [type].
     void set returnType(TypeAnnotation type);
   
  -  /**
  -   * Return the type parameters associated with this function, or `null` if
  -   * this function is not a generic function.
  -   */
  +  /// Return the type parameters associated with this function, or `null` if
  +  /// this function is not a generic function.
     TypeParameterList get typeParameters;
   
  -  /**
  -   * Set the type parameters associated with this method to the given
  -   * [typeParameters].
  -   */
  +  /// Set the type parameters associated with this method to the given
  +  /// [typeParameters].
     void set typeParameters(TypeParameterList typeParameters);
   }
   
  -/**
  - * An anonymous function type.
  - *
  - *    functionType ::=
  - *        [TypeAnnotation]? 'Function' [TypeParameterList]?
  - *        [FormalParameterList] '?'?
  - *
  - * where the FormalParameterList is being used to represent the following
  - * grammar, despite the fact that FormalParameterList can represent a much
  - * larger grammar than the one below. This is done in order to simplify the
  - * implementation.
  - *
  - *    parameterTypeList ::=
  - *        () |
  - *        ( normalParameterTypes ,? ) |
  - *        ( normalParameterTypes , optionalParameterTypes ) |
  - *        ( optionalParameterTypes )
  - *    namedParameterTypes ::=
  - *        { namedParameterType (, namedParameterType)* ,? }
  - *    namedParameterType ::=
  - *        [TypeAnnotation]? [SimpleIdentifier]
  - *    normalParameterTypes ::=
  - *        normalParameterType (, normalParameterType)*
  - *    normalParameterType ::=
  - *        [TypeAnnotation] [SimpleIdentifier]?
  - *    optionalParameterTypes ::=
  - *        optionalPositionalParameterTypes | namedParameterTypes
  - *    optionalPositionalParameterTypes ::=
  - *        [ normalParameterTypes ,? ]
  - *
  - * Clients may not extend, implement or mix-in this class.
  - */
  +/// An anonymous function type.
  +///
  +///    functionType ::=
  +///        [TypeAnnotation]? 'Function' [TypeParameterList]?
  +///        [FormalParameterList] '?'?
  +///
  +/// where the FormalParameterList is being used to represent the following
  +/// grammar, despite the fact that FormalParameterList can represent a much
  +/// larger grammar than the one below. This is done in order to simplify the
  +/// implementation.
  +///
  +///    parameterTypeList ::=
  +///        () |
  +///        ( normalParameterTypes ,? ) |
  +///        ( normalParameterTypes , optionalParameterTypes ) |
  +///        ( optionalParameterTypes )
  +///    namedParameterTypes ::=
  +///        { namedParameterType (, namedParameterType)* ,? }
  +///    namedParameterType ::=
  +///        [TypeAnnotation]? [SimpleIdentifier]
  +///    normalParameterTypes ::=
  +///        normalParameterType (, normalParameterType)*
  +///    normalParameterType ::=
  +///        [TypeAnnotation] [SimpleIdentifier]?
  +///    optionalParameterTypes ::=
  +///        optionalPositionalParameterTypes | namedParameterTypes
  +///    optionalPositionalParameterTypes ::=
  +///        [ normalParameterTypes ,? ]
  +///
  +/// Clients may not extend, implement or mix-in this class.
   abstract class GenericFunctionType implements TypeAnnotation {
  -  /**
  -   * Return the keyword 'Function'.
  -   */
  +  /// Return the keyword 'Function'.
     Token get functionKeyword;
   
  -  /**
  -   * Set the keyword 'Function' to the given [token].
  -   */
  +  /// Set the keyword 'Function' to the given [token].
     void set functionKeyword(Token token);
   
  -  /**
  -   * Return the parameters associated with the function type.
  -   */
  +  /// Return the parameters associated with the function type.
     FormalParameterList get parameters;
   
  -  /**
  -   * Set the parameters associated with the function type to the given list of
  -   * [parameters].
  -   */
  +  /// Set the parameters associated with the function type to the given list of
  +  /// [parameters].
     void set parameters(FormalParameterList parameters);
   
  -  /**
  -   * Set the question mark indicating that the type is nullable to the given
  -   * [token].
  -   */
  +  /// Set the question mark indicating that the type is nullable to the given
  +  /// [token].
     void set question(Token token);
   
  -  /**
  -   * Return the return type of the function type being defined, or `null` if
  -   * no return type was given.
  -   */
  +  /// Return the return type of the function type being defined, or `null` if
  +  /// no return type was given.
     TypeAnnotation get returnType;
   
  -  /**
  -   * Set the return type of the function type being defined to the given[type].
  -   */
  +  /// Set the return type of the function type being defined to the given[type].
     void set returnType(TypeAnnotation type);
   
  -  /**
  -   * Return the type parameters for the function type, or `null` if the function
  -   * type does not have any type parameters.
  -   */
  +  /// Return the type parameters for the function type, or `null` if the
  +  /// function type does not have any type parameters.
     TypeParameterList get typeParameters;
   
  -  /**
  -   * Set the type parameters for the function type to the given list of
  -   * [typeParameters].
  -   */
  +  /// Set the type parameters for the function type to the given list of
  +  /// [typeParameters].
     void set typeParameters(TypeParameterList typeParameters);
   }
   
  -/**
  - * A generic type alias.
  - *
  - *    functionTypeAlias ::=
  - *        metadata 'typedef' [SimpleIdentifier] [TypeParameterList]? = [FunctionType] ';'
  - *
  - * Clients may not extend, implement or mix-in this class.
  - */
  +/// A generic type alias.
  +///
  +///    functionTypeAlias ::=
  +///        metadata 'typedef' [SimpleIdentifier] [TypeParameterList]? = [FunctionType] ';'
  +///
  +/// Clients may not extend, implement or mix-in this class.
   abstract class GenericTypeAlias implements TypeAlias {
  -  /**
  -     * Return the equal sign separating the name being defined from the function
  -     * type.
  -     */
  +  /// Return the equal sign separating the name being defined from the function
  +  /// type.
     Token get equals;
   
  -  /**
  -     * Set the equal sign separating the name being defined from the function type
  -     * to the given [token].
  -     */
  +  /// Set the equal sign separating the name being defined from the function
  +  /// type to the given [token].
     void set equals(Token token);
   
  -  /**
  -     * Return the type of function being defined by the alias.
  -     */
  +  /// Return the type of function being defined by the alias.
     GenericFunctionType get functionType;
   
  -  /**
  -     * Set the type of function being defined by the alias to the given
  -     * [functionType].
  -     */
  +  /// Set the type of function being defined by the alias to the given
  +  /// [functionType].
     void set functionType(GenericFunctionType functionType);
   
  -  /**
  -     * Return the type parameters for the function type, or `null` if the function
  -     * type does not have any type parameters.
  -     */
  +  /// Return the type parameters for the function type, or `null` if the
  +  /// function type does not have any type parameters.
     TypeParameterList get typeParameters;
   
  -  /**
  -     * Set the type parameters for the function type to the given list of
  -     * [typeParameters].
  -     */
  +  /// Set the type parameters for the function type to the given list of
  +  /// [typeParameters].
     void set typeParameters(TypeParameterList typeParameters);
   }
   
  -/**
  - * A combinator that restricts the names being imported to those that are not in
  - * a given list.
  - *
  - *    hideCombinator ::=
  - *        'hide' [SimpleIdentifier] (',' [SimpleIdentifier])*
  - *
  - * Clients may not extend, implement or mix-in this class.
  - */
  +/// A combinator that restricts the names being imported to those that are not
  +/// in a given list.
  +///
  +///    hideCombinator ::=
  +///        'hide' [SimpleIdentifier] (',' [SimpleIdentifier])*
  +///
  +/// Clients may not extend, implement or mix-in this class.
   abstract class HideCombinator implements Combinator {
  -  /**
  -   * Return the list of names from the library that are hidden by this
  -   * combinator.
  -   */
  +  /// Return the list of names from the library that are hidden by this
  +  /// combinator.
     NodeList<SimpleIdentifier> get hiddenNames;
   }
   
  -/**
  - * A node that represents an identifier.
  - *
  - *    identifier ::=
  - *        [SimpleIdentifier]
  - *      | [PrefixedIdentifier]
  - *
  - * Clients may not extend, implement or mix-in this class.
  - */
  +/// A node that represents an identifier.
  +///
  +///    identifier ::=
  +///        [SimpleIdentifier]
  +///      | [PrefixedIdentifier]
  +///
  +/// Clients may not extend, implement or mix-in this class.
   abstract class Identifier implements Expression {
  -  /**
  -   * Return the best element available for this operator. If resolution was able
  -   * to find a better element based on type propagation, that element will be
  -   * returned. Otherwise, the element found using the result of static analysis
  -   * will be returned. If resolution has not been performed, then `null` will be
  -   * returned.
  -   *
  -   * Deprecated: The analyzer no longer computes propagated type information.
  -   * Use [staticElement] instead.
  -   */
  +  /// Return the best element available for this operator. If resolution was
  +  /// able to find a better element based on type propagation, that element will
  +  /// be returned. Otherwise, the element found using the result of static
  +  /// analysis will be returned. If resolution has not been performed, then
  +  /// `null` will be returned.
  +  ///
  +  /// Deprecated: The analyzer no longer computes propagated type information.
  +  /// Use [staticElement] instead.
     @deprecated
     Element get bestElement;
   
  -  /**
  -   * Return the lexical representation of the identifier.
  -   */
  +  /// Return the lexical representation of the identifier.
     String get name;
   
  -  /**
  -   * Return the element associated with this identifier based on propagated type
  -   * information, or `null` if the AST structure has not been resolved or if
  -   * this identifier could not be resolved. One example of the latter case is an
  -   * identifier that is not defined within the scope in which it appears.
  -   *
  -   * Deprecated: The analyzer no longer computes propagated type information.
  -   * Use [staticElement] instead.
  -   */
  +  /// Return the element associated with this identifier based on propagated
  +  /// type information, or `null` if the AST structure has not been resolved or
  +  /// if this identifier could not be resolved. One example of the latter case
  +  /// is an identifier that is not defined within the scope in which it appears.
  +  ///
  +  /// Deprecated: The analyzer no longer computes propagated type information.
  +  /// Use [staticElement] instead.
     @deprecated
     Element get propagatedElement;
   
  -  /**
  -   * Return the element associated with this identifier based on static type
  -   * information, or `null` if the AST structure has not been resolved or if
  -   * this identifier could not be resolved. One example of the latter case is an
  -   * identifier that is not defined within the scope in which it appears
  -   */
  +  /// Return the element associated with this identifier based on static type
  +  /// information, or `null` if the AST structure has not been resolved or if
  +  /// this identifier could not be resolved. One example of the latter case is
  +  /// an identifier that is not defined within the scope in which it appears.
     Element get staticElement;
   
  -  /**
  -   * Return `true` if the given [name] is visible only within the library in
  -   * which it is declared.
  -   */
  +  /// Return `true` if the given [name] is visible only within the library in
  +  /// which it is declared.
     static bool isPrivateName(String name) =>
         StringUtilities.startsWithChar(name, 0x5F); // '_'
   }
   
  -/**
  - * The basic structure of an if element.
  - *
  - * Clients may not extend, implement or mix-in this class.
  - */
  +/// The basic structure of an if element.
  +///
  +/// Clients may not extend, implement or mix-in this class.
   abstract class IfElement<E> implements AstNode {
  -  /**
  -   * Return the condition used to determine which of the statements is executed
  -   * next.
  -   */
  +  /// Return the condition used to determine which of the statements is executed
  +  /// next.
     Expression get condition;
   
  -  /**
  -   * Return the statement that is executed if the condition evaluates to
  -   * `false`, or `null` if there is no else statement.
  -   */
  +  /// Return the statement that is executed if the condition evaluates to
  +  /// `false`, or `null` if there is no else statement.
     E get elseElement;
   
  -  /**
  -   * Return the token representing the 'else' keyword, or `null` if there is no
  -   * else statement.
  -   */
  +  /// Return the token representing the 'else' keyword, or `null` if there is no
  +  /// else statement.
     Token get elseKeyword;
   
  -  /**
  -   * Return the token representing the 'if' keyword.
  -   */
  +  /// Return the token representing the 'if' keyword.
     Token get ifKeyword;
   
  -  /**
  -   * Return the left parenthesis.
  -   */
  +  /// Return the left parenthesis.
     Token get leftParenthesis;
   
  -  /**
  -   * Return the right parenthesis.
  -   */
  +  /// Return the right parenthesis.
     Token get rightParenthesis;
   
  -  /**
  -   * Return the statement that is executed if the condition evaluates to `true`.
  -   */
  +  /// Return the statement that is executed if the condition evaluates to
  +  /// `true`.
     E get thenElement;
   }
   
  -/**
  - * An if statement.
  - *
  - *    ifStatement ::=
  - *        'if' '(' [Expression] ')' [Statement] ('else' [Statement])?
  - *
  - * Clients may not extend, implement or mix-in this class.
  - */
  +/// An if statement.
  +///
  +///    ifStatement ::=
  +///        'if' '(' [Expression] ')' [Statement] ('else' [Statement])?
  +///
  +/// Clients may not extend, implement or mix-in this class.
   abstract class IfStatement implements Statement {
  -  /**
  -   * Return the condition used to determine which of the statements is executed
  -   * next.
  -   */
  +  /// Return the condition used to determine which of the statements is executed
  +  /// next.
     Expression get condition;
   
  -  /**
  -   * Set the condition used to determine which of the statements is executed
  -   * next to the given [expression].
  -   */
  +  /// Set the condition used to determine which of the statements is executed
  +  /// next to the given [expression].
     void set condition(Expression expression);
   
  -  /**
  -   * Return the token representing the 'else' keyword, or `null` if there is no
  -   * else statement.
  -   */
  +  /// Return the token representing the 'else' keyword, or `null` if there is no
  +  /// else statement.
     Token get elseKeyword;
   
  -  /**
  -   * Set the token representing the 'else' keyword to the given [token].
  -   */
  +  /// Set the token representing the 'else' keyword to the given [token].
     void set elseKeyword(Token token);
   
  -  /**
  -   * Return the statement that is executed if the condition evaluates to
  -   * `false`, or `null` if there is no else statement.
  -   */
  +  /// Return the statement that is executed if the condition evaluates to
  +  /// `false`, or `null` if there is no else statement.
     Statement get elseStatement;
   
  -  /**
  -   * Set the statement that is executed if the condition evaluates to `false`
  -   * to the given [statement].
  -   */
  +  /// Set the statement that is executed if the condition evaluates to `false`
  +  /// to the given [statement].
     void set elseStatement(Statement statement);
   
  -  /**
  -   * Return the token representing the 'if' keyword.
  -   */
  +  /// Return the token representing the 'if' keyword.
     Token get ifKeyword;
   
  -  /**
  -   * Set the token representing the 'if' keyword to the given [token].
  -   */
  +  /// Set the token representing the 'if' keyword to the given [token].
     void set ifKeyword(Token token);
   
  -  /**
  -   * 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 statement that is executed if the condition evaluates to `true`.
  -   */
  +  /// Return the statement that is executed if the condition evaluates to
  +  /// `true`.
     Statement get thenStatement;
   
  -  /**
  -   * Set the statement that is executed if the condition evaluates to `true` to
  -   * the given [statement].
  -   */
  +  /// Set the statement that is executed if the condition evaluates to `true` to
  +  /// the given [statement].
     void set thenStatement(Statement statement);
   }
   
  -/**
  - * The "implements" clause in an class declaration.
  - *
  - *    implementsClause ::=
  - *        'implements' [TypeName] (',' [TypeName])*
  - *
  - * Clients may not extend, implement or mix-in this class.
  - */
  +/// The "implements" clause in an class declaration.
  +///
  +///    implementsClause ::=
  +///        'implements' [TypeName] (',' [TypeName])*
  +///
  +/// Clients may not extend, implement or mix-in this class.
   abstract class ImplementsClause implements AstNode {
  -  /**
  -   * Return the token representing the 'implements' keyword.
  -   */
  +  /// Return the token representing the 'implements' keyword.
     Token get implementsKeyword;
   
  -  /**
  -   * Set the token representing the 'implements' keyword to the given [token].
  -   */
  +  /// Set the token representing the 'implements' keyword to the given [token].
     void set implementsKeyword(Token token);
   
  -  /**
  -   * Return the list of the interfaces that are being implemented.
  -   */
  +  /// Return the list of the interfaces that are being implemented.
     NodeList<TypeName> get interfaces;
   }
   
  -/**
  - * An import directive.
  - *
  - *    importDirective ::=
  - *        [Annotation] 'import' [StringLiteral] ('as' identifier)? [Combinator]* ';'
  - *      | [Annotation] 'import' [StringLiteral] 'deferred' 'as' identifier [Combinator]* ';'
  - *
  - * Clients may not extend, implement or mix-in this class.
  - */
  +/// An import directive.
  +///
  +///    importDirective ::=
  +///        [Annotation] 'import' [StringLiteral] ('as' identifier)? [Combinator]* ';'
  +///      | [Annotation] 'import' [StringLiteral] 'deferred' 'as' identifier [Combinator]* ';'
  +///
  +/// Clients may not extend, implement or mix-in this class.
   abstract class ImportDirective implements NamespaceDirective {
     static Comparator<ImportDirective> COMPARATOR =
         (ImportDirective import1, ImportDirective import2) {
  
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: // 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';
  