Fix dartdoc for AST nodes

pkg/analyzer/lib/dart/ast/ast.dart

 // Copyright (c) 2014, the Dart project authors.  Please see the AUTHORS file
 // 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](../element/element.dart).
  *
@@ skipping 35 matching lines @@
 import 'package:analyzer/src/generated/utilities_dart.dart';
 
 /**
  * Two or more string literals that are implicitly concatenated because of being
  * adjacent (separated only by whitespace).
  *
  * While the grammar only allows adjacent strings when all of the strings are of
  * the same kind (single line or multi-line), this class doesn't enforce that
  * restriction.
  *
- * > adjacentStrings ::=
- * >     [StringLiteral] [StringLiteral]+
+ *    adjacentStrings ::=
+ *        [StringLiteral] [StringLiteral]+
  *
  * Clients may not extend, implement or mix-in this class.
  */
 abstract class AdjacentStrings extends StringLiteral {
   /**
    * Initialize a newly created list of adjacent strings. To be syntactically
    * valid, the list of [strings] must contain at least two elements.
    */
   factory AdjacentStrings(List<StringLiteral> strings) = AdjacentStringsImpl;
 
@@ skipping 35 matching lines @@
   /**
    * Return a list containing the comment and annotations associated with this
    * node, sorted in lexical order.
    */
   List<AstNode> get sortedCommentAndAnnotations;
 }
 
 /**
  * An annotation that can be associated with an AST node.
  *
- * > metadata ::=
- * >     annotation*
- * >
- * > annotation ::=
- * >     '@' [Identifier] ('.' [SimpleIdentifier])? [ArgumentList]?
+ *    metadata ::=
+ *        annotation*
+ *
+ *    annotation ::=
+ *        '@' [Identifier] ('.' [SimpleIdentifier])? [ArgumentList]?
  *
  * Clients may not extend, implement or mix-in this class.
  */
 abstract class Annotation extends AstNode {
   /**
    * Initialize a newly created annotation. Both the [period] and the
    * [constructorName] can be `null` if the annotation is not referencing a
    * named constructor. The [arguments] can be `null` if the annotation is not
    * referencing a constructor.
    */
@@ skipping 80 matching lines @@
   /**
    * Set the period before the constructor name to the given [token].
    */
   void set period(Token token);
 }
 
 /**
  * A list of arguments in the invocation of an executable element (that is, a
  * function, method, or constructor).
  *
- * > argumentList ::=
- * >     '(' arguments? ')'
- * >
- * > arguments ::=
- * >     [NamedExpression] (',' [NamedExpression])*
- * >   | [Expression] (',' [Expression])* (',' [NamedExpression])*
+ *    argumentList ::=
+ *        '(' arguments? ')'
+ *
+ *    arguments ::=
+ *        [NamedExpression] (',' [NamedExpression])*
+ *      | [Expression] (',' [Expression])* (',' [NamedExpression])*
  *
  * Clients may not extend, implement or mix-in this class.
  */
 abstract class ArgumentList extends AstNode {
   /**
    * Initialize a newly created list of arguments. The list of [arguments] can
    * be `null` if there are no arguments.
    */
   factory ArgumentList(Token leftParenthesis, List<Expression> arguments,
       Token rightParenthesis) = ArgumentListImpl;
@@ skipping 38 matching lines @@
 
   /**
    * Set the right parenthesis to the given [token].
    */
   void set rightParenthesis(Token token);
 }
 
 /**
  * An as expression.
  *
- * > asExpression ::=
- * >     [Expression] 'as' [TypeName]
+ *    asExpression ::=
+ *        [Expression] 'as' [TypeName]
  *
  * Clients may not extend, implement or mix-in this class.
  */
 abstract class AsExpression extends Expression {
   /**
    * Initialize a newly created as expression.
    */
   factory AsExpression(Expression expression, Token asOperator, TypeName type) =
       AsExpressionImpl;
 
@@ skipping 25 matching lines @@
 
   /**
    * Set the name of the type being cast to to the given [name].
    */
   void set type(TypeName name);
 }
 
 /**
  * An assert statement.
  *
- * > assertStatement ::=
- * >     'assert' '(' [Expression] ')' ';'
+ *    assertStatement ::=
+ *        'assert' '(' [Expression] ')' ';'
  *
  * Clients may not extend, implement or mix-in this class.
  */
 abstract class AssertStatement extends Statement {
   /**
    * Initialize a newly created assert statement. The [comma] and [message] can
    * be `null` if there is no message.
    */
   factory AssertStatement(
       Token assertKeyword,
@@ skipping 75 matching lines @@
 
   /**
    * Set the semicolon terminating the statement to the given [token].
    */
   void set semicolon(Token token);
 }
 
 /**
  * An assignment expression.
  *
- * > assignmentExpression ::=
- * >     [Expression] operator [Expression]
+ *    assignmentExpression ::=
+ *        [Expression] operator [Expression]
  *
  * Clients may not extend, implement or mix-in this class.
  */
 abstract class AssignmentExpression extends Expression {
   /**
    * Initialize a newly created assignment expression.
    */
   factory AssignmentExpression(
           Expression leftHandSide, Token operator, Expression rightHandSide) =
       AssignmentExpressionImpl;
@@ skipping 408 matching lines @@
   R visitWhileStatement(WhileStatement node);
 
   R visitWithClause(WithClause node);
 
   R visitYieldStatement(YieldStatement node);
 }
 
 /**
  * An await expression.
  *
- * > awaitExpression ::=
- * >     'await' [Expression]
+ *    awaitExpression ::=
+ *        'await' [Expression]
  *
  * Clients may not extend, implement or mix-in this class.
  */
 abstract class AwaitExpression extends Expression {
   /**
    * Initialize a newly created await expression.
    */
   factory AwaitExpression(Token awaitKeyword, Expression expression) =
       AwaitExpressionImpl;
 
@@ skipping 14 matching lines @@
 
   /**
    * Set the expression whose value is being waited on to the given [expression].
    */
   void set expression(Expression expression);
 }
 
 /**
  * A binary (infix) expression.
  *
- * > binaryExpression ::=
- * >     [Expression] [Token] [Expression]
+ *    binaryExpression ::=
+ *        [Expression] [Token] [Expression]
  *
  * Clients may not extend, implement or mix-in this class.
  */
 abstract class BinaryExpression extends Expression {
   /**
    * Initialize a newly created binary expression.
    */
   factory BinaryExpression(
           Expression leftOperand, Token operator, Expression rightOperand) =
       BinaryExpressionImpl;
@@ skipping 64 matching lines @@
   /**
    * Set the element associated with the operator based on the static type of
    * the left operand to the given [element].
    */
   void set staticElement(MethodElement element);
 }
 
 /**
  * A sequence of statements.
  *
- * > block ::=
- * >     '{' statement* '}'
+ *    block ::=
+ *        '{' statement* '}'
  *
  * Clients may not extend, implement or mix-in this class.
  */
 abstract class Block extends Statement {
   /**
    * Initialize a newly created block of code.
    */
   factory Block(
           Token leftBracket, List<Statement> statements, Token rightBracket) =
       BlockImpl;
@@ skipping 20 matching lines @@
 
   /**
    * Return the statements contained in the block.
    */
   NodeList<Statement> get statements;
 }
 
 /**
  * A function body that consists of a block of statements.
  *
- * > blockFunctionBody ::=
- * >     ('async' | 'async' '*' | 'sync' '*')? [Block]
+ *    blockFunctionBody ::=
+ *        ('async' | 'async' '*' | 'sync' '*')? [Block]
  *
  * Clients may not extend, implement or mix-in this class.
  */
 abstract class BlockFunctionBody extends FunctionBody {
   /**
    * Initialize a newly created function body consisting of a block of
    * statements. The [keyword] can be `null` if there is no keyword specified
    * for the block. The [star] can be `null` if there is no star following the
    * keyword (and must be `null` if there is no keyword).
    */
@@ skipping 17 matching lines @@
 
   /**
    * Set the star following the 'async' or 'sync' keyword to the given [token].
    */
   void set star(Token token);
 }
 
 /**
  * A boolean literal expression.
  *
- * > booleanLiteral ::=
- * >     'false' | 'true'
+ *    booleanLiteral ::=
+ *        'false' | 'true'
  *
  * Clients may not extend, implement or mix-in this class.
  */
 abstract class BooleanLiteral extends Literal {
   /**
    * Initialize a newly created boolean literal.
    */
   factory BooleanLiteral(Token literal, bool value) = BooleanLiteralImpl;
 
   /**
    * 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.
    */
   bool get value;
 }
 
 /**
  * A break statement.
  *
- * > breakStatement ::=
- * >     'break' [SimpleIdentifier]? ';'
+ *    breakStatement ::=
+ *        'break' [SimpleIdentifier]? ';'
  *
  * Clients may not extend, implement or mix-in this class.
  */
 abstract class BreakStatement extends Statement {
   /**
    * Initialize a newly created break statement. The [label] can be `null` if
    * there is no label associated with the statement.
    */
   factory BreakStatement(
           Token breakKeyword, SimpleIdentifier label, Token semicolon) =
@@ skipping 46 matching lines @@
    * [node].
    */
   void set target(AstNode node);
 }
 
 /**
  * A sequence of cascaded expressions: expressions that share a common target.
  * There are three kinds of expressions that can be used in a cascade
  * expression: [IndexExpression], [MethodInvocation] and [PropertyAccess].
  *
- * > cascadeExpression ::=
- * >     [Expression] cascadeSection*
- * >
- * > cascadeSection ::=
- * >     '..'  (cascadeSelector arguments*) (assignableSelector arguments*)*
- * >     (assignmentOperator expressionWithoutCascade)?
- * >
- * > cascadeSelector ::=
- * >     '[ ' expression '] '
- * >   | identifier
+ *    cascadeExpression ::=
+ *        [Expression] cascadeSection*
+ *
+ *    cascadeSection ::=
+ *        '..'  (cascadeSelector arguments*) (assignableSelector arguments*)*
+ *        (assignmentOperator expressionWithoutCascade)?
+ *
+ *    cascadeSelector ::=
+ *        '[ ' expression '] '
+ *      | identifier
  *
  * Clients may not extend, implement or mix-in this class.
  */
 abstract class CascadeExpression extends Expression {
   /**
    * Initialize a newly created cascade expression. The list of
    * [cascadeSections] must contain at least one element.
    */
   factory CascadeExpression(
           Expression target, List<Expression> cascadeSections) =
@@ skipping 11 matching lines @@
 
   /**
    * Set the target of the cascade sections to the given [expression].
    */
   void set target(Expression target);
 }
 
 /**
  * A catch clause within a try statement.
  *
- * > onPart ::=
- * >     catchPart [Block]
- * >   | 'on' type catchPart? [Block]
- * >
- * > catchPart ::=
- * >     'catch' '(' [SimpleIdentifier] (',' [SimpleIdentifier])? ')'
+ *    onPart ::=
+ *        catchPart [Block]
+ *      | 'on' type catchPart? [Block]
+ *
+ *    catchPart ::=
+ *        'catch' '(' [SimpleIdentifier] (',' [SimpleIdentifier])? ')'
  *
  * Clients may not extend, implement or mix-in this class.
  */
 abstract class CatchClause extends AstNode {
   /**
    * Initialize a newly created catch clause. The [onKeyword] and
    * [exceptionType] can be `null` if the clause will catch all exceptions. The
    * [comma] and [stackTraceParameter] can be `null` if the stack trace
    * parameter is not defined.
    */
@@ skipping 105 matching lines @@
   /**
    * Set the parameter whose value will be the stack trace associated with the
    * exception to the given [parameter].
    */
   void set stackTraceParameter(SimpleIdentifier parameter);
 }
 
 /**
  * The declaration of a class.
  *
- * > classDeclaration ::=
- * >     'abstract'? 'class' [SimpleIdentifier] [TypeParameterList]?
- * >     ([ExtendsClause] [WithClause]?)?
- * >     [ImplementsClause]?
- * >     '{' [ClassMember]* '}'
+ *    classDeclaration ::=
+ *        'abstract'? 'class' [SimpleIdentifier] [TypeParameterList]?
+ *        ([ExtendsClause] [WithClause]?)?
+ *        [ImplementsClause]?
+ *        '{' [ClassMember]* '}'
  *
  * Clients may not extend, implement or mix-in this class.
  */
 abstract class ClassDeclaration extends NamedCompilationUnitMember {
   /**
    * Initialize a newly created class declaration. Either or both of the
    * [comment] and [metadata] can be `null` if the class does not have the
    * corresponding attribute. The [abstractKeyword] can be `null` if the class
    * is not abstract. The [typeParameters] can be `null` if the class does not
    * have any type parameters. Any or all of the [extendsClause], [withClause],
@@ skipping 146 matching lines @@
 /**
  * A node that declares a name within the scope of a class.
  *
  * Clients may not extend, implement or mix-in this class.
  */
 abstract class ClassMember extends Declaration {}
 
 /**
  * A class type alias.
  *
- * > classTypeAlias ::=
- * >     [SimpleIdentifier] [TypeParameterList]? '=' 'abstract'? mixinApplication
- * >
- * > mixinApplication ::=
- * >     [TypeName] [WithClause] [ImplementsClause]? ';'
+ *    classTypeAlias ::=
+ *        [SimpleIdentifier] [TypeParameterList]? '=' 'abstract'? mixinApplication
+ *
+ *    mixinApplication ::=
+ *        [TypeName] [WithClause] [ImplementsClause]? ';'
  *
  * Clients may not extend, implement or mix-in this class.
  */
 abstract class ClassTypeAlias extends TypeAlias {
   /**
    * Initialize a newly created class type alias. Either or both of the
    * [comment] and [metadata] can be `null` if the class type alias does not
    * have the corresponding attribute. The [typeParameters] can be `null` if the
    * class does not have any type parameters. The [abstractKeyword] can be
    * `null` if the class is not abstract. The [implementsClause] can be `null`
@@ skipping 79 matching lines @@
 
   /**
    * Set the with clause for this class to the given with [withClause].
    */
   void set withClause(WithClause withClause);
 }
 
 /**
  * A combinator associated with an import or export directive.
  *
- * > combinator ::=
- * >     [HideCombinator]
- * >   | [ShowCombinator]
+ *    combinator ::=
+ *        [HideCombinator]
+ *      | [ShowCombinator]
  *
  * Clients may not extend, implement or mix-in this class.
  */
 abstract class Combinator extends AstNode {
   /**
    * Return the 'hide' or 'show' keyword specifying what kind of processing is
    * to be done on the names.
    */
   Token get keyword;
 
   /**
    * Set the 'hide' or 'show' keyword specifying what kind of processing is
    * to be done on the names to the given [token].
    */
   void set keyword(Token token);
 }
 
 /**
  * A comment within the source code.
  *
- * > comment ::=
- * >     endOfLineComment
- * >   | blockComment
- * >   | documentationComment
- * >
- * > endOfLineComment ::=
- * >     '//' (CHARACTER - EOL)* EOL
- * >
- * > blockComment ::=
- * >     '/ *' CHARACTER* '&#42;/'
- * >
- * > documentationComment ::=
- * >     '/ **' (CHARACTER | [CommentReference])* '&#42;/'
- * >   | ('///' (CHARACTER - EOL)* EOL)+
+ *    comment ::=
+ *        endOfLineComment
+ *      | blockComment
+ *      | documentationComment
+ *
+ *    endOfLineComment ::=
+ *        '//' (CHARACTER - EOL)* EOL
+ *
+ *    blockComment ::=
+ *        '/ *' CHARACTER* '&#42;/'
+ *
+ *    documentationComment ::=
+ *        '/ **' (CHARACTER | [CommentReference])* '&#42;/'
+ *      | ('///' (CHARACTER - EOL)* EOL)+
  *
  * Clients may not extend, implement or mix-in this class.
  */
 abstract class Comment extends AstNode {
   /**
    * Initialize a newly created comment. The list of [tokens] must contain at
    * least one token. The [type] is the type of the comment. The list of
    * [references] can be empty if the comment does not contain any embedded
    * references.
    */
@@ skipping 48 matching lines @@
   /**
    * Create an end-of-line comment consisting of the given [tokens].
    */
   static Comment createEndOfLineComment(List<Token> tokens) =>
       CommentImpl.createEndOfLineComment(tokens);
 }
 
 /**
  * A reference to a Dart element that is found within a documentation comment.
  *
- * > commentReference ::=
- * >     '[' 'new'? [Identifier] ']'
+ *    commentReference ::=
+ *        '[' 'new'? [Identifier] ']'
  *
  * Clients may not extend, implement or mix-in this class.
  */
 abstract class CommentReference extends AstNode {
   /**
    * Initialize a newly created reference to a Dart element. The [newKeyword]
    * can be `null` if the reference is not to a constructor.
    */
   factory CommentReference(Token newKeyword, Identifier identifier) =
       CommentReferenceImpl;
@@ skipping 22 matching lines @@
 
 /**
  * A compilation unit.
  *
  * While the grammar restricts the order of the directives and declarations
  * within a compilation unit, this class does not enforce those restrictions.
  * In particular, the children of a compilation unit will be visited in lexical
  * order even if lexical order does not conform to the restrictions of the
  * grammar.
  *
- * > compilationUnit ::=
- * >     directives declarations
- * >
- * > directives ::=
- * >     [ScriptTag]? [LibraryDirective]? namespaceDirective* [PartDirective]*
- * >   | [PartOfDirective]
- * >
- * > namespaceDirective ::=
- * >     [ImportDirective]
- * >   | [ExportDirective]
- * >
- * > declarations ::=
- * >     [CompilationUnitMember]*
+ *    compilationUnit ::=
+ *        directives declarations
+ *
+ *    directives ::=
+ *        [ScriptTag]? [LibraryDirective]? namespaceDirective* [PartDirective]*
+ *      | [PartOfDirective]
+ *
+ *    namespaceDirective ::=
+ *        [ImportDirective]
+ *      | [ExportDirective]
+ *
+ *    declarations ::=
+ *        [CompilationUnitMember]*
  *
  * Clients may not extend, implement or mix-in this class.
  */
 abstract class CompilationUnit extends AstNode {
   /**
    * Initialize a newly created compilation unit to have the given directives
    * and declarations. The [scriptTag] can be `null` if there is no script tag
    * in the compilation unit. The list of [directives] can be `null` if there
    * are no directives in the compilation unit. The list of [declarations] can
    * be `null` if there are no declarations in the compilation unit.
@@ skipping 65 matching lines @@
    * Return a list containing all of the directives and declarations in this
    * compilation unit, sorted in lexical order.
    */
   List<AstNode> get sortedDirectivesAndDeclarations;
 }
 
 /**
  * A node that declares one or more names within the scope of a compilation
  * unit.
  *
- * > compilationUnitMember ::=
- * >     [ClassDeclaration]
- * >   | [TypeAlias]
- * >   | [FunctionDeclaration]
- * >   | [MethodDeclaration]
- * >   | [VariableDeclaration]
- * >   | [VariableDeclaration]
+ *    compilationUnitMember ::=
+ *        [ClassDeclaration]
+ *      | [TypeAlias]
+ *      | [FunctionDeclaration]
+ *      | [MethodDeclaration]
+ *      | [VariableDeclaration]
+ *      | [VariableDeclaration]
  *
  * Clients may not extend, implement or mix-in this class.
  */
 abstract class CompilationUnitMember extends Declaration {}
 
 /**
  * A conditional expression.
  *
- * > conditionalExpression ::=
- * >     [Expression] '?' [Expression] ':' [Expression]
+ *    conditionalExpression ::=
+ *        [Expression] '?' [Expression] ':' [Expression]
  *
  * Clients may not extend, implement or mix-in this class.
  */
 abstract class ConditionalExpression extends Expression {
   /**
    * Initialize a newly created conditional expression.
    */
   factory ConditionalExpression(
       Expression condition,
       Token question,
@@ skipping 57 matching lines @@
   /**
    * Set the expression that is executed if the condition evaluates to `true` to
    * the given [expression].
    */
   void set thenExpression(Expression expression);
 }
 
 /**
  * A configuration in either an import or export directive.
  *
- * > configuration ::=
- * >     'if' '(' test ')' uri
- * >
- * > test ::=
- * >     dottedName ('==' stringLiteral)?
- * >
- * > dottedName ::=
- * >     identifier ('.' identifier)*
+ *    configuration ::=
+ *        'if' '(' test ')' uri
+ *
+ *    test ::=
+ *        dottedName ('==' stringLiteral)?
+ *
+ *    dottedName ::=
+ *        identifier ('.' identifier)*
  *
  * Clients may not extend, implement or mix-in this class.
  */
 abstract class Configuration extends AstNode {
   /**
    * Initialize a newly created configuration.
    */
   factory Configuration(
       Token ifKeyword,
       Token leftParenthesis,
@@ skipping 77 matching lines @@
   /**
    * Set the value to which the value of the declared variable will be
    * compared to the given [value].
    */
   void set value(StringLiteral value);
 }
 
 /**
  * A constructor declaration.
  *
- * > constructorDeclaration ::=
- * >     constructorSignature [FunctionBody]?
- * >   | constructorName formalParameterList ':' 'this' ('.' [SimpleIdentifier])? arguments
- * >
- * > constructorSignature ::=
- * >     'external'? constructorName formalParameterList initializerList?
- * >   | 'external'? 'factory' factoryName formalParameterList initializerList?
- * >   | 'external'? 'const'  constructorName formalParameterList initializerList?
- * >
- * > constructorName ::=
- * >     [SimpleIdentifier] ('.' [SimpleIdentifier])?
- * >
- * > factoryName ::=
- * >     [Identifier] ('.' [SimpleIdentifier])?
- * >
- * > initializerList ::=
- * >     ':' [ConstructorInitializer] (',' [ConstructorInitializer])*
+ *    constructorDeclaration ::=
+ *        constructorSignature [FunctionBody]?
+ *      | constructorName formalParameterList ':' 'this' ('.' [SimpleIdentifier])? arguments
+ *
+ *    constructorSignature ::=
+ *        'external'? constructorName formalParameterList initializerList?
+ *      | 'external'? 'factory' factoryName formalParameterList initializerList?
+ *      | 'external'? 'const'  constructorName formalParameterList initializerList?
+ *
+ *    constructorName ::=
+ *        [SimpleIdentifier] ('.' [SimpleIdentifier])?
+ *
+ *    factoryName ::=
+ *        [Identifier] ('.' [SimpleIdentifier])?
+ *
+ *    initializerList ::=
+ *        ':' [ConstructorInitializer] (',' [ConstructorInitializer])*
  *
  * Clients may not extend, implement or mix-in this class.
  */
 abstract class ConstructorDeclaration extends ClassMember {
   /**
    * Initialize a newly created constructor declaration. The [externalKeyword]
    * can be `null` if the constructor is not external. Either or both of the
    * [comment] and [metadata] can be `null` if the constructor does not have the
    * corresponding attribute. The [constKeyword] can be `null` if the
    * constructor cannot be used to create a constant. The [factoryKeyword] can
@@ skipping 145 matching lines @@
   /**
    * 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]
+ *    fieldInitializer ::=
+ *        ('this' '.')? [SimpleIdentifier] '=' [Expression]
  *
  * Clients may not extend, implement or mix-in this class.
  */
 abstract class ConstructorFieldInitializer extends ConstructorInitializer {
   /**
    * Initialize a newly created field initializer to initialize the field with
    * the given name to the value of the given expression. The [thisKeyword] and
    * [period] can be `null` if the 'this' keyword was not specified.
    */
   factory ConstructorFieldInitializer(
@@ skipping 56 matching lines @@
 
   /**
    * 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]
+ *    constructorInitializer ::=
+ *        [SuperConstructorInvocation]
+ *      | [ConstructorFieldInitializer]
+ *      | [RedirectingConstructorInvocation]
  *
  * Clients may not extend, implement or mix-in this class.
  */
 abstract class ConstructorInitializer extends AstNode {}
 
 /**
  * The name of a constructor.
  *
- * > constructorName ::=
- * >     type ('.' identifier)?
+ *    constructorName ::=
+ *        type ('.' identifier)?
  *
  * Clients may not extend, implement or mix-in this class.
  */
 abstract class ConstructorName extends AstNode {
   /**
    * Initialize a newly created constructor name. The [period] and [name] can be
    * `null` if the constructor being named is the unnamed constructor.
    */
   factory ConstructorName(TypeName type, Token period, SimpleIdentifier name) =
       ConstructorNameImpl;
@@ skipping 41 matching lines @@
 
   /**
    * Set the name of the type defining the constructor to the given [type] name.
    */
   void set type(TypeName type);
 }
 
 /**
  * A continue statement.
  *
- * > continueStatement ::=
- * >     'continue' [SimpleIdentifier]? ';'
+ *    continueStatement ::=
+ *        'continue' [SimpleIdentifier]? ';'
  *
  * Clients may not extend, implement or mix-in this class.
  */
 abstract class ContinueStatement extends Statement {
   /**
    * Initialize a newly created continue statement. The [label] can be `null` if
    * there is no label associated with the statement.
    */
   factory ContinueStatement(
           Token continueKeyword, SimpleIdentifier label, Token semicolon) =
@@ skipping 58 matching lines @@
    * 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 element;
 }
 
 /**
  * The declaration of a single identifier.
  *
- * > declaredIdentifier ::=
- * >     [Annotation] finalConstVarOrType [SimpleIdentifier]
+ *    declaredIdentifier ::=
+ *        [Annotation] finalConstVarOrType [SimpleIdentifier]
  *
  * Clients may not extend, implement or mix-in this class.
  */
 abstract class DeclaredIdentifier extends Declaration {
   /**
    * Initialize a newly created formal parameter. Either or both of the
    * [comment] and [metadata] can be `null` if the declaration does not have the
    * corresponding attribute. The [keyword] can be `null` if a type name is
    * given. The [type] must be `null` if the keyword is 'var'.
    */
@@ skipping 51 matching lines @@
    * Set the name of the declared type of the parameter to the given [typeName].
    */
   void set type(TypeName typeName);
 }
 
 /**
  * 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])?
+ *    defaultFormalParameter ::=
+ *        [NormalFormalParameter] ('=' [Expression])?
+ *
+ *    defaultNamedParameter ::=
+ *        [NormalFormalParameter] (':' [Expression])?
  *
  * Clients may not extend, implement or mix-in this class.
  */
 abstract class DefaultFormalParameter extends FormalParameter {
   /**
    * Initialize a newly created default formal parameter. The [separator] and
    * [defaultValue] can be `null` if there is no default value.
    */
   factory DefaultFormalParameter(
       NormalFormalParameter parameter,
@@ skipping 38 matching lines @@
   /**
    * 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]
+ *    directive ::=
+ *        [ExportDirective]
+ *      | [ImportDirective]
+ *      | [LibraryDirective]
+ *      | [PartDirective]
+ *      | [PartOfDirective]
  *
  * Clients may not extend, implement or mix-in this class.
  */
 abstract class Directive extends 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] ')' ';'
+ *    doStatement ::=
+ *        'do' [Statement] 'while' '(' [Expression] ')' ';'
  *
  * Clients may not extend, implement or mix-in this class.
  */
 abstract class DoStatement extends Statement {
   /**
    * Initialize a newly created do loop.
    */
   factory DoStatement(
       Token doKeyword,
       Statement body,
@@ skipping 71 matching lines @@
 
   /**
    * 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])*
+ *    dottedName ::=
+ *        [SimpleIdentifier] ('.' [SimpleIdentifier])*
  *
  * Clients may not extend, implement or mix-in this class.
  */
 abstract class DottedName extends AstNode {
   /**
    * Initialize a newly created dotted name.
    */
   factory DottedName(List<SimpleIdentifier> components) = DottedNameImpl;
 
   /**
    * 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+
+ *    doubleLiteral ::=
+ *        decimalDigit+ ('.' decimalDigit*)? exponent?
+ *      | '.' decimalDigit+ exponent?
+ *
+ *    exponent ::=
+ *        ('e' | 'E') ('+' | '-')? decimalDigit+
  *
  * Clients may not extend, implement or mix-in this class.
  */
 abstract class DoubleLiteral extends Literal {
   /**
    * Initialize a newly created floating point literal.
    */
   factory DoubleLiteral(Token literal, double value) = DoubleLiteralImpl;
 
   /**
@@ skipping 14 matching lines @@
   /**
    * 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 ::=
- * >     ';'
+ *    emptyFunctionBody ::=
+ *        ';'
  *
  * Clients may not extend, implement or mix-in this class.
  */
 abstract class EmptyFunctionBody extends FunctionBody {
   /**
    * Initialize a newly created function body.
    */
   factory EmptyFunctionBody(Token semicolon) = EmptyFunctionBodyImpl;
 
   /**
    * 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 ::=
- * >     ';'
+ *    emptyStatement ::=
+ *        ';'
  *
  * Clients may not extend, implement or mix-in this class.
  */
 abstract class EmptyStatement extends Statement {
   /**
    * Initialize a newly created empty statement.
    */
   factory EmptyStatement(Token semicolon) = EmptyStatementImpl;
 
   /**
@@ skipping 30 matching lines @@
 
   /**
    * 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])* (',')? '}'
+ *    enumType ::=
+ *        metadata 'enum' [SimpleIdentifier] '{' [SimpleIdentifier] (',' [SimpleIdentifier])* (',')? '}'
  *
  * Clients may not extend, implement or mix-in this class.
  */
 abstract class EnumDeclaration extends NamedCompilationUnitMember {
   /**
    * Initialize a newly created enumeration declaration. Either or both of the
    * [comment] and [metadata] can be `null` if the declaration does not have the
    * corresponding attribute. The list of [constants] must contain at least one
    * value.
    */
@@ skipping 41 matching lines @@
 
   /**
    * Set the right curly bracket to the given [token].
    */
   void set rightBracket(Token token);
 }
 
 /**
  * An export directive.
  *
- * > exportDirective ::=
- * >     [Annotation] 'export' [StringLiteral] [Combinator]* ';'
+ *    exportDirective ::=
+ *        [Annotation] 'export' [StringLiteral] [Combinator]* ';'
  *
  * Clients may not extend, implement or mix-in this class.
  */
 abstract class ExportDirective extends NamespaceDirective {
   /**
    * Initialize a newly created export directive. Either or both of the
    * [comment] and [metadata] can be `null` if the directive does not have the
    * corresponding attribute. The list of [combinators] can be `null` if there
    * are no combinators.
    */
   factory ExportDirective(
       Comment comment,
       List<Annotation> metadata,
       Token keyword,
       StringLiteral libraryUri,
       List<Configuration> configurations,
       List<Combinator> combinators,
       Token semicolon) = ExportDirectiveImpl;
 }
 
 /**
  * A node that represents an expression.
  *
- * > expression ::=
- * >     [AssignmentExpression]
- * >   | [ConditionalExpression] cascadeSection*
- * >   | [ThrowExpression]
+ *    expression ::=
+ *        [AssignmentExpression]
+ *      | [ConditionalExpression] cascadeSection*
+ *      | [ThrowExpression]
  *
  * Clients may not extend, implement or mix-in this class.
  */
 abstract class Expression extends AstNode {
   /**
    * An empty list of expressions.
    */
   static const List<Expression> EMPTY_LIST = const <Expression>[];
 
   /**
@@ skipping 70 matching lines @@
 
   /**
    * Set the static type of this expression to the given [type].
    */
   void set staticType(DartType type);
 }
 
 /**
  * A function body consisting of a single expression.
  *
- * > expressionFunctionBody ::=
- * >     'async'? '=>' [Expression] ';'
+ *    expressionFunctionBody ::=
+ *        'async'? '=>' [Expression] ';'
  *
  * Clients may not extend, implement or mix-in this class.
  */
 abstract class ExpressionFunctionBody extends FunctionBody {
   /**
    * Initialize a newly created function body consisting of a block of
    * statements. The [keyword] can be `null` if the function body is not an
    * async function body.
    */
   factory ExpressionFunctionBody(Token keyword, Token functionDefinition,
@@ skipping 34 matching lines @@
 
   /**
    * Set the semicolon terminating the statement to the given [token].
    */
   void set semicolon(Token token);
 }
 
 /**
  * An expression used as a statement.
  *
- * > expressionStatement ::=
- * >     [Expression]? ';'
+ *    expressionStatement ::=
+ *        [Expression]? ';'
  *
  * Clients may not extend, implement or mix-in this class.
  */
 abstract class ExpressionStatement extends Statement {
   /**
    * Initialize a newly created expression statement.
    */
   factory ExpressionStatement(Expression expression, Token semicolon) =
       ExpressionStatementImpl;
 
@@ skipping 15 matching lines @@
 
   /**
    * Set the semicolon terminating the statement to the given [token].
    */
   void set semicolon(Token token);
 }
 
 /**
  * The "extends" clause in a class declaration.
  *
- * > extendsClause ::=
- * >     'extends' [TypeName]
+ *    extendsClause ::=
+ *        'extends' [TypeName]
  *
  * Clients may not extend, implement or mix-in this class.
  */
 abstract class ExtendsClause extends AstNode {
   /**
    * Initialize a newly created extends clause.
    */
   factory ExtendsClause(Token extendsKeyword, TypeName superclass) =
       ExtendsClauseImpl;
 
@@ skipping 14 matching lines @@
 
   /**
    * Set the name of the class that is being extended to the given [name].
    */
   void set superclass(TypeName name);
 }
 
 /**
  * The declaration of one or more fields of the same type.
  *
- * > fieldDeclaration ::=
- * >     'static'? [VariableDeclarationList] ';'
+ *    fieldDeclaration ::=
+ *        'static'? [VariableDeclarationList] ';'
  *
  * Clients may not extend, implement or mix-in this class.
  */
 abstract class FieldDeclaration extends ClassMember {
   /**
    * Initialize a newly created field declaration. Either or both of the
    * [comment] and [metadata] can be `null` if the declaration does not have the
    * corresponding attribute. The [staticKeyword] can be `null` if the field is
    * not a static field.
    */
@@ skipping 37 matching lines @@
 
   /**
    * Set the token representing the 'static' keyword to the given [token].
    */
   void set staticKeyword(Token token);
 }
 
 /**
  * A field formal parameter.
  *
- * > fieldFormalParameter ::=
- * >     ('final' [TypeName] | 'const' [TypeName] | 'var' | [TypeName])?
- * >     'this' '.' [SimpleIdentifier] ([TypeParameterList]? [FormalParameterList])?
+ *    fieldFormalParameter ::=
+ *        ('final' [TypeName] | 'const' [TypeName] | 'var' | [TypeName])?
+ *        'this' '.' [SimpleIdentifier] ([TypeParameterList]? [FormalParameterList])?
  *
  * Clients may not extend, implement or mix-in this class.
  */
 abstract class FieldFormalParameter extends NormalFormalParameter {
   /**
    * Initialize a newly created formal parameter. Either or both of the
    * [comment] and [metadata] can be `null` if the parameter does not have the
    * corresponding attribute. The [keyword] can be `null` if there is a type.
    * The [type] must be `null` if the keyword is 'var'. The [thisKeyword] and
    * [period] can be `null` if the keyword 'this' was not provided.  The
@@ skipping 77 matching lines @@
   /**
    * Set the type parameters associated with this method to the given
    * [typeParameters].
    */
   void set typeParameters(TypeParameterList typeParameters);
 }
 
 /**
  * A for-each statement.
  *
- * > forEachStatement ::=
- * >     'await'? 'for' '(' [DeclaredIdentifier] 'in' [Expression] ')' [Block]
- * >   | 'await'? 'for' '(' [SimpleIdentifier] 'in' [Expression] ')' [Block]
+ *    forEachStatement ::=
+ *        'await'? 'for' '(' [DeclaredIdentifier] 'in' [Expression] ')' [Block]
+ *      | 'await'? 'for' '(' [SimpleIdentifier] 'in' [Expression] ')' [Block]
  *
  * Clients may not extend, implement or mix-in this class.
  */
 abstract class ForEachStatement extends Statement {
   /**
    * Initialize a newly created for-each statement whose loop control variable
    * is declared internally (in the for-loop part). The [awaitKeyword] can be
    * `null` if this is not an asynchronous for loop.
    */
   factory ForEachStatement.withDeclaration(
@@ skipping 112 matching lines @@
 
   /**
    * Set the right parenthesis to the given [token].
    */
   void set rightParenthesis(Token token);
 }
 
 /**
  * A node representing a parameter to a function.
  *
- * > formalParameter ::=
- * >     [NormalFormalParameter]
- * >   | [DefaultFormalParameter]
+ *    formalParameter ::=
+ *        [NormalFormalParameter]
+ *      | [DefaultFormalParameter]
  *
  * Clients may not extend, implement or mix-in this class.
  */
 abstract class FormalParameter extends AstNode {
   /**
    * Return the element representing this parameter, or `null` if this parameter
    * has not been resolved.
    */
   ParameterElement get element;
 
@@ skipping 28 matching lines @@
 /**
  * The formal parameter list of a method declaration, function declaration, or
  * function type alias.
  *
  * While the grammar requires all optional formal parameters to follow all of
  * the normal formal parameters and at most one grouping of optional formal
  * parameters, this class does not enforce those constraints. All parameters are
  * flattened into a single list, which can have any or all kinds of parameters
  * (normal, named, and positional) in any order.
  *
- * > formalParameterList ::=
- * >     '(' ')'
- * >   | '(' normalFormalParameters (',' optionalFormalParameters)? ')'
- * >   | '(' optionalFormalParameters ')'
- * >
- * > normalFormalParameters ::=
- * >     [NormalFormalParameter] (',' [NormalFormalParameter])*
- * >
- * > optionalFormalParameters ::=
- * >     optionalPositionalFormalParameters
- * >   | namedFormalParameters
- * >
- * > optionalPositionalFormalParameters ::=
- * >     '[' [DefaultFormalParameter] (',' [DefaultFormalParameter])* ']'
- * >
- * > namedFormalParameters ::=
- * >     '{' [DefaultFormalParameter] (',' [DefaultFormalParameter])* '}'
+ *    formalParameterList ::=
+ *        '(' ')'
+ *      | '(' normalFormalParameters (',' optionalFormalParameters)? ')'
+ *      | '(' optionalFormalParameters ')'
+ *
+ *    normalFormalParameters ::=
+ *        [NormalFormalParameter] (',' [NormalFormalParameter])*
+ *
+ *    optionalFormalParameters ::=
+ *        optionalPositionalFormalParameters
+ *      | namedFormalParameters
+ *
+ *    optionalPositionalFormalParameters ::=
+ *        '[' [DefaultFormalParameter] (',' [DefaultFormalParameter])* ']'
+ *
+ *    namedFormalParameters ::=
+ *        '{' [DefaultFormalParameter] (',' [DefaultFormalParameter])* '}'
  *
  * Clients may not extend, implement or mix-in this class.
  */
 abstract class FormalParameterList extends AstNode {
   /**
    * Initialize a newly created parameter list. The list of [parameters] can be
    * `null` if there are no parameters. The [leftDelimiter] and [rightDelimiter]
    * can be `null` if there are no optional parameters.
    */
   factory FormalParameterList(
@@ skipping 56 matching lines @@
 
   /**
    * Set the right parenthesis to the given [token].
    */
   void set rightParenthesis(Token token);
 }
 
 /**
  * A for statement.
  *
- * > forStatement ::=
- * >     'for' '(' forLoopParts ')' [Statement]
- * >
- * > forLoopParts ::=
- * >     forInitializerStatement ';' [Expression]? ';' [Expression]?
- * >
- * > forInitializerStatement ::=
- * >     [DefaultFormalParameter]
- * >   | [Expression]?
+ *    forStatement ::=
+ *        'for' '(' forLoopParts ')' [Statement]
+ *
+ *    forLoopParts ::=
+ *        forInitializerStatement ';' [Expression]? ';' [Expression]?
+ *
+ *    forInitializerStatement ::=
+ *        [DefaultFormalParameter]
+ *      | [Expression]?
  *
  * Clients may not extend, implement or mix-in this class.
  */
 abstract class ForStatement extends Statement {
   /**
    * Initialize a newly created for statement. Either the [variableList] or the
    * [initialization] must be `null`. Either the [condition] and the list of
    * [updaters] can be `null` if the loop does not have the corresponding
    * attribute.
    */
@@ skipping 107 matching lines @@
 
   /**
    * Set the declaration of the loop variables to the given [variableList].
    */
   void set variables(VariableDeclarationList variableList);
 }
 
 /**
  * A node representing the body of a function or method.
  *
- * > functionBody ::=
- * >     [BlockFunctionBody]
- * >   | [EmptyFunctionBody]
- * >   | [ExpressionFunctionBody]
+ *    functionBody ::=
+ *        [BlockFunctionBody]
+ *      | [EmptyFunctionBody]
+ *      | [ExpressionFunctionBody]
  *
  * Clients may not extend, implement or mix-in this class.
  */
 abstract class FunctionBody extends AstNode {
   /**
    * Return `true` if this function body is asynchronous.
    */
   bool get isAsynchronous;
 
   /**
@@ skipping 41 matching lines @@
    * level function or method containing this [FunctionBody], return `false`.
    *
    * Throws an exception if resolution has not yet been performed.
    */
   bool isPotentiallyMutatedInScope(VariableElement variable);
 }
 
 /**
  * A top-level declaration.
  *
- * > functionDeclaration ::=
- * >     'external' functionSignature
- * >   | functionSignature [FunctionBody]
- * >
- * > functionSignature ::=
- * >     [Type]? ('get' | 'set')? [SimpleIdentifier] [FormalParameterList]
+ *    functionDeclaration ::=
+ *        'external' functionSignature
+ *      | functionSignature [FunctionBody]
+ *
+ *    functionSignature ::=
+ *        [Type]? ('get' | 'set')? [SimpleIdentifier] [FormalParameterList]
  *
  * Clients may not extend, implement or mix-in this class.
  */
 abstract class FunctionDeclaration extends NamedCompilationUnitMember {
   /**
    * Initialize a newly created function declaration. Either or both of the
    * [comment] and [metadata] can be `null` if the function does not have the
    * corresponding attribute. The [externalKeyword] can be `null` if the
    * function is not an external function. The [returnType] can be `null` if no
    * return type was specified. The [propertyKeyword] can be `null` if the
@@ skipping 87 matching lines @@
   /**
    * Set the function declaration being wrapped to the given
    * [functionDeclaration].
    */
   void set functionDeclaration(FunctionDeclaration functionDeclaration);
 }
 
 /**
  * A function expression.
  *
- * > functionExpression ::=
- * >     [TypeParameterList]? [FormalParameterList] [FunctionBody]
+ *    functionExpression ::=
+ *        [TypeParameterList]? [FormalParameterList] [FunctionBody]
  *
  * Clients may not extend, implement or mix-in this class.
  */
 abstract class FunctionExpression extends Expression {
   /**
    * Initialize a newly created function declaration.
    */
   factory FunctionExpression(
       TypeParameterList typeParameters,
       FormalParameterList parameters,
@@ skipping 43 matching lines @@
    */
   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]
+ *    functionExpressionInvocation ::=
+ *        [Expression] [TypeArgumentList]? [ArgumentList]
  *
  * Clients may not extend, implement or mix-in this class.
  */
 abstract class FunctionExpressionInvocation extends InvocationExpression {
   /**
    * Initialize a newly created function expression invocation.
    */
   factory FunctionExpressionInvocation(
       Expression function,
       TypeArgumentList typeArguments,
@@ skipping 87 matching lines @@
   /**
    * 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 ::=
- * >     [TypeName]? [SimpleIdentifier]
+ *    functionTypeAlias ::=
+ *        functionPrefix [TypeParameterList]? [FormalParameterList] ';'
+ *
+ *    functionPrefix ::=
+ *        [TypeName]? [SimpleIdentifier]
  *
  * Clients may not extend, implement or mix-in this class.
  */
 abstract class FunctionTypeAlias extends TypeAlias {
   /**
    * Initialize a newly created function type alias. Either or both of the
    * [comment] and [metadata] can be `null` if the function does not have the
    * corresponding attribute. The [returnType] can be `null` if no return type
    * was specified. The [typeParameters] can be `null` if the function has no
    * type parameters.
@@ skipping 40 matching lines @@
   /**
    * 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 ::=
- * >     [TypeName]? [SimpleIdentifier] [TypeParameterList]? [FormalParameterList]
+ *    functionSignature ::=
+ *        [TypeName]? [SimpleIdentifier] [TypeParameterList]? [FormalParameterList]
  *
  * Clients may not extend, implement or mix-in this class.
  */
 abstract class FunctionTypedFormalParameter extends NormalFormalParameter {
   /**
    * Initialize a newly created formal parameter. Either or both of the
    * [comment] and [metadata] can be `null` if the parameter does not have the
    * corresponding attribute. The [returnType] can be `null` if no return type
    * was specified.
    */
@@ skipping 37 matching lines @@
    * Set the type parameters associated with this method to the given
    * [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])*
+ *    hideCombinator ::=
+ *        'hide' [SimpleIdentifier] (',' [SimpleIdentifier])*
  *
  * Clients may not extend, implement or mix-in this class.
  */
 abstract class HideCombinator extends Combinator {
   /**
    * Initialize a newly created import show combinator.
    */
   factory HideCombinator(Token keyword, List<SimpleIdentifier> hiddenNames) =
       HideCombinatorImpl;
 
   /**
    * 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]
+ *    identifier ::=
+ *        [SimpleIdentifier]
+ *      | [PrefixedIdentifier]
  *
  * Clients may not extend, implement or mix-in this class.
  */
 abstract class Identifier extends 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.
@@ skipping 25 matching lines @@
    * 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); // '_'
 }
 
 /**
  * An if statement.
  *
- * > ifStatement ::=
- * >     'if' '(' [Expression] ')' [Statement] ('else' [Statement])?
+ *    ifStatement ::=
+ *        'if' '(' [Expression] ')' [Statement] ('else' [Statement])?
  *
  * Clients may not extend, implement or mix-in this class.
  */
 abstract class IfStatement extends Statement {
   /**
    * Initialize a newly created if statement. The [elseKeyword] and
    * [elseStatement] can be `null` if there is no else clause.
    */
   factory IfStatement(
       Token ifKeyword,
@@ skipping 77 matching lines @@
   /**
    * 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])*
+ *    implementsClause ::=
+ *        'implements' [TypeName] (',' [TypeName])*
  *
  * Clients may not extend, implement or mix-in this class.
  */
 abstract class ImplementsClause extends AstNode {
   /**
    * Initialize a newly created implements clause.
    */
   factory ImplementsClause(Token implementsKeyword, List<TypeName> interfaces) =
       ImplementsClauseImpl;
 
   /**
    * Return the token representing the 'implements' keyword.
    */
   Token get implementsKeyword;
 
   /**
    * 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.
    */
   NodeList<TypeName> get interfaces;
 }
 
 /**
  * An import directive.
  *
- * > importDirective ::=
- * >     [Annotation] 'import' [StringLiteral] ('as' identifier)? [Combinator]* ';'
- * >   | [Annotation] 'import' [StringLiteral] 'deferred' 'as' identifier [Combinator]* ';'
+ *    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 extends NamespaceDirective {
   static Comparator<ImportDirective> COMPARATOR =
       (ImportDirective import1, ImportDirective import2) {
     //
     // uri
     //
     StringLiteral uri1 = import1.uri;
@@ skipping 135 matching lines @@
 
   /**
    * Set the prefix to be used with the imported names to the given [identifier].
    */
   void set prefix(SimpleIdentifier identifier);
 }
 
 /**
  * An index expression.
  *
- * > indexExpression ::=
- * >     [Expression] '[' [Expression] ']'
+ *    indexExpression ::=
+ *        [Expression] '[' [Expression] ']'
  *
  * Clients may not extend, implement or mix-in this class.
  */
 abstract class IndexExpression extends Expression {
   /**
    * Initialize a newly created index expression.
    */
   factory IndexExpression.forCascade(Token period, Token leftBracket,
       Expression index, Token rightBracket) = IndexExpressionImpl.forCascade;
 
@@ skipping 142 matching lines @@
    * are they mutually exclusive. In other words, it is possible for both
    * methods to return `true` when invoked on the same node.
    */
   // TODO(brianwilkerson) Convert this to a getter.
   bool inSetterContext();
 }
 
 /**
  * An instance creation expression.
  *
- * > newExpression ::=
- * >     ('new' | 'const') [TypeName] ('.' [SimpleIdentifier])? [ArgumentList]
+ *    newExpression ::=
+ *        ('new' | 'const') [TypeName] ('.' [SimpleIdentifier])? [ArgumentList]
  *
  * Clients may not extend, implement or mix-in this class.
  */
 abstract class InstanceCreationExpression extends Expression {
   /**
    * Initialize a newly created instance creation expression.
    */
   factory InstanceCreationExpression(
       Token keyword,
       ConstructorName constructorName,
@@ skipping 47 matching lines @@
   /**
    * Set the element associated with the constructor based on static type
    * information to the given [element].
    */
   void set staticElement(ConstructorElement element);
 }
 
 /**
  * An integer literal expression.
  *
- * > integerLiteral ::=
- * >     decimalIntegerLiteral
- * >   | hexadecimalIntegerLiteral
- * >
- * > decimalIntegerLiteral ::=
- * >     decimalDigit+
- * >
- * > hexadecimalIntegerLiteral ::=
- * >     '0x' hexadecimalDigit+
- * >   | '0X' hexadecimalDigit+
+ *    integerLiteral ::=
+ *        decimalIntegerLiteral
+ *      | hexadecimalIntegerLiteral
+ *
+ *    decimalIntegerLiteral ::=
+ *        decimalDigit+
+ *
+ *    hexadecimalIntegerLiteral ::=
+ *        '0x' hexadecimalDigit+
+ *      | '0X' hexadecimalDigit+
  *
  * Clients may not extend, implement or mix-in this class.
  */
 abstract class IntegerLiteral extends Literal {
   /**
    * Initialize a newly created integer literal.
    */
   factory IntegerLiteral(Token literal, int value) = IntegerLiteralImpl;
 
   /**
@@ skipping 13 matching lines @@
 
   /**
    * Set the value of the literal to the given [value].
    */
   void set value(int value);
 }
 
 /**
  * A node within a [StringInterpolation].
  *
- * > interpolationElement ::=
- * >     [InterpolationExpression]
- * >   | [InterpolationString]
+ *    interpolationElement ::=
+ *        [InterpolationExpression]
+ *      | [InterpolationString]
  *
  * Clients may not extend, implement or mix-in this class.
  */
 abstract class InterpolationElement extends AstNode {}
 
 /**
  * An expression embedded in a string interpolation.
  *
- * > interpolationExpression ::=
- * >     '$' [SimpleIdentifier]
- * >   | '$' '{' [Expression] '}'
+ *    interpolationExpression ::=
+ *        '$' [SimpleIdentifier]
+ *      | '$' '{' [Expression] '}'
  *
  * Clients may not extend, implement or mix-in this class.
  */
 abstract class InterpolationExpression extends InterpolationElement {
   /**
    * Initialize a newly created interpolation expression.
    */
   factory InterpolationExpression(
           Token leftBracket, Expression expression, Token rightBracket) =
       InterpolationExpressionImpl;
@@ skipping 32 matching lines @@
 
   /**
    * Set the right curly bracket to the given [token].
    */
   void set rightBracket(Token token);
 }
 
 /**
  * A non-empty substring of an interpolated string.
  *
- * > interpolationString ::=
- * >     characters
+ *    interpolationString ::=
+ *        characters
  *
  * Clients may not extend, implement or mix-in this class.
  */
 abstract class InterpolationString extends InterpolationElement {
   /**
    * Initialize a newly created string of characters that are part of a string
    * interpolation.
    */
   factory InterpolationString(Token contents, String value) =
       InterpolationStringImpl;
@@ skipping 92 matching lines @@
   /**
    * Return the type arguments to be applied to the method being invoked, or
    * `null` if no type arguments were provided.
    */
   TypeArgumentList get typeArguments;
 }
 
 /**
  * An is expression.
  *
- * > isExpression ::=
- * >     [Expression] 'is' '!'? [TypeName]
+ *    isExpression ::=
+ *        [Expression] 'is' '!'? [TypeName]
  *
  * Clients may not extend, implement or mix-in this class.
  */
 abstract class IsExpression extends Expression {
   /**
    * Initialize a newly created is expression. The [notOperator] can be `null`
    * if the sense of the test is not negated.
    */
   factory IsExpression(Expression expression, Token isOperator,
       Token notOperator, TypeName type) = IsExpressionImpl;
@@ skipping 36 matching lines @@
 
   /**
    * Set the name of the type being tested for to the given [name].
    */
   void set type(TypeName name);
 }
 
 /**
  * A label on either a [LabeledStatement] or a [NamedExpression].
  *
- * > label ::=
- * >     [SimpleIdentifier] ':'
+ *    label ::=
+ *        [SimpleIdentifier] ':'
  *
  * Clients may not extend, implement or mix-in this class.
  */
 abstract class Label extends AstNode {
   /**
    * Initialize a newly created label.
    */
   factory Label(SimpleIdentifier label, Token colon) = LabelImpl;
 
   /**
@@ skipping 14 matching lines @@
 
   /**
    * Set the label being associated with the statement to the given [label].
    */
   void set label(SimpleIdentifier label);
 }
 
 /**
  * A statement that has a label associated with them.
  *
- * > labeledStatement ::=
- * >    [Label]+ [Statement]
+ *    labeledStatement ::=
+ *       [Label]+ [Statement]
  *
  * Clients may not extend, implement or mix-in this class.
  */
 abstract class LabeledStatement extends Statement {
   /**
    * Initialize a newly created labeled statement.
    */
   factory LabeledStatement(List<Label> labels, Statement statement) =
       LabeledStatementImpl;
 
@@ skipping 10 matching lines @@
   /**
    * Set the statement with which the labels are being associated to the given
    * [statement].
    */
   void set statement(Statement statement);
 }
 
 /**
  * A library directive.
  *
- * > libraryDirective ::=
- * >     [Annotation] 'library' [Identifier] ';'
+ *    libraryDirective ::=
+ *        [Annotation] 'library' [Identifier] ';'
  *
  * Clients may not extend, implement or mix-in this class.
  */
 abstract class LibraryDirective extends Directive {
   /**
    * Initialize a newly created library directive. Either or both of the
    * [comment] and [metadata] can be `null` if the directive does not have the
    * corresponding attribute.
    */
   factory LibraryDirective(
@@ skipping 30 matching lines @@
 
   /**
    * Set the semicolon terminating the directive to the given [token].
    */
   void set semicolon(Token token);
 }
 
 /**
  * The identifier for a library.
  *
- * > libraryIdentifier ::=
- * >     [SimpleIdentifier] ('.' [SimpleIdentifier])*
+ *    libraryIdentifier ::=
+ *        [SimpleIdentifier] ('.' [SimpleIdentifier])*
  *
  * Clients may not extend, implement or mix-in this class.
  */
 abstract class LibraryIdentifier extends Identifier {
   /**
    * Initialize a newly created prefixed identifier.
    */
   factory LibraryIdentifier(List<SimpleIdentifier> components) =
       LibraryIdentifierImpl;
 
   /**
    * Return the components of the identifier.
    */
   NodeList<SimpleIdentifier> get components;
 }
 
 /**
  * A list literal.
  *
- * > listLiteral ::=
- * >     'const'? ('<' [TypeName] '>')? '[' ([Expression] ','?)? ']'
+ *    listLiteral ::=
+ *        'const'? ('<' [TypeName] '>')? '[' ([Expression] ','?)? ']'
  *
  * Clients may not extend, implement or mix-in this class.
  */
 abstract class ListLiteral extends TypedLiteral {
   /**
    * Initialize a newly created list literal. The [constKeyword] can be `null`
    * if the literal is not a constant. The [typeArguments] can be `null` if no
    * type arguments were declared. The list of [elements] can be `null` if the
    * list is empty.
    */
@@ skipping 26 matching lines @@
 
   /**
    * Set the right square bracket to the given [token].
    */
   void set rightBracket(Token token);
 }
 
 /**
  * A node that represents a literal expression.
  *
- * > literal ::=
- * >     [BooleanLiteral]
- * >   | [DoubleLiteral]
- * >   | [IntegerLiteral]
- * >   | [ListLiteral]
- * >   | [MapLiteral]
- * >   | [NullLiteral]
- * >   | [StringLiteral]
+ *    literal ::=
+ *        [BooleanLiteral]
+ *      | [DoubleLiteral]
+ *      | [IntegerLiteral]
+ *      | [ListLiteral]
+ *      | [MapLiteral]
+ *      | [NullLiteral]
+ *      | [StringLiteral]
  *
  * Clients may not extend, implement or mix-in this class.
  */
 abstract class Literal extends Expression {}
 
 /**
  * A literal map.
  *
- * > mapLiteral ::=
- * >     'const'? ('<' [TypeName] (',' [TypeName])* '>')?
- * >     '{' ([MapLiteralEntry] (',' [MapLiteralEntry])* ','?)? '}'
+ *    mapLiteral ::=
+ *        'const'? ('<' [TypeName] (',' [TypeName])* '>')?
+ *        '{' ([MapLiteralEntry] (',' [MapLiteralEntry])* ','?)? '}'
  *
  * Clients may not extend, implement or mix-in this class.
  */
 abstract class MapLiteral extends TypedLiteral {
   /**
    * Initialize a newly created map literal. The [constKeyword] can be `null` if
    * the literal is not a constant. The [typeArguments] can be `null` if no type
    * arguments were declared. The [entries] can be `null` if the map is empty.
    */
   factory MapLiteral(
@@ skipping 25 matching lines @@
 
   /**
    * Set the right curly bracket to the given [token].
    */
   void set rightBracket(Token token);
 }
 
 /**
  * A single key/value pair in a map literal.
  *
- * > mapLiteralEntry ::=
- * >     [Expression] ':' [Expression]
+ *    mapLiteralEntry ::=
+ *        [Expression] ':' [Expression]
  *
  * Clients may not extend, implement or mix-in this class.
  */
 abstract class MapLiteralEntry extends AstNode {
   /**
    * Initialize a newly created map literal entry.
    */
   factory MapLiteralEntry(Expression key, Token separator, Expression value) =
       MapLiteralEntryImpl;
 
@@ skipping 28 matching lines @@
   /**
    * Set the expression computing the value that will be associated with the key
    * to the given [expression].
    */
   void set value(Expression expression);
 }
 
 /**
  * A method declaration.
  *
- * > methodDeclaration ::=
- * >     methodSignature [FunctionBody]
- * >
- * > methodSignature ::=
- * >     'external'? ('abstract' | 'static')? [Type]? ('get' | 'set')?
- * >     methodName [TypeParameterList] [FormalParameterList]
- * >
- * > methodName ::=
- * >     [SimpleIdentifier]
- * >   | 'operator' [SimpleIdentifier]
+ *    methodDeclaration ::=
+ *        methodSignature [FunctionBody]
+ *
+ *    methodSignature ::=
+ *        'external'? ('abstract' | 'static')? [Type]? ('get' | 'set')?
+ *        methodName [TypeParameterList] [FormalParameterList]
+ *
+ *    methodName ::=
+ *        [SimpleIdentifier]
+ *      | 'operator' [SimpleIdentifier]
  *
  * Clients may not extend, implement or mix-in this class.
  */
 abstract class MethodDeclaration extends ClassMember {
   /**
    * Initialize a newly created method declaration. Either or both of the
    * [comment] and [metadata] can be `null` if the declaration does not have the
    * corresponding attribute. The [externalKeyword] can be `null` if the method
    * is not external. The [modifierKeyword] can be `null` if the method is
    * neither abstract nor static. The [returnType] can be `null` if no return
@@ skipping 143 matching lines @@
    */
   void set typeParameters(TypeParameterList typeParameters);
 }
 
 /**
  * The invocation of either a function or a method. Invocations of functions
  * resulting from evaluating an expression are represented by
  * [FunctionExpressionInvocation] nodes. Invocations of getters and setters are
  * represented by either [PrefixedIdentifier] or [PropertyAccess] nodes.
  *
- * > methodInvocation ::=
- * >     ([Expression] '.')? [SimpleIdentifier] [TypeArgumentList]? [ArgumentList]
+ *    methodInvocation ::=
+ *        ([Expression] '.')? [SimpleIdentifier] [TypeArgumentList]? [ArgumentList]
  *
  * Clients may not extend, implement or mix-in this class.
  */
 abstract class MethodInvocation extends InvocationExpression {
   /**
    * Initialize a newly created method invocation. The [target] and [operator]
    * can be `null` if there is no target.
    */
   factory MethodInvocation(
       Expression target,
@@ skipping 117 matching lines @@
   /**
    * Set the name of the member being declared to the given [identifier].
    */
   void set name(SimpleIdentifier identifier);
 }
 
 /**
  * An expression that has a name associated with it. They are used in method
  * invocations when there are named parameters.
  *
- * > namedExpression ::=
- * >     [Label] [Expression]
+ *    namedExpression ::=
+ *        [Label] [Expression]
  *
  * Clients may not extend, implement or mix-in this class.
  */
 abstract class NamedExpression extends Expression {
   /**
    * Initialize a newly created named expression..
    */
   factory NamedExpression(Label name, Expression expression) =
       NamedExpressionImpl;
 
@@ skipping 22 matching lines @@
 
   /**
    * Set the name associated with the expression to the given [identifier].
    */
   void set name(Label identifier);
 }
 
 /**
  * A node that represents a directive that impacts the namespace of a library.
  *
- * > directive ::=
- * >     [ExportDirective]
- * >   | [ImportDirective]
+ *    directive ::=
+ *        [ExportDirective]
+ *      | [ImportDirective]
  *
  * Clients may not extend, implement or mix-in this class.
  */
 abstract class NamespaceDirective extends UriBasedDirective {
   /**
    * Return the combinators used to control how names are imported or exported.
    */
   NodeList<Combinator> get combinators;
 
   /**
@@ skipping 15 matching lines @@
 
   /**
    * Set the semicolon terminating the directive to the given [token].
    */
   void set semicolon(Token token);
 }
 
 /**
  * The "native" clause in an class declaration.
  *
- * > nativeClause ::=
- * >     'native' [StringLiteral]
+ *    nativeClause ::=
+ *        'native' [StringLiteral]
  *
  * Clients may not extend, implement or mix-in this class.
  */
 abstract class NativeClause extends AstNode {
   /**
    * Initialize a newly created native clause.
    */
   factory NativeClause(Token nativeKeyword, StringLiteral name) =
       NativeClauseImpl;
 
@@ skipping 16 matching lines @@
   /**
    * Set the token representing the 'native' keyword to the given [token].
    */
   void set nativeKeyword(Token token);
 }
 
 /**
  * A function body that consists of a native keyword followed by a string
  * literal.
  *
- * > nativeFunctionBody ::=
- * >     'native' [SimpleStringLiteral] ';'
+ *    nativeFunctionBody ::=
+ *        'native' [SimpleStringLiteral] ';'
  *
  * Clients may not extend, implement or mix-in this class.
  */
 abstract class NativeFunctionBody extends FunctionBody {
   /**
    * Initialize a newly created function body consisting of the 'native' token,
    * a string literal, and a semicolon.
    */
   factory NativeFunctionBody(
           Token nativeKeyword, StringLiteral stringLiteral, Token semicolon) =
@@ skipping 86 matching lines @@
 
   /**
    * Use the given [visitor] to visit each of the nodes in this list.
    */
   accept(AstVisitor visitor);
 }
 
 /**
  * A formal parameter that is required (is not optional).
  *
- * > normalFormalParameter ::=
- * >     [FunctionTypedFormalParameter]
- * >   | [FieldFormalParameter]
- * >   | [SimpleFormalParameter]
+ *    normalFormalParameter ::=
+ *        [FunctionTypedFormalParameter]
+ *      | [FieldFormalParameter]
+ *      | [SimpleFormalParameter]
  *
  * Clients may not extend, implement or mix-in this class.
  */
 abstract class NormalFormalParameter extends FormalParameter {
   /**
    * Return the documentation comment associated with this parameter, or `null`
    * if this parameter does not have a documentation comment associated with it.
    */
   Comment get documentationComment;
 
@@ skipping 16 matching lines @@
   /**
    * Return a list containing the comment and annotations associated with this
    * parameter, sorted in lexical order.
    */
   List<AstNode> get sortedCommentAndAnnotations;
 }
 
 /**
  * A null literal expression.
  *
- * > nullLiteral ::=
- * >     'null'
+ *    nullLiteral ::=
+ *        'null'
  *
  * Clients may not extend, implement or mix-in this class.
  */
 abstract class NullLiteral extends Literal {
   /**
    * Initialize a newly created null literal.
    */
   factory NullLiteral(Token literal) = NullLiteralImpl;
 
   /**
    * Return the token representing the literal.
    */
   Token get literal;
 
   /**
    * Set the token representing the literal to the given [token].
    */
   void set literal(Token token);
 }
 
 /**
  * A parenthesized expression.
  *
- * > parenthesizedExpression ::=
- * >     '(' [Expression] ')'
+ *    parenthesizedExpression ::=
+ *        '(' [Expression] ')'
  *
  * Clients may not extend, implement or mix-in this class.
  */
 abstract class ParenthesizedExpression extends Expression {
   /**
    * Initialize a newly created parenthesized expression.
    */
   factory ParenthesizedExpression(Token leftParenthesis, Expression expression,
       Token rightParenthesis) = ParenthesizedExpressionImpl;
 
@@ skipping 24 matching lines @@
 
   /**
    * Set the right parenthesis to the given [token].
    */
   void set rightParenthesis(Token token);
 }
 
 /**
  * A part directive.
  *
- * > partDirective ::=
- * >     [Annotation] 'part' [StringLiteral] ';'
+ *    partDirective ::=
+ *        [Annotation] 'part' [StringLiteral] ';'
  *
  * Clients may not extend, implement or mix-in this class.
  */
 abstract class PartDirective extends UriBasedDirective {
   /**
    * Initialize a newly created part directive. Either or both of the [comment]
    * and [metadata] can be `null` if the directive does not have the
    * corresponding attribute.
    */
   factory PartDirective(
@@ skipping 20 matching lines @@
 
   /**
    * Set the semicolon terminating the directive to the given [token].
    */
   void set semicolon(Token token);
 }
 
 /**
  * A part-of directive.
  *
- * > partOfDirective ::=
- * >     [Annotation] 'part' 'of' [Identifier] ';'
+ *    partOfDirective ::=
+ *        [Annotation] 'part' 'of' [Identifier] ';'
  *
  * Clients may not extend, implement or mix-in this class.
  */
 abstract class PartOfDirective extends Directive {
   /**
    * Initialize a newly created part-of directive. Either or both of the
    * [comment] and [metadata] can be `null` if the directive does not have the
    * corresponding attribute.
    */
   factory PartOfDirective(
@@ skipping 43 matching lines @@
 
   /**
    * Set the semicolon terminating the directive to the given [token].
    */
   void set semicolon(Token token);
 }
 
 /**
  * A postfix unary expression.
  *
- * > postfixExpression ::=
- * >     [Expression] [Token]
+ *    postfixExpression ::=
+ *        [Expression] [Token]
  *
  * Clients may not extend, implement or mix-in this class.
  */
 abstract class PostfixExpression extends Expression {
   /**
    * Initialize a newly created postfix expression.
    */
   factory PostfixExpression(Expression operand, Token operator) =
       PostfixExpressionImpl;
 
@@ skipping 52 matching lines @@
    * Set the element associated with the operator based on the static type of
    * the operand to the given [element].
    */
   void set staticElement(MethodElement element);
 }
 
 /**
  * An identifier that is prefixed or an access to an object property where the
  * target of the property access is a simple identifier.
  *
- * > prefixedIdentifier ::=
- * >     [SimpleIdentifier] '.' [SimpleIdentifier]
+ *    prefixedIdentifier ::=
+ *        [SimpleIdentifier] '.' [SimpleIdentifier]
  *
  * Clients may not extend, implement or mix-in this class.
  */
 abstract class PrefixedIdentifier extends Identifier {
   /**
    * Initialize a newly created prefixed identifier.
    */
   factory PrefixedIdentifier(
           SimpleIdentifier prefix, Token period, SimpleIdentifier identifier) =
       PrefixedIdentifierImpl;
@@ skipping 37 matching lines @@
   /**
    * Set the prefix associated with the library in which the identifier is
    * defined to the given [identifier].
    */
   void set prefix(SimpleIdentifier identifier);
 }
 
 /**
  * A prefix unary expression.
  *
- * > prefixExpression ::=
- * >     [Token] [Expression]
+ *    prefixExpression ::=
+ *        [Token] [Expression]
  *
  * Clients may not extend, implement or mix-in this class.
  */
 abstract class PrefixExpression extends Expression {
   /**
    * Initialize a newly created prefix expression.
    */
   factory PrefixExpression(Token operator, Expression operand) =
       PrefixExpressionImpl;
 
@@ skipping 55 matching lines @@
   void set staticElement(MethodElement element);
 }
 
 /**
  * The access of a property of an object.
  *
  * Note, however, that accesses to properties of objects can also be represented
  * as [PrefixedIdentifier] nodes in cases where the target is also a simple
  * identifier.
  *
- * > propertyAccess ::=
- * >     [Expression] '.' [SimpleIdentifier]
+ *    propertyAccess ::=
+ *        [Expression] '.' [SimpleIdentifier]
  *
  * Clients may not extend, implement or mix-in this class.
  */
 abstract class PropertyAccess extends Expression {
   /**
    * Initialize a newly created property access expression.
    */
   factory PropertyAccess(
           Expression target, Token operator, SimpleIdentifier propertyName) =
       PropertyAccessImpl;
@@ skipping 46 matching lines @@
    * Set the expression computing the object defining the property being
    * accessed to the given [expression].
    */
   void set target(Expression expression);
 }
 
 /**
  * The invocation of a constructor in the same class from within a constructor's
  * initialization list.
  *
- * > redirectingConstructorInvocation ::=
- * >     'this' ('.' identifier)? arguments
+ *    redirectingConstructorInvocation ::=
+ *        'this' ('.' identifier)? arguments
  *
  * Clients may not extend, implement or mix-in this class.
  */
 abstract class RedirectingConstructorInvocation extends ConstructorInitializer {
   /**
    * Initialize a newly created redirecting invocation to invoke the constructor
    * with the given name with the given arguments. The [constructorName] can be
    * `null` if the constructor being invoked is the unnamed constructor.
    */
   factory RedirectingConstructorInvocation(
@@ skipping 56 matching lines @@
 
   /**
    * Set the token for the 'this' keyword to the given [token].
    */
   void set thisKeyword(Token token);
 }
 
 /**
  * A rethrow expression.
  *
- * > rethrowExpression ::=
- * >     'rethrow'
+ *    rethrowExpression ::=
+ *        'rethrow'
  *
  * Clients may not extend, implement or mix-in this class.
  */
 abstract class RethrowExpression extends Expression {
   /**
    * Initialize a newly created rethrow expression.
    */
   factory RethrowExpression(Token rethrowKeyword) = RethrowExpressionImpl;
 
   /**
    * Return the token representing the 'rethrow' keyword.
    */
   Token get rethrowKeyword;
 
   /**
    * Set the token representing the 'rethrow' keyword to the given [token].
    */
   void set rethrowKeyword(Token token);
 }
 
 /**
  * A return statement.
  *
- * > returnStatement ::=
- * >     'return' [Expression]? ';'
+ *    returnStatement ::=
+ *        'return' [Expression]? ';'
  *
  * Clients may not extend, implement or mix-in this class.
  */
 abstract class ReturnStatement extends Statement {
   /**
    * Initialize a newly created return statement. The [expression] can be `null`
    * if no explicit value was provided.
    */
   factory ReturnStatement(
           Token returnKeyword, Expression expression, Token semicolon) =
@@ skipping 28 matching lines @@
 
   /**
    * Set the semicolon terminating the statement to the given [token].
    */
   void set semicolon(Token token);
 }
 
 /**
  * A script tag that can optionally occur at the beginning of a compilation unit.
  *
- * > scriptTag ::=
- * >     '#!' (~NEWLINE)* NEWLINE
+ *    scriptTag ::=
+ *        '#!' (~NEWLINE)* NEWLINE
  *
  * Clients may not extend, implement or mix-in this class.
  */
 abstract class ScriptTag extends AstNode {
   /**
    * Initialize a newly created script tag.
    */
   factory ScriptTag(Token scriptTag) = ScriptTagImpl;
 
   /**
    * Return the token representing this script tag.
    */
   Token get scriptTag;
 
   /**
    * Set the token representing this script tag to the given [token].
    */
   void set scriptTag(Token token);
 }
 
 /**
  * A combinator that restricts the names being imported to those in a given list.
  *
- * > showCombinator ::=
- * >     'show' [SimpleIdentifier] (',' [SimpleIdentifier])*
+ *    showCombinator ::=
+ *        'show' [SimpleIdentifier] (',' [SimpleIdentifier])*
  *
  * Clients may not extend, implement or mix-in this class.
  */
 abstract class ShowCombinator extends Combinator {
   /**
    * Initialize a newly created import show combinator.
    */
   factory ShowCombinator(Token keyword, List<SimpleIdentifier> shownNames) =
       ShowCombinatorImpl;
 
   /**
    * Return the list of names from the library that are made visible by this
    * combinator.
    */
   NodeList<SimpleIdentifier> get shownNames;
 }
 
 /**
  * A simple formal parameter.
  *
- * > simpleFormalParameter ::=
- * >     ('final' [TypeName] | 'var' | [TypeName])? [SimpleIdentifier]
+ *    simpleFormalParameter ::=
+ *        ('final' [TypeName] | 'var' | [TypeName])? [SimpleIdentifier]
  *
  * Clients may not extend, implement or mix-in this class.
  */
 abstract class SimpleFormalParameter extends NormalFormalParameter {
   /**
    * Initialize a newly created formal parameter. Either or both of the
    * [comment] and [metadata] can be `null` if the parameter does not have the
    * corresponding attribute. The [keyword] can be `null` if a type was
    * specified. The [type] must be `null` if the keyword is 'var'.
    */
@@ skipping 24 matching lines @@
 
   /**
    * Set the name of the declared type of the parameter to the given [typeName].
    */
   void set type(TypeName typeName);
 }
 
 /**
  * A simple identifier.
  *
- * > simpleIdentifier ::=
- * >     initialCharacter internalCharacter*
- * >
- * > initialCharacter ::= '_' | '$' | letter
- * >
- * > internalCharacter ::= '_' | '$' | letter | digit
+ *    simpleIdentifier ::=
+ *        initialCharacter internalCharacter*
+ *
+ *    initialCharacter ::= '_' | '$' | letter
+ *
+ *    internalCharacter ::= '_' | '$' | letter | digit
  *
  * Clients may not extend, implement or mix-in this class.
  */
 abstract class SimpleIdentifier extends Identifier {
   /**
    * Initialize a newly created identifier.
    */
   factory SimpleIdentifier(Token token) = SimpleIdentifierImpl;
 
   /**
@@ skipping 64 matching lines @@
    * are they mutually exclusive. In other words, it is possible for both
    * methods to return `true` when invoked on the same node.
    */
   // TODO(brianwilkerson) Convert this to a getter.
   bool inSetterContext();
 }
 
 /**
  * A string literal expression that does not contain any interpolations.
  *
- * > simpleStringLiteral ::=
- * >     rawStringLiteral
- * >   | basicStringLiteral
- * >
- * > rawStringLiteral ::=
- * >     'r' basicStringLiteral
- * >
- * > simpleStringLiteral ::=
- * >     multiLineStringLiteral
- * >   | singleLineStringLiteral
- * >
- * > multiLineStringLiteral ::=
- * >     "'''" characters "'''"
- * >   | '"""' characters '"""'
- * >
- * > singleLineStringLiteral ::=
- * >     "'" characters "'"
- * >   | '"' characters '"'
+ *    simpleStringLiteral ::=
+ *        rawStringLiteral
+ *      | basicStringLiteral
+ *
+ *    rawStringLiteral ::=
+ *        'r' basicStringLiteral
+ *
+ *    simpleStringLiteral ::=
+ *        multiLineStringLiteral
+ *      | singleLineStringLiteral
+ *
+ *    multiLineStringLiteral ::=
+ *        "'''" characters "'''"
+ *      | '"""' characters '"""'
+ *
+ *    singleLineStringLiteral ::=
+ *        "'" characters "'"
+ *      | '"' characters '"'
  *
  * Clients may not extend, implement or mix-in this class.
  */
 abstract class SimpleStringLiteral extends SingleStringLiteral {
   /**
    * Initialize a newly created simple string literal.
    */
   factory SimpleStringLiteral(Token literal, String value) =
       SimpleStringLiteralImpl;
 
@@ skipping 14 matching lines @@
 
   /**
    * Set the value of the literal to the given [string].
    */
   void set value(String string);
 }
 
 /**
  * A single string literal expression.
  *
- * > singleStringLiteral ::=
- * >     [SimpleStringLiteral]
- * >   | [StringInterpolation]
+ *    singleStringLiteral ::=
+ *        [SimpleStringLiteral]
+ *      | [StringInterpolation]
  *
  * Clients may not extend, implement or mix-in this class.
  */
 abstract class SingleStringLiteral extends StringLiteral {
   /**
    * Return the offset of the after-last contents character.
    */
   int get contentsEnd;
 
   /**
@@ skipping 15 matching lines @@
   /**
    * Return `true` if this string literal uses single quotes (' or ''').
    * Return `false` if this string literal uses double quotes (" or """).
    */
   bool get isSingleQuoted;
 }
 
 /**
  * A node that represents a statement.
  *
- * > statement ::=
- * >     [Block]
- * >   | [VariableDeclarationStatement]
- * >   | [ForStatement]
- * >   | [ForEachStatement]
- * >   | [WhileStatement]
- * >   | [DoStatement]
- * >   | [SwitchStatement]
- * >   | [IfStatement]
- * >   | [TryStatement]
- * >   | [BreakStatement]
- * >   | [ContinueStatement]
- * >   | [ReturnStatement]
- * >   | [ExpressionStatement]
- * >   | [FunctionDeclarationStatement]
+ *    statement ::=
+ *        [Block]
+ *      | [VariableDeclarationStatement]
+ *      | [ForStatement]
+ *      | [ForEachStatement]
+ *      | [WhileStatement]
+ *      | [DoStatement]
+ *      | [SwitchStatement]
+ *      | [IfStatement]
+ *      | [TryStatement]
+ *      | [BreakStatement]
+ *      | [ContinueStatement]
+ *      | [ReturnStatement]
+ *      | [ExpressionStatement]
+ *      | [FunctionDeclarationStatement]
  *
  * Clients may not extend, implement or mix-in this class.
  */
 abstract class Statement extends AstNode {
   /**
    * If this is a labeled statement, return the unlabeled portion of the
    * statement, otherwise return the statement itself.
    */
   Statement get unlabeled;
 }
 
 /**
  * A string interpolation literal.
  *
- * > stringInterpolation ::=
- * >     ''' [InterpolationElement]* '''
- * >   | '"' [InterpolationElement]* '"'
+ *    stringInterpolation ::=
+ *        ''' [InterpolationElement]* '''
+ *      | '"' [InterpolationElement]* '"'
  *
  * Clients may not extend, implement or mix-in this class.
  */
 abstract class StringInterpolation extends SingleStringLiteral {
   /**
    * Initialize a newly created string interpolation expression.
    */
   factory StringInterpolation(List<InterpolationElement> elements) =
       StringInterpolationImpl;
 
   /**
    * Return the elements that will be composed to produce the resulting string.
    */
   NodeList<InterpolationElement> get elements;
 }
 
 /**
  * A string literal expression.
  *
- * > stringLiteral ::=
- * >     [SimpleStringLiteral]
- * >   | [AdjacentStrings]
- * >   | [StringInterpolation]
+ *    stringLiteral ::=
+ *        [SimpleStringLiteral]
+ *      | [AdjacentStrings]
+ *      | [StringInterpolation]
  *
  * Clients may not extend, implement or mix-in this class.
  */
 abstract class StringLiteral extends Literal {
   /**
    * Return the value of the string literal, or `null` if the string is not a
    * constant string without any string interpolation.
    */
   String get stringValue;
 }
 
 /**
  * The invocation of a superclass' constructor from within a constructor's
  * initialization list.
  *
- * > superInvocation ::=
- * >     'super' ('.' [SimpleIdentifier])? [ArgumentList]
+ *    superInvocation ::=
+ *        'super' ('.' [SimpleIdentifier])? [ArgumentList]
  *
  * Clients may not extend, implement or mix-in this class.
  */
 abstract class SuperConstructorInvocation extends ConstructorInitializer {
   /**
    * Initialize a newly created super invocation to invoke the inherited
    * constructor with the given name with the given arguments. The [period] and
    * [constructorName] can be `null` if the constructor being invoked is the
    * unnamed constructor.
    */
@@ skipping 57 matching lines @@
 
   /**
    * Set the token for the 'super' keyword to the given [token].
    */
   void set superKeyword(Token token);
 }
 
 /**
  * A super expression.
  *
- * > superExpression ::=
- * >     'super'
+ *    superExpression ::=
+ *        'super'
  *
  * Clients may not extend, implement or mix-in this class.
  */
 abstract class SuperExpression extends Expression {
   /**
    * Initialize a newly created super expression.
    */
   factory SuperExpression(Token superKeyword) = SuperExpressionImpl;
 
   /**
    * Return the token representing the 'super' keyword.
    */
   Token get superKeyword;
 
   /**
    * Set the token representing the 'super' keyword to the given [token].
    */
   void set superKeyword(Token token);
 }
 
 /**
  * A case in a switch statement.
  *
- * > switchCase ::=
- * >     [SimpleIdentifier]* 'case' [Expression] ':' [Statement]*
+ *    switchCase ::=
+ *        [SimpleIdentifier]* 'case' [Expression] ':' [Statement]*
  *
  * Clients may not extend, implement or mix-in this class.
  */
 abstract class SwitchCase extends SwitchMember {
   /**
    * Initialize a newly created switch case. The list of [labels] can be `null`
    * if there are no labels.
    */
   factory SwitchCase(List<Label> labels, Token keyword, Expression expression,
       Token colon, List<Statement> statements) = SwitchCaseImpl;
 
   /**
    * Return the expression controlling whether the statements will be executed.
    */
   Expression get expression;
 
   /**
    * Set the expression controlling whether the statements will be executed to
    * the given [expression].
    */
   void set expression(Expression expression);
 }
 
 /**
  * The default case in a switch statement.
  *
- * > switchDefault ::=
- * >     [SimpleIdentifier]* 'default' ':' [Statement]*
+ *    switchDefault ::=
+ *        [SimpleIdentifier]* 'default' ':' [Statement]*
  *
  * Clients may not extend, implement or mix-in this class.
  */
 abstract class SwitchDefault extends SwitchMember {
   /**
    * Initialize a newly created switch default. The list of [labels] can be
    * `null` if there are no labels.
    */
   factory SwitchDefault(List<Label> labels, Token keyword, Token colon,
       List<Statement> statements) = SwitchDefaultImpl;
 }
 
 /**
  * An element within a switch statement.
  *
- * > switchMember ::=
- * >     switchCase
- * >   | switchDefault
+ *    switchMember ::=
+ *        switchCase
+ *      | switchDefault
  *
  * Clients may not extend, implement or mix-in this class.
  */
 abstract class SwitchMember extends AstNode {
   /**
    * Return the colon separating the keyword or the expression from the
    * statements.
    */
   Token get colon;
 
@@ skipping 22 matching lines @@
   /**
    * Return the statements that will be executed if this switch member is
    * selected.
    */
   NodeList<Statement> get statements;
 }
 
 /**
  * A switch statement.
  *
- * > switchStatement ::=
- * >     'switch' '(' [Expression] ')' '{' [SwitchCase]* [SwitchDefault]? '}'
+ *    switchStatement ::=
+ *        'switch' '(' [Expression] ')' '{' [SwitchCase]* [SwitchDefault]? '}'
  *
  * Clients may not extend, implement or mix-in this class.
  */
 abstract class SwitchStatement extends Statement {
   /**
    * Initialize a newly created switch statement. The list of [members] can be
    * `null` if there are no switch members.
    */
   factory SwitchStatement(
       Token switchKeyword,
@@ skipping 68 matching lines @@
 
   /**
    * Set the token representing the 'switch' keyword to the given [token].
    */
   void set switchKeyword(Token token);
 }
 
 /**
  * A symbol literal expression.
  *
- * > symbolLiteral ::=
- * >     '#' (operator | (identifier ('.' identifier)*))
+ *    symbolLiteral ::=
+ *        '#' (operator | (identifier ('.' identifier)*))
  *
  * Clients may not extend, implement or mix-in this class.
  */
 abstract class SymbolLiteral extends Literal {
   /**
    * Initialize a newly created symbol literal.
    */
   factory SymbolLiteral(Token poundSign, List<Token> components) =
       SymbolLiteralImpl;
 
   /**
    * Return the components of the literal.
    */
   List<Token> get components;
 
   /**
    * Return the token introducing the literal.
    */
   Token get poundSign;
 
   /**
    * Set the token introducing the literal to the given [token].
    */
   void set poundSign(Token token);
 }
 
 /**
  * A this expression.
  *
- * > thisExpression ::=
- * >     'this'
+ *    thisExpression ::=
+ *        'this'
  *
  * Clients may not extend, implement or mix-in this class.
  */
 abstract class ThisExpression extends Expression {
   /**
    * Initialize a newly created this expression.
    */
   factory ThisExpression(Token thisKeyword) = ThisExpressionImpl;
 
   /**
    * Return the token representing the 'this' keyword.
    */
   Token get thisKeyword;
 
   /**
    * Set the token representing the 'this' keyword to the given [token].
    */
   void set thisKeyword(Token token);
 }
 
 /**
  * A throw expression.
  *
- * > throwExpression ::=
- * >     'throw' [Expression]
+ *    throwExpression ::=
+ *        'throw' [Expression]
  *
  * Clients may not extend, implement or mix-in this class.
  */
 abstract class ThrowExpression extends Expression {
   /**
    * Initialize a newly created throw expression.
    */
   factory ThrowExpression(Token throwKeyword, Expression expression) =
       ThrowExpressionImpl;
 
@@ skipping 15 matching lines @@
 
   /**
    * Set the token representing the 'throw' keyword to the given [token].
    */
   void set throwKeyword(Token token);
 }
 
 /**
  * The declaration of one or more top-level variables of the same type.
  *
- * > topLevelVariableDeclaration ::=
- * >     ('final' | 'const') type? staticFinalDeclarationList ';'
- * >   | variableDeclaration ';'
+ *    topLevelVariableDeclaration ::=
+ *        ('final' | 'const') type? staticFinalDeclarationList ';'
+ *      | variableDeclaration ';'
  *
  * Clients may not extend, implement or mix-in this class.
  */
 abstract class TopLevelVariableDeclaration extends CompilationUnitMember {
   /**
    * Initialize a newly created top-level variable declaration. Either or both
    * of the [comment] and [metadata] can be `null` if the variable does not have
    * the corresponding attribute.
    */
   factory TopLevelVariableDeclaration(
@@ skipping 20 matching lines @@
   /**
    * Set the top-level variables being declared to the given list of
    * [variables].
    */
   void set variables(VariableDeclarationList variables);
 }
 
 /**
  * A try statement.
  *
- * > tryStatement ::=
- * >     'try' [Block] ([CatchClause]+ finallyClause? | finallyClause)
- * >
- * > finallyClause ::=
- * >     'finally' [Block]
+ *    tryStatement ::=
+ *        'try' [Block] ([CatchClause]+ finallyClause? | finallyClause)
+ *
+ *    finallyClause ::=
+ *        'finally' [Block]
  *
  * Clients may not extend, implement or mix-in this class.
  */
 abstract class TryStatement extends Statement {
   /**
    * Initialize a newly created try statement. The list of [catchClauses] can be
    * `null` if there are no catch clauses. The [finallyKeyword] and
    * [finallyBlock] can be `null` if there is no finally clause.
    */
   factory TryStatement(
@@ skipping 47 matching lines @@
 
   /**
    * Set the token representing the 'try' keyword to the given [token].
    */
   void set tryKeyword(Token token);
 }
 
 /**
  * The declaration of a type alias.
  *
- * > typeAlias ::=
- * >     'typedef' typeAliasBody
- * >
- * > typeAliasBody ::=
- * >     classTypeAlias
- * >   | functionTypeAlias
+ *    typeAlias ::=
+ *        'typedef' typeAliasBody
+ *
+ *    typeAliasBody ::=
+ *        classTypeAlias
+ *      | functionTypeAlias
  *
  * Clients may not extend, implement or mix-in this class.
  */
 abstract class TypeAlias extends NamedCompilationUnitMember {
   /**
    * Return the semicolon terminating the declaration.
    */
   Token get semicolon;
 
   /**
    * Set the semicolon terminating the declaration to the given [token].
    */
   void set semicolon(Token token);
 
   /**
    * Return the token representing the 'typedef' keyword.
    */
   Token get typedefKeyword;
 
   /**
    * Set the token representing the 'typedef' keyword to the given [token].
    */
   void set typedefKeyword(Token token);
 }
 
 /**
  * A list of type arguments.
  *
- * > typeArguments ::=
- * >     '<' typeName (',' typeName)* '>'
+ *    typeArguments ::=
+ *        '<' typeName (',' typeName)* '>'
  *
  * Clients may not extend, implement or mix-in this class.
  */
 abstract class TypeArgumentList extends AstNode {
   /**
    * Initialize a newly created list of type arguments.
    */
   factory TypeArgumentList(
           Token leftBracket, List<TypeName> arguments, Token rightBracket) =
       TypeArgumentListImpl;
@@ skipping 20 matching lines @@
 
   /**
    * Set the right bracket to the given [token].
    */
   void set rightBracket(Token token);
 }
 
 /**
  * A literal that has a type associated with it.
  *
- * > typedLiteral ::=
- * >     [ListLiteral]
- * >   | [MapLiteral]
+ *    typedLiteral ::=
+ *        [ListLiteral]
+ *      | [MapLiteral]
  *
  * Clients may not extend, implement or mix-in this class.
  */
 abstract class TypedLiteral extends Literal {
   /**
    * Return the token representing the 'const' keyword, or `null` if the literal
    * is not a constant.
    */
   Token get constKeyword;
 
@@ skipping 11 matching lines @@
   /**
    * Set the type argument associated with this literal to the given
    * [typeArguments].
    */
   void set typeArguments(TypeArgumentList typeArguments);
 }
 
 /**
  * The name of a type, which can optionally include type arguments.
  *
- * > typeName ::=
- * >     [Identifier] typeArguments?
+ *    typeName ::=
+ *        [Identifier] typeArguments?
  *
  * Clients may not extend, implement or mix-in this class.
  */
 abstract class TypeName extends AstNode {
   /**
    * Initialize a newly created type name. The [typeArguments] can be `null` if
    * there are no type arguments.
    */
   factory TypeName(Identifier name, TypeArgumentList typeArguments) =
       TypeNameImpl;
@@ skipping 36 matching lines @@
   /**
    * Set the type arguments associated with the type to the given
    * [typeArguments].
    */
   void set typeArguments(TypeArgumentList typeArguments);
 }
 
 /**
  * A type parameter.
  *
- * > typeParameter ::=
- * >     [SimpleIdentifier] ('extends' [TypeName])?
+ *    typeParameter ::=
+ *        [SimpleIdentifier] ('extends' [TypeName])?
  *
  * Clients may not extend, implement or mix-in this class.
  */
 abstract class TypeParameter extends Declaration {
   /**
    * Initialize a newly created type parameter. Either or both of the [comment]
    * and [metadata] can be `null` if the parameter does not have the
    * corresponding attribute. The [extendsKeyword] and [bound] can be `null` if
    * the parameter does not have an upper bound.
    */
@@ skipping 34 matching lines @@
 
   /**
    * Set the name of the type parameter to the given [identifier].
    */
   void set name(SimpleIdentifier identifier);
 }
 
 /**
  * Type parameters within a declaration.
  *
- * > typeParameterList ::=
- * >     '<' [TypeParameter] (',' [TypeParameter])* '>'
+ *    typeParameterList ::=
+ *        '<' [TypeParameter] (',' [TypeParameter])* '>'
  *
  * Clients may not extend, implement or mix-in this class.
  */
 abstract class TypeParameterList extends AstNode {
   /**
    * Initialize a newly created list of type parameters.
    */
   factory TypeParameterList(
       Token leftBracket,
       List<TypeParameter> typeParameters,
@@ skipping 11 matching lines @@
 
   /**
    * Return the type parameters for the type.
    */
   NodeList<TypeParameter> get typeParameters;
 }
 
 /**
  * A directive that references a URI.
  *
- * > uriBasedDirective ::=
- * >     [ExportDirective]
- * >   | [ImportDirective]
- * >   | [PartDirective]
+ *    uriBasedDirective ::=
+ *        [ExportDirective]
+ *      | [ImportDirective]
+ *      | [PartDirective]
  *
  * Clients may not extend, implement or mix-in this class.
  */
 abstract class UriBasedDirective extends Directive {
   /**
    * Return the source to which the URI was resolved.
    */
   Source get source;
 
   /**
@@ skipping 49 matching lines @@
       UriValidationCodeImpl.URI_WITH_INTERPOLATION;
 
   static const UriValidationCode URI_WITH_DART_EXT_SCHEME =
       UriValidationCodeImpl.URI_WITH_DART_EXT_SCHEME;
 }
 
 /**
  * An identifier that has an initial value associated with it. Instances of this
  * class are always children of the class [VariableDeclarationList].
  *
- * > variableDeclaration ::=
- * >     [SimpleIdentifier] ('=' [Expression])?
+ *    variableDeclaration ::=
+ *        [SimpleIdentifier] ('=' [Expression])?
  *
  * TODO(paulberry): the grammar does not allow metadata to be associated with
  * a VariableDeclaration, and currently we don't record comments for it either.
  * Consider changing the class hierarchy so that [VariableDeclaration] does not
  * extend [Declaration].
  *
  * Clients may not extend, implement or mix-in this class.
  */
 abstract class VariableDeclaration extends Declaration {
   /**
@@ skipping 50 matching lines @@
 
   /**
    * 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' [TypeName]?
- * >   | 'const' [TypeName]?
- * >   | 'var'
- * >   | [TypeName]
+ *    variableDeclarationList ::=
+ *        finalConstVarOrType [VariableDeclaration] (',' [VariableDeclaration])*
+ *
+ *    finalConstVarOrType ::=
+ *      | 'final' [TypeName]?
+ *      | 'const' [TypeName]?
+ *      | 'var'
+ *      | [TypeName]
  *
  * Clients may not extend, implement or mix-in this class.
  */
 abstract class VariableDeclarationList extends AnnotatedNode {
   /**
    * Initialize a newly created variable declaration list. Either or both of the
    * [comment] and [metadata] can be `null` if the variable list does not have
    * the corresponding attribute. The [keyword] can be `null` if a type was
    * specified. The [type] must be `null` if the keyword is 'var'.
    */
@@ skipping 44 matching lines @@
   /**
    * 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] ';'
+ *    variableDeclarationStatement ::=
+ *        [VariableDeclarationList] ';'
  *
  * Clients may not extend, implement or mix-in this class.
  */
 abstract class VariableDeclarationStatement extends Statement {
   /**
    * Initialize a newly created variable declaration statement.
    */
   factory VariableDeclarationStatement(
           VariableDeclarationList variableList, Token semicolon) =
       VariableDeclarationStatementImpl;
@@ skipping 15 matching lines @@
 
   /**
    * Set the variables being declared to the given list of [variables].
    */
   void set variables(VariableDeclarationList variables);
 }
 
 /**
  * A while statement.
  *
- * > whileStatement ::=
- * >     'while' '(' [Expression] ')' [Statement]
+ *    whileStatement ::=
+ *        'while' '(' [Expression] ')' [Statement]
  *
  * Clients may not extend, implement or mix-in this class.
  */
 abstract class WhileStatement extends Statement {
   /**
    * Initialize a newly created while statement.
    */
   factory WhileStatement(
       Token whileKeyword,
       Token leftParenthesis,
@@ skipping 50 matching lines @@
 
   /**
    * 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])*
+ *    withClause ::=
+ *        'with' [TypeName] (',' [TypeName])*
  *
  * Clients may not extend, implement or mix-in this class.
  */
 abstract class WithClause extends AstNode {
   /**
    * Initialize a newly created with clause.
    */
   factory WithClause(Token withKeyword, List<TypeName> mixinTypes) =
       WithClauseImpl;
 
   /**
    * 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] ‘;’
+ *    yieldStatement ::=
+ *        'yield' '*'? [Expression] ‘;’
  *
  * Clients may not extend, implement or mix-in this class.
  */
 abstract class YieldStatement extends Statement {
   /**
    * Initialize a newly created yield expression. The [star] can be `null` if no
    * star was provided.
    */
   factory YieldStatement(Token yieldKeyword, Token star, Expression expression,
       Token semicolon) = YieldStatementImpl;
@@ skipping 31 matching lines @@
   /**
    * Return the 'yield' keyword.
    */
   Token get yieldKeyword;
 
   /**
    * Return the 'yield' keyword to the given [token].
    */
   void set yieldKeyword(Token token);
 }