Fix dartdoc for AST nodes

pkg/analyzer/lib/src/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.
 
 library analyzer.src.dart.ast.ast;
 
 import 'dart:collection';
 
 import 'package:analyzer/dart/ast/ast.dart';
 import 'package:analyzer/dart/ast/token.dart';
@@ skipping 11 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]+
  */
 class AdjacentStringsImpl extends StringLiteralImpl implements AdjacentStrings {
   /**
    * The strings that are implicitly concatenated.
    */
   NodeList<StringLiteral> _strings;
 
   /**
    * Initialize a newly created list of adjacent strings. To be syntactically
    * valid, the list of [strings] must contain at least two elements.
@@ skipping 130 matching lines @@
       return true;
     }
     Annotation firstAnnotation = _metadata[0];
     return _comment.offset < firstAnnotation.offset;
   }
 }
 
 /**
  * An annotation that can be associated with an AST node.
  *
- * > metadata ::=
- * >     annotation*
- * >
- * > annotation ::=
- * >     '@' [Identifier] ('.' [SimpleIdentifier])? [ArgumentList]?
+ *    metadata ::=
+ *        annotation*
+ *
+ *    annotation ::=
+ *        '@' [Identifier] ('.' [SimpleIdentifier])? [ArgumentList]?
  */
 class AnnotationImpl extends AstNodeImpl implements Annotation {
   /**
    * The at sign that introduced the annotation.
    */
   Token atSign;
 
   /**
    * The name of the class defining the constructor that is being invoked or the
    * name of the field that is being referenced.
@@ skipping 110 matching lines @@
     _safelyVisitChild(_name, visitor);
     _safelyVisitChild(_constructorName, visitor);
     _safelyVisitChild(_arguments, visitor);
   }
 }
 
 /**
  * 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])*
  */
 class ArgumentListImpl extends AstNodeImpl implements ArgumentList {
   /**
    * The left parenthesis.
    */
   Token leftParenthesis;
 
   /**
    * The expressions producing the values of the arguments.
    */
@@ skipping 126 matching lines @@
       // The expression isn't a child of this node.
       return null;
     }
     return _correspondingStaticParameters[index];
   }
 }
 
 /**
  * An as expression.
  *
- * > asExpression ::=
- * >     [Expression] 'as' [TypeName]
+ *    asExpression ::=
+ *        [Expression] 'as' [TypeName]
  */
 class AsExpressionImpl extends ExpressionImpl implements AsExpression {
   /**
    * The expression used to compute the value being cast.
    */
   Expression _expression;
 
   /**
    * The 'as' operator.
    */
@@ skipping 47 matching lines @@
   @override
   void visitChildren(AstVisitor visitor) {
     _safelyVisitChild(_expression, visitor);
     _safelyVisitChild(_type, visitor);
   }
 }
 
 /**
  * An assert statement.
  *
- * > assertStatement ::=
- * >     'assert' '(' [Expression] ')' ';'
+ *    assertStatement ::=
+ *        'assert' '(' [Expression] ')' ';'
  */
 class AssertStatementImpl extends StatementImpl implements AssertStatement {
   /**
    * The token representing the 'assert' keyword.
    */
   Token assertKeyword;
 
   /**
    * The left parenthesis.
    */
@@ skipping 78 matching lines @@
   @override
   void visitChildren(AstVisitor visitor) {
     _safelyVisitChild(_condition, visitor);
     _safelyVisitChild(message, visitor);
   }
 }
 
 /**
  * An assignment expression.
  *
- * > assignmentExpression ::=
- * >     [Expression] operator [Expression]
+ *    assignmentExpression ::=
+ *        [Expression] operator [Expression]
  */
 class AssignmentExpressionImpl extends ExpressionImpl
     implements AssignmentExpression {
   /**
    * The expression used to compute the left hand side.
    */
   Expression _leftHandSide;
 
   /**
    * The assignment operator being applied.
@@ skipping 282 matching lines @@
   void _safelyVisitChild(AstNode child, AstVisitor visitor) {
     if (child != null) {
       child.accept(visitor);
     }
   }
 }
 
 /**
  * An await expression.
  *
- * > awaitExpression ::=
- * >     'await' [Expression]
+ *    awaitExpression ::=
+ *        'await' [Expression]
  */
 class AwaitExpressionImpl extends ExpressionImpl implements AwaitExpression {
   /**
    * The 'await' keyword.
    */
   Token awaitKeyword;
 
   /**
    * The expression whose value is being waited on.
    */
@@ skipping 37 matching lines @@
 
   @override
   void visitChildren(AstVisitor visitor) {
     _safelyVisitChild(_expression, visitor);
   }
 }
 
 /**
  * A binary (infix) expression.
  *
- * > binaryExpression ::=
- * >     [Expression] [Token] [Expression]
+ *    binaryExpression ::=
+ *        [Expression] [Token] [Expression]
  */
 class BinaryExpressionImpl extends ExpressionImpl implements BinaryExpression {
   /**
    * The expression used to compute the left operand.
    */
   Expression _leftOperand;
 
   /**
    * The binary operator being applied.
    */
@@ skipping 106 matching lines @@
   @override
   void visitChildren(AstVisitor visitor) {
     _safelyVisitChild(_leftOperand, visitor);
     _safelyVisitChild(_rightOperand, visitor);
   }
 }
 
 /**
  * A function body that consists of a block of statements.
  *
- * > blockFunctionBody ::=
- * >     ('async' | 'async' '*' | 'sync' '*')? [Block]
+ *    blockFunctionBody ::=
+ *        ('async' | 'async' '*' | 'sync' '*')? [Block]
  */
 class BlockFunctionBodyImpl extends FunctionBodyImpl
     implements BlockFunctionBody {
   /**
    * The token representing the 'async' or 'sync' keyword, or `null` if there is
    * no such keyword.
    */
   Token keyword;
 
   /**
@@ skipping 54 matching lines @@
 
   @override
   void visitChildren(AstVisitor visitor) {
     _safelyVisitChild(_block, visitor);
   }
 }
 
 /**
  * A sequence of statements.
  *
- * > block ::=
- * >     '{' statement* '}'
+ *    block ::=
+ *        '{' statement* '}'
  */
 class BlockImpl extends StatementImpl implements Block {
   /**
    * The left curly bracket.
    */
   Token leftBracket;
 
   /**
    * The statements contained in the block.
    */
@@ skipping 31 matching lines @@
 
   @override
   void visitChildren(AstVisitor visitor) {
     _statements.accept(visitor);
   }
 }
 
 /**
  * A boolean literal expression.
  *
- * > booleanLiteral ::=
- * >     'false' | 'true'
+ *    booleanLiteral ::=
+ *        'false' | 'true'
  */
 class BooleanLiteralImpl extends LiteralImpl implements BooleanLiteral {
   /**
    * The token representing the literal.
    */
   Token literal;
 
   /**
    * The value of the literal.
    */
@@ skipping 21 matching lines @@
 
   @override
   void visitChildren(AstVisitor visitor) {
     // There are no children to visit.
   }
 }
 
 /**
  * A break statement.
  *
- * > breakStatement ::=
- * >     'break' [SimpleIdentifier]? ';'
+ *    breakStatement ::=
+ *        'break' [SimpleIdentifier]? ';'
  */
 class BreakStatementImpl extends StatementImpl implements BreakStatement {
   /**
    * The token representing the 'break' keyword.
    */
   Token breakKeyword;
 
   /**
    * The label associated with the statement, or `null` if there is no label.
    */
@@ skipping 49 matching lines @@
   void visitChildren(AstVisitor visitor) {
     _safelyVisitChild(_label, visitor);
   }
 }
 
 /**
  * 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
  */
 class CascadeExpressionImpl extends ExpressionImpl
     implements CascadeExpression {
   /**
    * The target of the cascade sections.
    */
   Expression _target;
 
   /**
    * The cascade sections sharing the common target.
@@ skipping 40 matching lines @@
   @override
   void visitChildren(AstVisitor visitor) {
     _safelyVisitChild(_target, visitor);
     _cascadeSections.accept(visitor);
   }
 }
 
 /**
  * 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])? ')'
  */
 class CatchClauseImpl extends AstNodeImpl implements CatchClause {
   /**
    * The token representing the 'on' keyword, or `null` if there is no 'on'
    * keyword.
    */
   Token onKeyword;
 
   /**
    * The type of exceptions caught by this catch clause, or `null` if this catch
@@ skipping 157 matching lines @@
   void addAll(Iterable items) {
     if (items != null) {
       _entities.addAll(items);
     }
   }
 }
 
 /**
  * The declaration of a class.
  *
- * > classDeclaration ::=
- * >     'abstract'? 'class' [SimpleIdentifier] [TypeParameterList]?
- * >     ([ExtendsClause] [WithClause]?)?
- * >     [ImplementsClause]?
- * >     '{' [ClassMember]* '}'
+ *    classDeclaration ::=
+ *        'abstract'? 'class' [SimpleIdentifier] [TypeParameterList]?
+ *        ([ExtendsClause] [WithClause]?)?
+ *        [ImplementsClause]?
+ *        '{' [ClassMember]* '}'
  */
 class ClassDeclarationImpl extends NamedCompilationUnitMemberImpl
     implements ClassDeclaration {
   /**
    * The 'abstract' keyword, or `null` if the keyword was absent.
    */
   Token abstractKeyword;
 
   /**
    * The token representing the 'class' keyword.
@@ skipping 225 matching lines @@
    * [comment] and [metadata] can be `null` if the member does not have the
    * corresponding attribute.
    */
   ClassMemberImpl(Comment comment, List<Annotation> metadata)
       : super(comment, metadata);
 }
 
 /**
  * A class type alias.
  *
- * > classTypeAlias ::=
- * >     [SimpleIdentifier] [TypeParameterList]? '=' 'abstract'? mixinApplication
- * >
- * > mixinApplication ::=
- * >     [TypeName] [WithClause] [ImplementsClause]? ';'
+ *    classTypeAlias ::=
+ *        [SimpleIdentifier] [TypeParameterList]? '=' 'abstract'? mixinApplication
+ *
+ *    mixinApplication ::=
+ *        [TypeName] [WithClause] [ImplementsClause]? ';'
  */
 class ClassTypeAliasImpl extends TypeAliasImpl implements ClassTypeAlias {
   /**
    * The type parameters for the class, or `null` if the class does not have any
    * type parameters.
    */
   TypeParameterList _typeParameters;
 
   /**
    * The token for the '=' separating the name from the definition.
@@ skipping 118 matching lines @@
     _safelyVisitChild(_typeParameters, visitor);
     _safelyVisitChild(_superclass, visitor);
     _safelyVisitChild(_withClause, visitor);
     _safelyVisitChild(_implementsClause, visitor);
   }
 }
 
 /**
  * A combinator associated with an import or export directive.
  *
- * > combinator ::=
- * >     [HideCombinator]
- * >   | [ShowCombinator]
+ *    combinator ::=
+ *        [HideCombinator]
+ *      | [ShowCombinator]
  */
 abstract class CombinatorImpl extends AstNodeImpl implements Combinator {
   /**
    * The 'hide' or 'show' keyword specifying what kind of processing is to be
    * done on the names.
    */
   Token keyword;
 
   /**
    * Initialize a newly created combinator.
    */
   CombinatorImpl(this.keyword);
 
   @override
   Token get beginToken => keyword;
 }
 
 /**
  * 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)+
  */
 class CommentImpl extends AstNodeImpl implements Comment {
   /**
    * The tokens representing the comment.
    */
   final List<Token> tokens;
 
   /**
    * The type of the comment.
    */
@@ skipping 69 matching lines @@
   /**
    * Create an end-of-line comment consisting of the given [tokens].
    */
   static Comment createEndOfLineComment(List<Token> tokens) =>
       new CommentImpl(tokens, CommentType.END_OF_LINE, null);
 }
 
 /**
  * A reference to a Dart element that is found within a documentation comment.
  *
- * > commentReference ::=
- * >     '[' 'new'? [Identifier] ']'
+ *    commentReference ::=
+ *        '[' 'new'? [Identifier] ']'
  */
 class CommentReferenceImpl extends AstNodeImpl implements CommentReference {
   /**
    * The token representing the 'new' keyword, or `null` if there was no 'new'
    * keyword.
    */
   Token newKeyword;
 
   /**
    * The identifier being referenced.
@@ skipping 70 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]*
  */
 class CompilationUnitImpl extends AstNodeImpl implements CompilationUnit {
   /**
    * The first token in the token stream that was parsed to form this
    * compilation unit.
    */
   Token beginToken;
 
   /**
    * The script tag at the beginning of the compilation unit, or `null` if there
@@ skipping 118 matching lines @@
         child.accept(visitor);
       }
     }
   }
 }
 
 /**
  * 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]
  */
 abstract class CompilationUnitMemberImpl extends DeclarationImpl
     implements CompilationUnitMember {
   /**
    * Initialize a newly created generic compilation unit member. Either or both
    * of the [comment] and [metadata] can be `null` if the member does not have
    * the corresponding attribute.
    */
   CompilationUnitMemberImpl(Comment comment, List<Annotation> metadata)
       : super(comment, metadata);
 }
 
 /**
  * A conditional expression.
  *
- * > conditionalExpression ::=
- * >     [Expression] '?' [Expression] ':' [Expression]
+ *    conditionalExpression ::=
+ *        [Expression] '?' [Expression] ':' [Expression]
  */
 class ConditionalExpressionImpl extends ExpressionImpl
     implements ConditionalExpression {
   /**
    * The condition used to determine which of the expressions is executed next.
    */
   Expression _condition;
 
   /**
    * The token used to separate the condition from the then expression.
@@ skipping 158 matching lines @@
   void visitChildren(AstVisitor visitor) {
     _safelyVisitChild(_name, visitor);
     _safelyVisitChild(_value, visitor);
     _safelyVisitChild(_libraryUri, visitor);
   }
 }
 
 /**
  * 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])*
  */
 class ConstructorDeclarationImpl extends ClassMemberImpl
     implements ConstructorDeclaration {
   /**
    * The token for the 'external' keyword, or `null` if the constructor is not
    * external.
    */
   Token externalKeyword;
 
   /**
@@ skipping 188 matching lines @@
     _safelyVisitChild(_parameters, visitor);
     _initializers.accept(visitor);
     _safelyVisitChild(_redirectedConstructor, visitor);
     _safelyVisitChild(_body, visitor);
   }
 }
 
 /**
  * The initialization of a field within a constructor's initialization list.
  *
- * > fieldInitializer ::=
- * >     ('this' '.')? [SimpleIdentifier] '=' [Expression]
+ *    fieldInitializer ::=
+ *        ('this' '.')? [SimpleIdentifier] '=' [Expression]
  */
 class ConstructorFieldInitializerImpl extends ConstructorInitializerImpl
     implements ConstructorFieldInitializer {
   /**
    * The token for the 'this' keyword, or `null` if there is no 'this' keyword.
    */
   Token thisKeyword;
 
   /**
    * The token for the period after the 'this' keyword, or `null` if there is no
@@ skipping 68 matching lines @@
   @override
   void visitChildren(AstVisitor visitor) {
     _safelyVisitChild(_fieldName, visitor);
     _safelyVisitChild(_expression, visitor);
   }
 }
 
 /**
  * A node that can occur in the initializer list of a constructor declaration.
  *
- * > constructorInitializer ::=
- * >     [SuperConstructorInvocation]
- * >   | [ConstructorFieldInitializer]
- * >   | [RedirectingConstructorInvocation]
+ *    constructorInitializer ::=
+ *        [SuperConstructorInvocation]
+ *      | [ConstructorFieldInitializer]
+ *      | [RedirectingConstructorInvocation]
  */
 abstract class ConstructorInitializerImpl extends AstNodeImpl
     implements ConstructorInitializer {}
 
 /**
  * The name of the constructor.
  *
- * > constructorName ::=
- * >     type ('.' identifier)?
+ *    constructorName ::=
+ *        type ('.' identifier)?
  */
 class ConstructorNameImpl extends AstNodeImpl implements ConstructorName {
   /**
    * The name of the type defining the constructor.
    */
   TypeName _type;
 
   /**
    * The token for the period before the constructor name, or `null` if the
    * specified constructor is the unnamed constructor.
@@ skipping 59 matching lines @@
   @override
   void visitChildren(AstVisitor visitor) {
     _safelyVisitChild(_type, visitor);
     _safelyVisitChild(_name, visitor);
   }
 }
 
 /**
  * A continue statement.
  *
- * > continueStatement ::=
- * >     'continue' [SimpleIdentifier]? ';'
+ *    continueStatement ::=
+ *        'continue' [SimpleIdentifier]? ';'
  */
 class ContinueStatementImpl extends StatementImpl implements ContinueStatement {
   /**
    * The token representing the 'continue' keyword.
    */
   Token continueKeyword;
 
   /**
    * The label associated with the statement, or `null` if there is no label.
    */
@@ skipping 61 matching lines @@
    * [metadata] can be `null` if the declaration does not have the corresponding
    * attribute.
    */
   DeclarationImpl(Comment comment, List<Annotation> metadata)
       : super(comment, metadata);
 }
 
 /**
  * The declaration of a single identifier.
  *
- * > declaredIdentifier ::=
- * >     [Annotation] finalConstVarOrType [SimpleIdentifier]
+ *    declaredIdentifier ::=
+ *        [Annotation] finalConstVarOrType [SimpleIdentifier]
  */
 class DeclaredIdentifierImpl extends DeclarationImpl
     implements DeclaredIdentifier {
   /**
    * The token representing either the 'final', 'const' or 'var' keyword, or
    * `null` if no keyword was used.
    */
   Token keyword;
 
   /**
@@ skipping 80 matching lines @@
     _safelyVisitChild(_type, visitor);
     _safelyVisitChild(_identifier, visitor);
   }
 }
 
 /**
  * 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])?
  */
 class DefaultFormalParameterImpl extends FormalParameterImpl
     implements DefaultFormalParameter {
   /**
    * The formal parameter with which the default value is associated.
    */
   NormalFormalParameter _parameter;
 
   /**
    * The kind of this parameter.
@@ skipping 71 matching lines @@
   @override
   void visitChildren(AstVisitor visitor) {
     _safelyVisitChild(_parameter, visitor);
     _safelyVisitChild(_defaultValue, visitor);
   }
 }
 
 /**
  * A node that represents a directive.
  *
- * > directive ::=
- * >     [ExportDirective]
- * >   | [ImportDirective]
- * >   | [LibraryDirective]
- * >   | [PartDirective]
- * >   | [PartOfDirective]
+ *    directive ::=
+ *        [ExportDirective]
+ *      | [ImportDirective]
+ *      | [LibraryDirective]
+ *      | [PartDirective]
+ *      | [PartOfDirective]
  */
 abstract class DirectiveImpl extends AnnotatedNodeImpl implements Directive {
   /**
    * 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 element;
 
   /**
    * Initialize a newly create directive. Either or both of the [comment] and
    * [metadata] can be `null` if the directive does not have the corresponding
    * attribute.
    */
   DirectiveImpl(Comment comment, List<Annotation> metadata)
       : super(comment, metadata);
 }
 
 /**
  * A do statement.
  *
- * > doStatement ::=
- * >     'do' [Statement] 'while' '(' [Expression] ')' ';'
+ *    doStatement ::=
+ *        'do' [Statement] 'while' '(' [Expression] ')' ';'
  */
 class DoStatementImpl extends StatementImpl implements DoStatement {
   /**
    * The token representing the 'do' keyword.
    */
   Token doKeyword;
 
   /**
    * The body of the loop.
    */
@@ skipping 77 matching lines @@
   @override
   void visitChildren(AstVisitor visitor) {
     _safelyVisitChild(_body, visitor);
     _safelyVisitChild(_condition, visitor);
   }
 }
 
 /**
  * A dotted name, used in a configuration within an import or export directive.
  *
- * > dottedName ::=
- * >     [SimpleIdentifier] ('.' [SimpleIdentifier])*
+ *    dottedName ::=
+ *        [SimpleIdentifier] ('.' [SimpleIdentifier])*
  */
 class DottedNameImpl extends AstNodeImpl implements DottedName {
   /**
    * The components of the identifier.
    */
   NodeList<SimpleIdentifier> _components;
 
   /**
    * Initialize a newly created dotted name.
    */
@@ skipping 19 matching lines @@
 
   @override
   void visitChildren(AstVisitor visitor) {
     _components.accept(visitor);
   }
 }
 
 /**
  * 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+
  */
 class DoubleLiteralImpl extends LiteralImpl implements DoubleLiteral {
   /**
    * The token representing the literal.
    */
   Token literal;
 
   /**
    * The value of the literal.
    */
@@ skipping 19 matching lines @@
   @override
   void visitChildren(AstVisitor visitor) {
     // There are no children to visit.
   }
 }
 
 /**
  * An empty function body, which can only appear in constructors or abstract
  * methods.
  *
- * > emptyFunctionBody ::=
- * >     ';'
+ *    emptyFunctionBody ::=
+ *        ';'
  */
 class EmptyFunctionBodyImpl extends FunctionBodyImpl
     implements EmptyFunctionBody {
   /**
    * The token representing the semicolon that marks the end of the function
    * body.
    */
   Token semicolon;
 
   /**
@@ skipping 15 matching lines @@
 
   @override
   void visitChildren(AstVisitor visitor) {
     // Empty function bodies have no children.
   }
 }
 
 /**
  * An empty statement.
  *
- * > emptyStatement ::=
- * >     ';'
+ *    emptyStatement ::=
+ *        ';'
  */
 class EmptyStatementImpl extends StatementImpl implements EmptyStatement {
   /**
    * The semicolon terminating the statement.
    */
   Token semicolon;
 
   /**
    * Initialize a newly created empty statement.
    */
@@ skipping 66 matching lines @@
   @override
   void visitChildren(AstVisitor visitor) {
     super.visitChildren(visitor);
     _safelyVisitChild(_name, visitor);
   }
 }
 
 /**
  * The declaration of an enumeration.
  *
- * > enumType ::=
- * >     metadata 'enum' [SimpleIdentifier] '{' [SimpleIdentifier] (',' [SimpleIdentifier])* (',')? '}'
+ *    enumType ::=
+ *        metadata 'enum' [SimpleIdentifier] '{' [SimpleIdentifier] (',' [SimpleIdentifier])* (',')? '}'
  */
 class EnumDeclarationImpl extends NamedCompilationUnitMemberImpl
     implements EnumDeclaration {
   /**
    * The 'enum' keyword.
    */
   Token enumKeyword;
 
   /**
    * The left curly bracket.
@@ skipping 68 matching lines @@
 class EphemeralIdentifier extends SimpleIdentifierImpl {
   EphemeralIdentifier(AstNode parent, int location)
       : super(new StringToken(TokenType.IDENTIFIER, "", location)) {
     (parent as AstNodeImpl)._becomeParentOf(this);
   }
 }
 
 /**
  * An export directive.
  *
- * > exportDirective ::=
- * >     [Annotation] 'export' [StringLiteral] [Combinator]* ';'
+ *    exportDirective ::=
+ *        [Annotation] 'export' [StringLiteral] [Combinator]* ';'
  */
 class ExportDirectiveImpl extends NamespaceDirectiveImpl
     implements ExportDirective {
   /**
    * 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.
    */
   ExportDirectiveImpl(
@@ skipping 30 matching lines @@
   @override
   void visitChildren(AstVisitor visitor) {
     super.visitChildren(visitor);
     combinators.accept(visitor);
   }
 }
 
 /**
  * A function body consisting of a single expression.
  *
- * > expressionFunctionBody ::=
- * >     'async'? '=>' [Expression] ';'
+ *    expressionFunctionBody ::=
+ *        'async'? '=>' [Expression] ';'
  */
 class ExpressionFunctionBodyImpl extends FunctionBodyImpl
     implements ExpressionFunctionBody {
   /**
    * The token representing the 'async' keyword, or `null` if there is no such
    * keyword.
    */
   Token keyword;
 
   /**
@@ skipping 64 matching lines @@
 
   @override
   void visitChildren(AstVisitor visitor) {
     _safelyVisitChild(_expression, visitor);
   }
 }
 
 /**
  * A node that represents an expression.
  *
- * > expression ::=
- * >     [AssignmentExpression]
- * >   | [ConditionalExpression] cascadeSection*
- * >   | [ThrowExpression]
+ *    expression ::=
+ *        [AssignmentExpression]
+ *      | [ConditionalExpression] cascadeSection*
+ *      | [ThrowExpression]
  */
 abstract class ExpressionImpl extends AstNodeImpl implements Expression {
   /**
    * The static type of this expression, or `null` if the AST structure has not
    * been resolved.
    */
   DartType staticType;
 
   /**
    * The propagated type of this expression, or `null` if type propagation has
@@ skipping 75 matching lines @@
     } else if (parent is PostfixExpressionImpl) {
       return parent._staticParameterElementForOperand;
     }
     return null;
   }
 }
 
 /**
  * An expression used as a statement.
  *
- * > expressionStatement ::=
- * >     [Expression]? ';'
+ *    expressionStatement ::=
+ *        [Expression]? ';'
  */
 class ExpressionStatementImpl extends StatementImpl
     implements ExpressionStatement {
   /**
    * The expression that comprises the statement.
    */
   Expression _expression;
 
   /**
    * The semicolon terminating the statement, or `null` if the expression is a
@@ skipping 39 matching lines @@
 
   @override
   void visitChildren(AstVisitor visitor) {
     _safelyVisitChild(_expression, visitor);
   }
 }
 
 /**
  * The "extends" clause in a class declaration.
  *
- * > extendsClause ::=
- * >     'extends' [TypeName]
+ *    extendsClause ::=
+ *        'extends' [TypeName]
  */
 class ExtendsClauseImpl extends AstNodeImpl implements ExtendsClause {
   /**
    * The token representing the 'extends' keyword.
    */
   Token extendsKeyword;
 
   /**
    * The name of the class that is being extended.
    */
@@ skipping 29 matching lines @@
 
   @override
   void visitChildren(AstVisitor visitor) {
     _safelyVisitChild(_superclass, visitor);
   }
 }
 
 /**
  * The declaration of one or more fields of the same type.
  *
- * > fieldDeclaration ::=
- * >     'static'? [VariableDeclarationList] ';'
+ *    fieldDeclaration ::=
+ *        'static'? [VariableDeclarationList] ';'
  */
 class FieldDeclarationImpl extends ClassMemberImpl implements FieldDeclaration {
   /**
    * The token representing the 'static' keyword, or `null` if the fields are
    * not static.
    */
   Token staticKeyword;
 
   /**
    * The fields being declared.
@@ skipping 52 matching lines @@
   @override
   void visitChildren(AstVisitor visitor) {
     super.visitChildren(visitor);
     _safelyVisitChild(_fieldList, visitor);
   }
 }
 
 /**
  * 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])?
  */
 class FieldFormalParameterImpl extends NormalFormalParameterImpl
     implements FieldFormalParameter {
   /**
    * The token representing either the 'final', 'const' or 'var' keyword, or
    * `null` if no keyword was used.
    */
   Token keyword;
 
   /**
@@ skipping 119 matching lines @@
     _safelyVisitChild(_type, visitor);
     _safelyVisitChild(identifier, visitor);
     _safelyVisitChild(_typeParameters, visitor);
     _safelyVisitChild(_parameters, visitor);
   }
 }
 
 /**
  * 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]
  */
 class ForEachStatementImpl extends StatementImpl implements ForEachStatement {
   /**
    * The token representing the 'await' keyword, or `null` if there is no
    * 'await' keyword.
    */
   Token awaitKeyword;
 
   /**
    * The token representing the 'for' keyword.
@@ skipping 132 matching lines @@
     _safelyVisitChild(_loopVariable, visitor);
     _safelyVisitChild(_identifier, visitor);
     _safelyVisitChild(_iterable, visitor);
     _safelyVisitChild(_body, visitor);
   }
 }
 
 /**
  * A node representing a parameter to a function.
  *
- * > formalParameter ::=
- * >     [NormalFormalParameter]
- * >   | [DefaultFormalParameter]
+ *    formalParameter ::=
+ *        [NormalFormalParameter]
+ *      | [DefaultFormalParameter]
  */
 abstract class FormalParameterImpl extends AstNodeImpl
     implements FormalParameter {
   @override
   ParameterElement get element {
     SimpleIdentifier identifier = this.identifier;
     if (identifier == null) {
       return null;
     }
     return identifier.staticElement as ParameterElement;
   }
 }
 
 /**
  * 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])* '}'
  */
 class FormalParameterListImpl extends AstNodeImpl
     implements FormalParameterList {
   /**
    * The left parenthesis.
    */
   Token leftParenthesis;
 
   /**
    * The parameters associated with the method.
@@ skipping 70 matching lines @@
 
   @override
   void visitChildren(AstVisitor visitor) {
     _parameters.accept(visitor);
   }
 }
 
 /**
  * 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]?
  */
 class ForStatementImpl extends StatementImpl implements ForStatement {
   /**
    * The token representing the 'for' keyword.
    */
   Token forKeyword;
 
   /**
    * The left parenthesis.
    */
@@ skipping 131 matching lines @@
     _safelyVisitChild(_initialization, visitor);
     _safelyVisitChild(_condition, visitor);
     _updaters.accept(visitor);
     _safelyVisitChild(_body, visitor);
   }
 }
 
 /**
  * A node representing the body of a function or method.
  *
- * > functionBody ::=
- * >     [BlockFunctionBody]
- * >   | [EmptyFunctionBody]
- * >   | [ExpressionFunctionBody]
+ *    functionBody ::=
+ *        [BlockFunctionBody]
+ *      | [EmptyFunctionBody]
+ *      | [ExpressionFunctionBody]
  */
 abstract class FunctionBodyImpl extends AstNodeImpl implements FunctionBody {
   /**
    * Additional information about local variables and parameters that are
    * declared within this function body or any enclosing function body.  `null`
    * if resolution has not yet been performed.
    */
   LocalVariableInfo localVariableInfo;
 
   /**
@@ skipping 36 matching lines @@
     if (localVariableInfo == null) {
       throw new StateError('Resolution has not yet been performed');
     }
     return localVariableInfo.potentiallyMutatedInScope.contains(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]
  */
 class FunctionDeclarationImpl extends NamedCompilationUnitMemberImpl
     implements FunctionDeclaration {
   /**
    * The token representing the 'external' keyword, or `null` if this is not an
    * external function.
    */
   Token externalKeyword;
 
   /**
@@ skipping 139 matching lines @@
 
   @override
   void visitChildren(AstVisitor visitor) {
     _safelyVisitChild(_functionDeclaration, visitor);
   }
 }
 
 /**
  * A function expression.
  *
- * > functionExpression ::=
- * >     [TypeParameterList]? [FormalParameterList] [FunctionBody]
+ *    functionExpression ::=
+ *        [TypeParameterList]? [FormalParameterList] [FunctionBody]
  */
 class FunctionExpressionImpl extends ExpressionImpl
     implements FunctionExpression {
   /**
    * The type parameters associated with the method, or `null` if the method is
    * not a generic method.
    */
   TypeParameterList _typeParameters;
 
   /**
@@ skipping 89 matching lines @@
     _safelyVisitChild(_body, visitor);
   }
 }
 
 /**
  * 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]
  */
 class FunctionExpressionInvocationImpl extends InvocationExpressionImpl
     implements FunctionExpressionInvocation {
   /**
    * The expression producing the function being invoked.
    */
   Expression _function;
 
   /**
    * The element associated with the function being invoked based on static type
@@ skipping 55 matching lines @@
   void visitChildren(AstVisitor visitor) {
     _safelyVisitChild(_function, visitor);
     _safelyVisitChild(_typeArguments, visitor);
     _safelyVisitChild(_argumentList, visitor);
   }
 }
 
 /**
  * A function type alias.
  *
- * > functionTypeAlias ::=
- * >     functionPrefix [TypeParameterList]? [FormalParameterList] ';'
- * >
- * > functionPrefix ::=
- * >     [TypeName]? [SimpleIdentifier]
+ *    functionTypeAlias ::=
+ *        functionPrefix [TypeParameterList]? [FormalParameterList] ';'
+ *
+ *    functionPrefix ::=
+ *        [TypeName]? [SimpleIdentifier]
  */
 class FunctionTypeAliasImpl extends TypeAliasImpl implements FunctionTypeAlias {
   /**
    * The name of the return type of the function type being defined, or `null`
    * if no return type was given.
    */
   TypeName _returnType;
 
   /**
    * The type parameters for the function type, or `null` if the function type
@@ skipping 74 matching lines @@
     _safelyVisitChild(_returnType, visitor);
     _safelyVisitChild(_name, visitor);
     _safelyVisitChild(_typeParameters, visitor);
     _safelyVisitChild(_parameters, visitor);
   }
 }
 
 /**
  * A function-typed formal parameter.
  *
- * > functionSignature ::=
- * >     [TypeName]? [SimpleIdentifier] [TypeParameterList]? [FormalParameterList]
+ *    functionSignature ::=
+ *        [TypeName]? [SimpleIdentifier] [TypeParameterList]? [FormalParameterList]
  */
 class FunctionTypedFormalParameterImpl extends NormalFormalParameterImpl
     implements FunctionTypedFormalParameter {
   /**
    * The return type of the function, or `null` if the function does not have a
    * return type.
    */
   TypeName _returnType;
 
   /**
@@ skipping 81 matching lines @@
     _safelyVisitChild(identifier, visitor);
     _safelyVisitChild(_typeParameters, visitor);
     _safelyVisitChild(_parameters, visitor);
   }
 }
 
 /**
  * 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])*
  */
 class HideCombinatorImpl extends CombinatorImpl implements HideCombinator {
   /**
    * The list of names from the library that are hidden by this combinator.
    */
   NodeList<SimpleIdentifier> _hiddenNames;
 
   /**
    * Initialize a newly created import show combinator.
    */
@@ skipping 18 matching lines @@
 
   @override
   void visitChildren(AstVisitor visitor) {
     _hiddenNames.accept(visitor);
   }
 }
 
 /**
  * A node that represents an identifier.
  *
- * > identifier ::=
- * >     [SimpleIdentifier]
- * >   | [PrefixedIdentifier]
+ *    identifier ::=
+ *        [SimpleIdentifier]
+ *      | [PrefixedIdentifier]
  */
 abstract class IdentifierImpl extends ExpressionImpl implements Identifier {
   /**
    * 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.
    */
   Element get bestElement;
 
   @override
   bool get isAssignable => true;
 }
 
 /**
  * An if statement.
  *
- * > ifStatement ::=
- * >     'if' '(' [Expression] ')' [Statement] ('else' [Statement])?
+ *    ifStatement ::=
+ *        'if' '(' [Expression] ')' [Statement] ('else' [Statement])?
  */
 class IfStatementImpl extends StatementImpl implements IfStatement {
   /**
    * The token representing the 'if' keyword.
    */
   Token ifKeyword;
 
   /**
    * The left parenthesis.
    */
@@ skipping 95 matching lines @@
   void visitChildren(AstVisitor visitor) {
     _safelyVisitChild(_condition, visitor);
     _safelyVisitChild(_thenStatement, visitor);
     _safelyVisitChild(_elseStatement, visitor);
   }
 }
 
 /**
  * The "implements" clause in an class declaration.
  *
- * > implementsClause ::=
- * >     'implements' [TypeName] (',' [TypeName])*
+ *    implementsClause ::=
+ *        'implements' [TypeName] (',' [TypeName])*
  */
 class ImplementsClauseImpl extends AstNodeImpl implements ImplementsClause {
   /**
    * The token representing the 'implements' keyword.
    */
   Token implementsKeyword;
 
   /**
    * The interfaces that are being implemented.
    */
@@ skipping 26 matching lines @@
 
   @override
   void visitChildren(AstVisitor visitor) {
     _interfaces.accept(visitor);
   }
 }
 
 /**
  * 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]* ';'
  */
 class ImportDirectiveImpl extends NamespaceDirectiveImpl
     implements ImportDirective {
   /**
    * The token representing the 'deferred' keyword, or `null` if the imported is
    * not deferred.
    */
   Token deferredKeyword;
 
   /**
@@ skipping 68 matching lines @@
   void visitChildren(AstVisitor visitor) {
     super.visitChildren(visitor);
     _safelyVisitChild(_prefix, visitor);
     combinators.accept(visitor);
   }
 }
 
 /**
  * An index expression.
  *
- * > indexExpression ::=
- * >     [Expression] '[' [Expression] ']'
+ *    indexExpression ::=
+ *        [Expression] '[' [Expression] ']'
  */
 class IndexExpressionImpl extends ExpressionImpl implements IndexExpression {
   /**
    * The expression used to compute the object being indexed, or `null` if this
    * index expression is part of a cascade expression.
    */
   Expression _target;
 
   /**
    * The period ("..") before a cascaded index expression, or `null` if this
@@ skipping 191 matching lines @@
   @override
   void visitChildren(AstVisitor visitor) {
     _safelyVisitChild(_target, visitor);
     _safelyVisitChild(_index, visitor);
   }
 }
 
 /**
  * An instance creation expression.
  *
- * > newExpression ::=
- * >     ('new' | 'const') [TypeName] ('.' [SimpleIdentifier])? [ArgumentList]
+ *    newExpression ::=
+ *        ('new' | 'const') [TypeName] ('.' [SimpleIdentifier])? [ArgumentList]
  */
 class InstanceCreationExpressionImpl extends ExpressionImpl
     implements InstanceCreationExpression {
   /**
    * The 'new' or 'const' keyword used to indicate how an object should be
    * created.
    */
   Token keyword;
 
   /**
@@ skipping 64 matching lines @@
   @override
   void visitChildren(AstVisitor visitor) {
     _safelyVisitChild(_constructorName, visitor);
     _safelyVisitChild(_argumentList, visitor);
   }
 }
 
 /**
  * An integer literal expression.
  *
- * > integerLiteral ::=
- * >     decimalIntegerLiteral
- * >   | hexadecimalIntegerLiteral
- * >
- * > decimalIntegerLiteral ::=
- * >     decimalDigit+
- * >
- * > hexadecimalIntegerLiteral ::=
- * >     '0x' hexadecimalDigit+
- * >   | '0X' hexadecimalDigit+
+ *    integerLiteral ::=
+ *        decimalIntegerLiteral
+ *      | hexadecimalIntegerLiteral
+ *
+ *    decimalIntegerLiteral ::=
+ *        decimalDigit+
+ *
+ *    hexadecimalIntegerLiteral ::=
+ *        '0x' hexadecimalDigit+
+ *      | '0X' hexadecimalDigit+
  */
 class IntegerLiteralImpl extends LiteralImpl implements IntegerLiteral {
   /**
    * The token representing the literal.
    */
   Token literal;
 
   /**
    * The value of the literal.
    */
@@ skipping 18 matching lines @@
 
   @override
   void visitChildren(AstVisitor visitor) {
     // There are no children to visit.
   }
 }
 
 /**
  * A node within a [StringInterpolation].
  *
- * > interpolationElement ::=
- * >     [InterpolationExpression]
- * >   | [InterpolationString]
+ *    interpolationElement ::=
+ *        [InterpolationExpression]
+ *      | [InterpolationString]
  */
 abstract class InterpolationElementImpl extends AstNodeImpl
     implements InterpolationElement {}
 
 /**
  * An expression embedded in a string interpolation.
  *
- * > interpolationExpression ::=
- * >     '$' [SimpleIdentifier]
- * >   | '$' '{' [Expression] '}'
+ *    interpolationExpression ::=
+ *        '$' [SimpleIdentifier]
+ *      | '$' '{' [Expression] '}'
  */
 class InterpolationExpressionImpl extends InterpolationElementImpl
     implements InterpolationExpression {
   /**
    * The token used to introduce the interpolation expression; either '$' if the
    * expression is a simple identifier or '${' if the expression is a full
    * expression.
    */
   Token leftBracket;
 
@@ skipping 46 matching lines @@
 
   @override
   void visitChildren(AstVisitor visitor) {
     _safelyVisitChild(_expression, visitor);
   }
 }
 
 /**
  * A non-empty substring of an interpolated string.
  *
- * > interpolationString ::=
- * >     characters
+ *    interpolationString ::=
+ *        characters
  */
 class InterpolationStringImpl extends InterpolationElementImpl
     implements InterpolationString {
   /**
    * The characters that will be added to the string.
    */
   Token contents;
 
   /**
    * The value of the literal.
@@ skipping 80 matching lines @@
 
   @override
   void set typeArguments(TypeArgumentList typeArguments) {
     _typeArguments = _becomeParentOf(typeArguments);
   }
 }
 
 /**
  * An is expression.
  *
- * > isExpression ::=
- * >     [Expression] 'is' '!'? [TypeName]
+ *    isExpression ::=
+ *        [Expression] 'is' '!'? [TypeName]
  */
 class IsExpressionImpl extends ExpressionImpl implements IsExpression {
   /**
    * The expression used to compute the value whose type is being tested.
    */
   Expression _expression;
 
   /**
    * The is operator.
    */
@@ skipping 57 matching lines @@
   @override
   void visitChildren(AstVisitor visitor) {
     _safelyVisitChild(_expression, visitor);
     _safelyVisitChild(_type, visitor);
   }
 }
 
 /**
  * A statement that has a label associated with them.
  *
- * > labeledStatement ::=
- * >    [Label]+ [Statement]
+ *    labeledStatement ::=
+ *       [Label]+ [Statement]
  */
 class LabeledStatementImpl extends StatementImpl implements LabeledStatement {
   /**
    * The labels being associated with the statement.
    */
   NodeList<Label> _labels;
 
   /**
    * The statement with which the labels are being associated.
    */
@@ skipping 43 matching lines @@
   @override
   void visitChildren(AstVisitor visitor) {
     _labels.accept(visitor);
     _safelyVisitChild(_statement, visitor);
   }
 }
 
 /**
  * A label on either a [LabeledStatement] or a [NamedExpression].
  *
- * > label ::=
- * >     [SimpleIdentifier] ':'
+ *    label ::=
+ *        [SimpleIdentifier] ':'
  */
 class LabelImpl extends AstNodeImpl implements Label {
   /**
    * The label being associated with the statement.
    */
   SimpleIdentifier _label;
 
   /**
    * The colon that separates the label from the statement.
    */
@@ skipping 28 matching lines @@
 
   @override
   void visitChildren(AstVisitor visitor) {
     _safelyVisitChild(_label, visitor);
   }
 }
 
 /**
  * A library directive.
  *
- * > libraryDirective ::=
- * >     [Annotation] 'library' [Identifier] ';'
+ *    libraryDirective ::=
+ *        [Annotation] 'library' [Identifier] ';'
  */
 class LibraryDirectiveImpl extends DirectiveImpl implements LibraryDirective {
   /**
    * The token representing the 'library' keyword.
    */
   Token libraryKeyword;
 
   /**
    * The name of the library being defined.
    */
@@ skipping 42 matching lines @@
   @override
   void visitChildren(AstVisitor visitor) {
     super.visitChildren(visitor);
     _safelyVisitChild(_name, visitor);
   }
 }
 
 /**
  * The identifier for a library.
  *
- * > libraryIdentifier ::=
- * >     [SimpleIdentifier] ('.' [SimpleIdentifier])*
+ *    libraryIdentifier ::=
+ *        [SimpleIdentifier] ('.' [SimpleIdentifier])*
  */
 class LibraryIdentifierImpl extends IdentifierImpl
     implements LibraryIdentifier {
   /**
    * The components of the identifier.
    */
   NodeList<SimpleIdentifier> _components;
 
   /**
    * Initialize a newly created prefixed identifier.
@@ skipping 47 matching lines @@
 
   @override
   void visitChildren(AstVisitor visitor) {
     _components.accept(visitor);
   }
 }
 
 /**
  * A list literal.
  *
- * > listLiteral ::=
- * >     'const'? ('<' [TypeName] '>')? '[' ([Expression] ','?)? ']'
+ *    listLiteral ::=
+ *        'const'? ('<' [TypeName] '>')? '[' ([Expression] ','?)? ']'
  */
 class ListLiteralImpl extends TypedLiteralImpl implements ListLiteral {
   /**
    * The left square bracket.
    */
   Token leftBracket;
 
   /**
    * The expressions used to compute the elements of the list.
    */
@@ skipping 47 matching lines @@
   @override
   void visitChildren(AstVisitor visitor) {
     super.visitChildren(visitor);
     _elements.accept(visitor);
   }
 }
 
 /**
  * A node that represents a literal expression.
  *
- * > literal ::=
- * >     [BooleanLiteral]
- * >   | [DoubleLiteral]
- * >   | [IntegerLiteral]
- * >   | [ListLiteral]
- * >   | [MapLiteral]
- * >   | [NullLiteral]
- * >   | [StringLiteral]
+ *    literal ::=
+ *        [BooleanLiteral]
+ *      | [DoubleLiteral]
+ *      | [IntegerLiteral]
+ *      | [ListLiteral]
+ *      | [MapLiteral]
+ *      | [NullLiteral]
+ *      | [StringLiteral]
  */
 abstract class LiteralImpl extends ExpressionImpl implements Literal {
   @override
   int get precedence => 16;
 }
 
 /**
  * Additional information about local variables within a function or method
  * produced at resolution time.
  */
 class LocalVariableInfo {
   /**
    * The set of local variables and parameters that are potentially mutated
    * within a local function other than the function in which they are declared.
    */
   final Set<VariableElement> potentiallyMutatedInClosure =
       new Set<VariableElement>();
 
   /**
    * The set of local variables and parameters that are potentiall mutated
    * within the scope of their declarations.
    */
   final Set<VariableElement> potentiallyMutatedInScope =
       new Set<VariableElement>();
 }
 
 /**
  * A single key/value pair in a map literal.
  *
- * > mapLiteralEntry ::=
- * >     [Expression] ':' [Expression]
+ *    mapLiteralEntry ::=
+ *        [Expression] ':' [Expression]
  */
 class MapLiteralEntryImpl extends AstNodeImpl implements MapLiteralEntry {
   /**
    * The expression computing the key with which the value will be associated.
    */
   Expression _key;
 
   /**
    * The colon that separates the key from the value.
    */
@@ skipping 44 matching lines @@
   @override
   void visitChildren(AstVisitor visitor) {
     _safelyVisitChild(_key, visitor);
     _safelyVisitChild(_value, visitor);
   }
 }
 
 /**
  * A literal map.
  *
- * > mapLiteral ::=
- * >     'const'? ('<' [TypeName] (',' [TypeName])* '>')?
- * >     '{' ([MapLiteralEntry] (',' [MapLiteralEntry])* ','?)? '}'
+ *    mapLiteral ::=
+ *        'const'? ('<' [TypeName] (',' [TypeName])* '>')?
+ *        '{' ([MapLiteralEntry] (',' [MapLiteralEntry])* ','?)? '}'
  */
 class MapLiteralImpl extends TypedLiteralImpl implements MapLiteral {
   /**
    * The left curly bracket.
    */
   Token leftBracket;
 
   /**
    * The entries in the map.
    */
@@ skipping 46 matching lines @@
   @override
   void visitChildren(AstVisitor visitor) {
     super.visitChildren(visitor);
     _entries.accept(visitor);
   }
 }
 
 /**
  * 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]
  */
 class MethodDeclarationImpl extends ClassMemberImpl
     implements MethodDeclaration {
   /**
    * The token for the 'external' keyword, or `null` if the constructor is not
    * external.
    */
   Token externalKeyword;
 
   /**
@@ skipping 189 matching lines @@
     _safelyVisitChild(_body, visitor);
   }
 }
 
 /**
  * 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]
  */
 class MethodInvocationImpl extends InvocationExpressionImpl
     implements MethodInvocation {
   /**
    * The expression producing the object on which the method is defined, or
    * `null` if there is no target (that is, the target is implicitly `this`).
    */
   Expression _target;
 
   /**
@@ skipping 124 matching lines @@
   @override
   void set name(SimpleIdentifier identifier) {
     _name = _becomeParentOf(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]
  */
 class NamedExpressionImpl extends ExpressionImpl implements NamedExpression {
   /**
    * The name associated with the expression.
    */
   Label _name;
 
   /**
    * The expression with which the name is associated.
    */
@@ skipping 51 matching lines @@
   @override
   void visitChildren(AstVisitor visitor) {
     _safelyVisitChild(_name, visitor);
     _safelyVisitChild(_expression, visitor);
   }
 }
 
 /**
  * A node that represents a directive that impacts the namespace of a library.
  *
- * > directive ::=
- * >     [ExportDirective]
- * >   | [ImportDirective]
+ *    directive ::=
+ *        [ExportDirective]
+ *      | [ImportDirective]
  */
 abstract class NamespaceDirectiveImpl extends UriBasedDirectiveImpl
     implements NamespaceDirective {
   /**
    * The token representing the 'import' or 'export' keyword.
    */
   Token keyword;
 
   /**
    * The configurations used to control which library will actually be loaded at
@@ skipping 42 matching lines @@
   @override
   Token get firstTokenAfterCommentAndMetadata => keyword;
 
   @override
   LibraryElement get uriElement;
 }
 
 /**
  * The "native" clause in an class declaration.
  *
- * > nativeClause ::=
- * >     'native' [StringLiteral]
+ *    nativeClause ::=
+ *        'native' [StringLiteral]
  */
 class NativeClauseImpl extends AstNodeImpl implements NativeClause {
   /**
    * The token representing the 'native' keyword.
    */
   Token nativeKeyword;
 
   /**
    * The name of the native object that implements the class.
    */
@@ skipping 30 matching lines @@
   @override
   void visitChildren(AstVisitor visitor) {
     _safelyVisitChild(_name, visitor);
   }
 }
 
 /**
  * A function body that consists of a native keyword followed by a string
  * literal.
  *
- * > nativeFunctionBody ::=
- * >     'native' [SimpleStringLiteral] ';'
+ *    nativeFunctionBody ::=
+ *        'native' [SimpleStringLiteral] ';'
  */
 class NativeFunctionBodyImpl extends FunctionBodyImpl
     implements NativeFunctionBody {
   /**
    * The token representing 'native' that marks the start of the function body.
    */
   Token nativeKeyword;
 
   /**
    * The string literal, after the 'native' token.
@@ skipping 160 matching lines @@
     }
     E removedNode = _elements[index];
     _elements.removeAt(index);
     return removedNode;
   }
 }
 
 /**
  * A formal parameter that is required (is not optional).
  *
- * > normalFormalParameter ::=
- * >     [FunctionTypedFormalParameter]
- * >   | [FieldFormalParameter]
- * >   | [SimpleFormalParameter]
+ *    normalFormalParameter ::=
+ *        [FunctionTypedFormalParameter]
+ *      | [FieldFormalParameter]
+ *      | [SimpleFormalParameter]
  */
 abstract class NormalFormalParameterImpl extends FormalParameterImpl
     implements NormalFormalParameter {
   /**
    * The documentation comment associated with this parameter, or `null` if this
    * parameter does not have a documentation comment associated with it.
    */
   Comment _comment;
 
   /**
@@ skipping 96 matching lines @@
       return true;
     }
     Annotation firstAnnotation = _metadata[0];
     return _comment.offset < firstAnnotation.offset;
   }
 }
 
 /**
  * A null literal expression.
  *
- * > nullLiteral ::=
- * >     'null'
+ *    nullLiteral ::=
+ *        'null'
  */
 class NullLiteralImpl extends LiteralImpl implements NullLiteral {
   /**
    * The token representing the literal.
    */
   Token literal;
 
   /**
    * Initialize a newly created null literal.
    */
@@ skipping 13 matching lines @@
 
   @override
   void visitChildren(AstVisitor visitor) {
     // There are no children to visit.
   }
 }
 
 /**
  * A parenthesized expression.
  *
- * > parenthesizedExpression ::=
- * >     '(' [Expression] ')'
+ *    parenthesizedExpression ::=
+ *        '(' [Expression] ')'
  */
 class ParenthesizedExpressionImpl extends ExpressionImpl
     implements ParenthesizedExpression {
   /**
    * The left parenthesis.
    */
   Token leftParenthesis;
 
   /**
    * The expression within the parentheses.
@@ skipping 41 matching lines @@
 
   @override
   void visitChildren(AstVisitor visitor) {
     _safelyVisitChild(_expression, visitor);
   }
 }
 
 /**
  * A part directive.
  *
- * > partDirective ::=
- * >     [Annotation] 'part' [StringLiteral] ';'
+ *    partDirective ::=
+ *        [Annotation] 'part' [StringLiteral] ';'
  */
 class PartDirectiveImpl extends UriBasedDirectiveImpl implements PartDirective {
   /**
    * The token representing the 'part' keyword.
    */
   Token partKeyword;
 
   /**
    * The semicolon terminating the directive.
    */
@@ skipping 24 matching lines @@
   @override
   CompilationUnitElement get uriElement => element as CompilationUnitElement;
 
   @override
   accept(AstVisitor visitor) => visitor.visitPartDirective(this);
 }
 
 /**
  * A part-of directive.
  *
- * > partOfDirective ::=
- * >     [Annotation] 'part' 'of' [Identifier] ';'
+ *    partOfDirective ::=
+ *        [Annotation] 'part' 'of' [Identifier] ';'
  */
 class PartOfDirectiveImpl extends DirectiveImpl implements PartOfDirective {
   /**
    * The token representing the 'part' keyword.
    */
   Token partKeyword;
 
   /**
    * The token representing the 'of' keyword.
    */
@@ skipping 55 matching lines @@
   @override
   void visitChildren(AstVisitor visitor) {
     super.visitChildren(visitor);
     _safelyVisitChild(_libraryName, visitor);
   }
 }
 
 /**
  * A postfix unary expression.
  *
- * > postfixExpression ::=
- * >     [Expression] [Token]
+ *    postfixExpression ::=
+ *        [Expression] [Token]
  */
 class PostfixExpressionImpl extends ExpressionImpl
     implements PostfixExpression {
   /**
    * The expression computing the operand for the operator.
    */
   Expression _operand;
 
   /**
    * The postfix operator being applied to the operand.
@@ skipping 92 matching lines @@
   @override
   void visitChildren(AstVisitor visitor) {
     _safelyVisitChild(_operand, visitor);
   }
 }
 
 /**
  * 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]
  */
 class PrefixedIdentifierImpl extends IdentifierImpl
     implements PrefixedIdentifier {
   /**
    * The prefix associated with the library in which the identifier is defined.
    */
   SimpleIdentifier _prefix;
 
   /**
    * The period used to separate the prefix from the identifier.
@@ skipping 91 matching lines @@
   @override
   void visitChildren(AstVisitor visitor) {
     _safelyVisitChild(_prefix, visitor);
     _safelyVisitChild(_identifier, visitor);
   }
 }
 
 /**
  * A prefix unary expression.
  *
- * > prefixExpression ::=
- * >     [Token] [Expression]
+ *    prefixExpression ::=
+ *        [Token] [Expression]
  */
 class PrefixExpressionImpl extends ExpressionImpl implements PrefixExpression {
   /**
    * The prefix operator being applied to the operand.
    */
   Token operator;
 
   /**
    * The expression computing the operand for the operator.
    */
@@ skipping 93 matching lines @@
   }
 }
 
 /**
  * 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]
  */
 class PropertyAccessImpl extends ExpressionImpl implements PropertyAccess {
   /**
    * The expression computing the object defining the property being accessed.
    */
   Expression _target;
 
   /**
    * The property access operator.
    */
@@ skipping 76 matching lines @@
   void visitChildren(AstVisitor visitor) {
     _safelyVisitChild(_target, visitor);
     _safelyVisitChild(_propertyName, visitor);
   }
 }
 
 /**
  * The invocation of a constructor in the same class from within a constructor's
  * initialization list.
  *
- * > redirectingConstructorInvocation ::=
- * >     'this' ('.' identifier)? arguments
+ *    redirectingConstructorInvocation ::=
+ *        'this' ('.' identifier)? arguments
  */
 class RedirectingConstructorInvocationImpl extends ConstructorInitializerImpl
     implements RedirectingConstructorInvocation {
   /**
    * The token for the 'this' keyword.
    */
   Token thisKeyword;
 
   /**
    * The token for the period before the name of the constructor that is being
@@ skipping 66 matching lines @@
   @override
   void visitChildren(AstVisitor visitor) {
     _safelyVisitChild(_constructorName, visitor);
     _safelyVisitChild(_argumentList, visitor);
   }
 }
 
 /**
  * A rethrow expression.
  *
- * > rethrowExpression ::=
- * >     'rethrow'
+ *    rethrowExpression ::=
+ *        'rethrow'
  */
 class RethrowExpressionImpl extends ExpressionImpl
     implements RethrowExpression {
   /**
    * The token representing the 'rethrow' keyword.
    */
   Token rethrowKeyword;
 
   /**
    * Initialize a newly created rethrow expression.
@@ skipping 17 matching lines @@
 
   @override
   void visitChildren(AstVisitor visitor) {
     // There are no children to visit.
   }
 }
 
 /**
  * A return statement.
  *
- * > returnStatement ::=
- * >     'return' [Expression]? ';'
+ *    returnStatement ::=
+ *        'return' [Expression]? ';'
  */
 class ReturnStatementImpl extends StatementImpl implements ReturnStatement {
   /**
    * The token representing the 'return' keyword.
    */
   Token returnKeyword;
 
   /**
    * The expression computing the value to be returned, or `null` if no explicit
    * value was provided.
@@ skipping 37 matching lines @@
 
   @override
   void visitChildren(AstVisitor visitor) {
     _safelyVisitChild(_expression, visitor);
   }
 }
 
 /**
  * A script tag that can optionally occur at the beginning of a compilation unit.
  *
- * > scriptTag ::=
- * >     '#!' (~NEWLINE)* NEWLINE
+ *    scriptTag ::=
+ *        '#!' (~NEWLINE)* NEWLINE
  */
 class ScriptTagImpl extends AstNodeImpl implements ScriptTag {
   /**
    * The token representing this script tag.
    */
   Token scriptTag;
 
   /**
    * Initialize a newly created script tag.
    */
@@ skipping 13 matching lines @@
 
   @override
   void visitChildren(AstVisitor visitor) {
     // There are no children to visit.
   }
 }
 
 /**
  * A combinator that restricts the names being imported to those in a given list.
  *
- * > showCombinator ::=
- * >     'show' [SimpleIdentifier] (',' [SimpleIdentifier])*
+ *    showCombinator ::=
+ *        'show' [SimpleIdentifier] (',' [SimpleIdentifier])*
  */
 class ShowCombinatorImpl extends CombinatorImpl implements ShowCombinator {
   /**
    * The list of names from the library that are made visible by this combinator.
    */
   NodeList<SimpleIdentifier> _shownNames;
 
   /**
    * Initialize a newly created import show combinator.
    */
@@ skipping 19 matching lines @@
 
   @override
   void visitChildren(AstVisitor visitor) {
     _shownNames.accept(visitor);
   }
 }
 
 /**
  * A simple formal parameter.
  *
- * > simpleFormalParameter ::=
- * >     ('final' [TypeName] | 'var' | [TypeName])? [SimpleIdentifier]
+ *    simpleFormalParameter ::=
+ *        ('final' [TypeName] | 'var' | [TypeName])? [SimpleIdentifier]
  */
 class SimpleFormalParameterImpl extends NormalFormalParameterImpl
     implements SimpleFormalParameter {
   /**
    * The token representing either the 'final', 'const' or 'var' keyword, or
    * `null` if no keyword was used.
    */
   Token keyword;
 
   /**
@@ skipping 59 matching lines @@
   void visitChildren(AstVisitor visitor) {
     super.visitChildren(visitor);
     _safelyVisitChild(_type, visitor);
     _safelyVisitChild(identifier, visitor);
   }
 }
 
 /**
  * A simple identifier.
  *
- * > simpleIdentifier ::=
- * >     initialCharacter internalCharacter*
- * >
- * > initialCharacter ::= '_' | '$' | letter
- * >
- * > internalCharacter ::= '_' | '$' | letter | digit
+ *    simpleIdentifier ::=
+ *        initialCharacter internalCharacter*
+ *
+ *    initialCharacter ::= '_' | '$' | letter
+ *
+ *    internalCharacter ::= '_' | '$' | letter | digit
  */
 class SimpleIdentifierImpl extends IdentifierImpl implements SimpleIdentifier {
   /**
    * The token representing the identifier.
    */
   Token token;
 
   /**
    * The element associated with this identifier based on static type
    * information, or `null` if the AST structure has not been resolved or if
@@ skipping 262 matching lines @@
       return _returnOrReportElement(
           parent, element is VariableElement, element);
     }
     return element;
   }
 }
 
 /**
  * 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 '"'
  */
 class SimpleStringLiteralImpl extends SingleStringLiteralImpl
     implements SimpleStringLiteral {
   /**
    * The token representing the literal.
    */
   Token literal;
 
   /**
    * The value of the literal.
@@ skipping 56 matching lines @@
 
   @override
   void _appendStringValue(StringBuffer buffer) {
     buffer.write(value);
   }
 }
 
 /**
  * A single string literal expression.
  *
- * > singleStringLiteral ::=
- * >     [SimpleStringLiteral]
- * >   | [StringInterpolation]
+ *    singleStringLiteral ::=
+ *        [SimpleStringLiteral]
+ *      | [StringInterpolation]
  */
 abstract class SingleStringLiteralImpl extends StringLiteralImpl
     implements SingleStringLiteral {}
 
 /**
  * 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]
  */
 abstract class StatementImpl extends AstNodeImpl implements Statement {
   @override
   Statement get unlabeled => this;
 }
 
 /**
  * A string interpolation literal.
  *
- * > stringInterpolation ::=
- * >     ''' [InterpolationElement]* '''
- * >   | '"' [InterpolationElement]* '"'
+ *    stringInterpolation ::=
+ *        ''' [InterpolationElement]* '''
+ *      | '"' [InterpolationElement]* '"'
  */
 class StringInterpolationImpl extends SingleStringLiteralImpl
     implements StringInterpolation {
   /**
    * The elements that will be composed to produce the resulting string.
    */
   NodeList<InterpolationElement> _elements;
 
   /**
    * Initialize a newly created string interpolation expression.
@@ skipping 148 matching lines @@
       }
       index++;
     }
     return start;
   }
 }
 
 /**
  * A string literal expression.
  *
- * > stringLiteral ::=
- * >     [SimpleStringLiteral]
- * >   | [AdjacentStrings]
- * >   | [StringInterpolation]
+ *    stringLiteral ::=
+ *        [SimpleStringLiteral]
+ *      | [AdjacentStrings]
+ *      | [StringInterpolation]
  */
 abstract class StringLiteralImpl extends LiteralImpl implements StringLiteral {
   @override
   String get stringValue {
     StringBuffer buffer = new StringBuffer();
     try {
       _appendStringValue(buffer);
     } on IllegalArgumentException {
       return null;
     }
     return buffer.toString();
   }
 
   /**
    * Append the value of this string literal to the given [buffer]. Throw an
    * [IllegalArgumentException] if the string is not a constant string without
    * any string interpolation.
    */
   void _appendStringValue(StringBuffer buffer);
 }
 
 /**
  * The invocation of a superclass' constructor from within a constructor's
  * initialization list.
  *
- * > superInvocation ::=
- * >     'super' ('.' [SimpleIdentifier])? [ArgumentList]
+ *    superInvocation ::=
+ *        'super' ('.' [SimpleIdentifier])? [ArgumentList]
  */
 class SuperConstructorInvocationImpl extends ConstructorInitializerImpl
     implements SuperConstructorInvocation {
   /**
    * The token for the 'super' keyword.
    */
   Token superKeyword;
 
   /**
    * The token for the period before the name of the constructor that is being
@@ skipping 66 matching lines @@
   @override
   void visitChildren(AstVisitor visitor) {
     _safelyVisitChild(_constructorName, visitor);
     _safelyVisitChild(_argumentList, visitor);
   }
 }
 
 /**
  * A super expression.
  *
- * > superExpression ::=
- * >     'super'
+ *    superExpression ::=
+ *        'super'
  */
 class SuperExpressionImpl extends ExpressionImpl implements SuperExpression {
   /**
    * The token representing the 'super' keyword.
    */
   Token superKeyword;
 
   /**
    * Initialize a newly created super expression.
    */
@@ skipping 16 matching lines @@
 
   @override
   void visitChildren(AstVisitor visitor) {
     // There are no children to visit.
   }
 }
 
 /**
  * A case in a switch statement.
  *
- * > switchCase ::=
- * >     [SimpleIdentifier]* 'case' [Expression] ':' [Statement]*
+ *    switchCase ::=
+ *        [SimpleIdentifier]* 'case' [Expression] ':' [Statement]*
  */
 class SwitchCaseImpl extends SwitchMemberImpl implements SwitchCase {
   /**
    * The expression controlling whether the statements will be executed.
    */
   Expression _expression;
 
   /**
    * Initialize a newly created switch case. The list of [labels] can be `null`
    * if there are no labels.
@@ skipping 27 matching lines @@
   void visitChildren(AstVisitor visitor) {
     labels.accept(visitor);
     _safelyVisitChild(_expression, visitor);
     statements.accept(visitor);
   }
 }
 
 /**
  * The default case in a switch statement.
  *
- * > switchDefault ::=
- * >     [SimpleIdentifier]* 'default' ':' [Statement]*
+ *    switchDefault ::=
+ *        [SimpleIdentifier]* 'default' ':' [Statement]*
  */
 class SwitchDefaultImpl extends SwitchMemberImpl implements SwitchDefault {
   /**
    * Initialize a newly created switch default. The list of [labels] can be
    * `null` if there are no labels.
    */
   SwitchDefaultImpl(List<Label> labels, Token keyword, Token colon,
       List<Statement> statements)
       : super(labels, keyword, colon, statements);
 
@@ skipping 10 matching lines @@
   @override
   void visitChildren(AstVisitor visitor) {
     labels.accept(visitor);
     statements.accept(visitor);
   }
 }
 
 /**
  * An element within a switch statement.
  *
- * > switchMember ::=
- * >     switchCase
- * >   | switchDefault
+ *    switchMember ::=
+ *        switchCase
+ *      | switchDefault
  */
 abstract class SwitchMemberImpl extends AstNodeImpl implements SwitchMember {
   /**
    * The labels associated with the switch member.
    */
   NodeList<Label> _labels;
 
   /**
    * The token representing the 'case' or 'default' keyword.
    */
@@ skipping 38 matching lines @@
   @override
   NodeList<Label> get labels => _labels;
 
   @override
   NodeList<Statement> get statements => _statements;
 }
 
 /**
  * A switch statement.
  *
- * > switchStatement ::=
- * >     'switch' '(' [Expression] ')' '{' [SwitchCase]* [SwitchDefault]? '}'
+ *    switchStatement ::=
+ *        'switch' '(' [Expression] ')' '{' [SwitchCase]* [SwitchDefault]? '}'
  */
 class SwitchStatementImpl extends StatementImpl implements SwitchStatement {
   /**
    * The token representing the 'switch' keyword.
    */
   Token switchKeyword;
 
   /**
    * The left parenthesis.
    */
@@ skipping 74 matching lines @@
   @override
   void visitChildren(AstVisitor visitor) {
     _safelyVisitChild(_expression, visitor);
     _members.accept(visitor);
   }
 }
 
 /**
  * A symbol literal expression.
  *
- * > symbolLiteral ::=
- * >     '#' (operator | (identifier ('.' identifier)*))
+ *    symbolLiteral ::=
+ *        '#' (operator | (identifier ('.' identifier)*))
  */
 class SymbolLiteralImpl extends LiteralImpl implements SymbolLiteral {
   /**
    * The token introducing the literal.
    */
   Token poundSign;
 
   /**
    * The components of the literal.
    */
@@ skipping 21 matching lines @@
 
   @override
   void visitChildren(AstVisitor visitor) {
     // There are no children to visit.
   }
 }
 
 /**
  * A this expression.
  *
- * > thisExpression ::=
- * >     'this'
+ *    thisExpression ::=
+ *        'this'
  */
 class ThisExpressionImpl extends ExpressionImpl implements ThisExpression {
   /**
    * The token representing the 'this' keyword.
    */
   Token thisKeyword;
 
   /**
    * Initialize a newly created this expression.
    */
@@ skipping 16 matching lines @@
 
   @override
   void visitChildren(AstVisitor visitor) {
     // There are no children to visit.
   }
 }
 
 /**
  * A throw expression.
  *
- * > throwExpression ::=
- * >     'throw' [Expression]
+ *    throwExpression ::=
+ *        'throw' [Expression]
  */
 class ThrowExpressionImpl extends ExpressionImpl implements ThrowExpression {
   /**
    * The token representing the 'throw' keyword.
    */
   Token throwKeyword;
 
   /**
    * The expression computing the exception to be thrown.
    */
@@ skipping 37 matching lines @@
 
   @override
   void visitChildren(AstVisitor visitor) {
     _safelyVisitChild(_expression, visitor);
   }
 }
 
 /**
  * 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 ';'
  */
 class TopLevelVariableDeclarationImpl extends CompilationUnitMemberImpl
     implements TopLevelVariableDeclaration {
   /**
    * The top-level variables being declared.
    */
   VariableDeclarationList _variableList;
 
   /**
    * The semicolon terminating the declaration.
@@ skipping 38 matching lines @@
   @override
   void visitChildren(AstVisitor visitor) {
     super.visitChildren(visitor);
     _safelyVisitChild(_variableList, visitor);
   }
 }
 
 /**
  * A try statement.
  *
- * > tryStatement ::=
- * >     'try' [Block] ([CatchClause]+ finallyClause? | finallyClause)
- * >
- * > finallyClause ::=
- * >     'finally' [Block]
+ *    tryStatement ::=
+ *        'try' [Block] ([CatchClause]+ finallyClause? | finallyClause)
+ *
+ *    finallyClause ::=
+ *        'finally' [Block]
  */
 class TryStatementImpl extends StatementImpl implements TryStatement {
   /**
    * The token representing the 'try' keyword.
    */
   Token tryKeyword;
 
   /**
    * The body of the statement.
    */
@@ skipping 77 matching lines @@
   void visitChildren(AstVisitor visitor) {
     _safelyVisitChild(_body, visitor);
     _catchClauses.accept(visitor);
     _safelyVisitChild(_finallyBlock, visitor);
   }
 }
 
 /**
  * The declaration of a type alias.
  *
- * > typeAlias ::=
- * >     'typedef' typeAliasBody
- * >
- * > typeAliasBody ::=
- * >     classTypeAlias
- * >   | functionTypeAlias
+ *    typeAlias ::=
+ *        'typedef' typeAliasBody
+ *
+ *    typeAliasBody ::=
+ *        classTypeAlias
+ *      | functionTypeAlias
  */
 abstract class TypeAliasImpl extends NamedCompilationUnitMemberImpl
     implements TypeAlias {
   /**
    * The token representing the 'typedef' keyword.
    */
   Token typedefKeyword;
 
   /**
    * The semicolon terminating the declaration.
@@ skipping 12 matching lines @@
   @override
   Token get endToken => semicolon;
 
   @override
   Token get firstTokenAfterCommentAndMetadata => typedefKeyword;
 }
 
 /**
  * A list of type arguments.
  *
- * > typeArguments ::=
- * >     '<' typeName (',' typeName)* '>'
+ *    typeArguments ::=
+ *        '<' typeName (',' typeName)* '>'
  */
 class TypeArgumentListImpl extends AstNodeImpl implements TypeArgumentList {
   /**
    * The left bracket.
    */
   Token leftBracket;
 
   /**
    * The type arguments associated with the type.
    */
@@ skipping 33 matching lines @@
 
   @override
   void visitChildren(AstVisitor visitor) {
     _arguments.accept(visitor);
   }
 }
 
 /**
  * A literal that has a type associated with it.
  *
- * > typedLiteral ::=
- * >     [ListLiteral]
- * >   | [MapLiteral]
+ *    typedLiteral ::=
+ *        [ListLiteral]
+ *      | [MapLiteral]
  */
 abstract class TypedLiteralImpl extends LiteralImpl implements TypedLiteral {
   /**
    * The token representing the 'const' keyword, or `null` if the literal is not
    * a constant.
    */
   Token constKeyword;
 
   /**
    * The type argument associated with this literal, or `null` if no type
@@ skipping 23 matching lines @@
 
   @override
   void visitChildren(AstVisitor visitor) {
     _safelyVisitChild(_typeArguments, visitor);
   }
 }
 
 /**
  * The name of a type, which can optionally include type arguments.
  *
- * > typeName ::=
- * >     [Identifier] typeArguments?
+ *    typeName ::=
+ *        [Identifier] typeArguments?
  */
 class TypeNameImpl extends AstNodeImpl implements TypeName {
   /**
    * The name of the type.
    */
   Identifier _name;
 
   /**
    * The type arguments associated with the type, or `null` if there are no type
    * arguments.
@@ skipping 63 matching lines @@
   @override
   void visitChildren(AstVisitor visitor) {
     _safelyVisitChild(_name, visitor);
     _safelyVisitChild(_typeArguments, visitor);
   }
 }
 
 /**
  * A type parameter.
  *
- * > typeParameter ::=
- * >     [SimpleIdentifier] ('extends' [TypeName])?
+ *    typeParameter ::=
+ *        [SimpleIdentifier] ('extends' [TypeName])?
  */
 class TypeParameterImpl extends DeclarationImpl implements TypeParameter {
   /**
    * The name of the type parameter.
    */
   SimpleIdentifier _name;
 
   /**
    * The token representing the 'extends' keyword, or `null` if there is no
    * explicit upper bound.
@@ skipping 61 matching lines @@
   void visitChildren(AstVisitor visitor) {
     super.visitChildren(visitor);
     _safelyVisitChild(_name, visitor);
     _safelyVisitChild(_bound, visitor);
   }
 }
 
 /**
  * Type parameters within a declaration.
  *
- * > typeParameterList ::=
- * >     '<' [TypeParameter] (',' [TypeParameter])* '>'
+ *    typeParameterList ::=
+ *        '<' [TypeParameter] (',' [TypeParameter])* '>'
  */
 class TypeParameterListImpl extends AstNodeImpl implements TypeParameterList {
   /**
    * The left angle bracket.
    */
   final Token leftBracket;
 
   /**
    * The type parameters in the list.
    */
@@ skipping 32 matching lines @@
 
   @override
   void visitChildren(AstVisitor visitor) {
     _typeParameters.accept(visitor);
   }
 }
 
 /**
  * A directive that references a URI.
  *
- * > uriBasedDirective ::=
- * >     [ExportDirective]
- * >   | [ImportDirective]
- * >   | [PartDirective]
+ *    uriBasedDirective ::=
+ *        [ExportDirective]
+ *      | [ImportDirective]
+ *      | [PartDirective]
  */
 abstract class UriBasedDirectiveImpl extends DirectiveImpl
     implements UriBasedDirective {
   /**
    * The prefix of a URI using the `dart-ext` scheme to reference a native code
    * library.
    */
   static String _DART_EXT_SCHEME = "dart-ext:";
 
   /**
@@ skipping 82 matching lines @@
   const UriValidationCodeImpl(this.name);
 
   @override
   String toString() => name;
 }
 
 /**
  * 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].
  */
 class VariableDeclarationImpl extends DeclarationImpl
     implements VariableDeclaration {
   /**
    * The name of the variable being declared.
@@ skipping 96 matching lines @@
   void visitChildren(AstVisitor visitor) {
     super.visitChildren(visitor);
     _safelyVisitChild(_name, visitor);
     _safelyVisitChild(_initializer, visitor);
   }
 }
 
 /**
  * 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]
  */
 class VariableDeclarationListImpl extends AnnotatedNodeImpl
     implements VariableDeclarationList {
   /**
    * The token representing the 'final', 'const' or 'var' keyword, or `null` if
    * no keyword was included.
    */
   Token keyword;
 
   /**
@@ skipping 68 matching lines @@
     super.visitChildren(visitor);
     _safelyVisitChild(_type, visitor);
     _variables.accept(visitor);
   }
 }
 
 /**
  * A list of variables that are being declared in a context where a statement is
  * required.
  *
- * > variableDeclarationStatement ::=
- * >     [VariableDeclarationList] ';'
+ *    variableDeclarationStatement ::=
+ *        [VariableDeclarationList] ';'
  */
 class VariableDeclarationStatementImpl extends StatementImpl
     implements VariableDeclarationStatement {
   /**
    * The variables being declared.
    */
   VariableDeclarationList _variableList;
 
   /**
    * The semicolon terminating the statement.
@@ skipping 31 matching lines @@
 
   @override
   void visitChildren(AstVisitor visitor) {
     _safelyVisitChild(_variableList, visitor);
   }
 }
 
 /**
  * A while statement.
  *
- * > whileStatement ::=
- * >     'while' '(' [Expression] ')' [Statement]
+ *    whileStatement ::=
+ *        'while' '(' [Expression] ')' [Statement]
  */
 class WhileStatementImpl extends StatementImpl implements WhileStatement {
   /**
    * The token representing the 'while' keyword.
    */
   Token whileKeyword;
 
   /**
    * The left parenthesis.
    */
@@ skipping 59 matching lines @@
   @override
   void visitChildren(AstVisitor visitor) {
     _safelyVisitChild(_condition, visitor);
     _safelyVisitChild(_body, visitor);
   }
 }
 
 /**
  * The with clause in a class declaration.
  *
- * > withClause ::=
- * >     'with' [TypeName] (',' [TypeName])*
+ *    withClause ::=
+ *        'with' [TypeName] (',' [TypeName])*
  */
 class WithClauseImpl extends AstNodeImpl implements WithClause {
   /**
    * The token representing the 'with' keyword.
    */
   Token withKeyword;
 
   /**
    * The names of the mixins that were specified.
    */
@@ skipping 26 matching lines @@
 
   @override
   void visitChildren(AstVisitor visitor) {
     _mixinTypes.accept(visitor);
   }
 }
 
 /**
  * A yield statement.
  *
- * > yieldStatement ::=
- * >     'yield' '*'? [Expression] ‘;’
+ *    yieldStatement ::=
+ *        'yield' '*'? [Expression] ‘;’
  */
 class YieldStatementImpl extends StatementImpl implements YieldStatement {
   /**
    * The 'yield' keyword.
    */
   Token yieldKeyword;
 
   /**
    * The star optionally following the 'yield' keyword.
    */
@@ skipping 50 matching lines @@
   }
 
   @override
   accept(AstVisitor visitor) => visitor.visitYieldStatement(this);
 
   @override
   void visitChildren(AstVisitor visitor) {
     _safelyVisitChild(_expression, visitor);
   }
 }