New analyzer_experimental snapshot.

pkg/analyzer_experimental/lib/src/generated/ast.dart

 // This code was auto-generated, is not intended to be edited, and is subject to
 // significant change. Please see the README file for more information.
 library engine.ast;
 import 'dart:collection';
 import 'java_core.dart';
 import 'java_engine.dart';
 import 'error.dart';
 import 'source.dart' show LineInfo;
 import 'scanner.dart';
 import 'engine.dart' show AnalysisEngine;
 import 'utilities_dart.dart';
 import 'element.dart';
 /**
- * The abstract class {@code ASTNode} defines the behavior common to all nodes in the AST structure
+ * The abstract class `ASTNode` defines the behavior common to all nodes in the AST structure
  * for a Dart program.
  * @coverage dart.engine.ast
  */
 abstract class ASTNode {
 
   /**
-   * The parent of the node, or {@code null} if the node is the root of an AST structure.
+   * The parent of the node, or `null` if the node is the root of an AST structure.
    */
   ASTNode _parent;
 
   /**
-   * A table mapping the names of properties to their values, or {@code null} if this node does not
+   * A table mapping the names of properties to their values, or `null` if this node does not
    * have any properties associated with it.
    */
   Map<String, Object> _propertyMap;
 
   /**
-   * A comparator that can be used to sort AST nodes in lexical order. In other words,{@code compare} will return a negative value if the offset of the first node is less than the
+   * A comparator that can be used to sort AST nodes in lexical order. In other words,`compare` will return a negative value if the offset of the first node is less than the
    * offset of the second node, zero (0) if the nodes have the same offset, and a positive value if
    * if the offset of the first node is greater than the offset of the second node.
    */
   static Comparator<ASTNode> LEXICAL_ORDER = (ASTNode first, ASTNode second) => second.offset - first.offset;
 
   /**
    * Use the given visitor to visit this node.
    * @param visitor the visitor that will visit this node
    * @return the value returned by the visitor as a result of visiting this node
    */
   accept(ASTVisitor visitor);
 
   /**
-   * @return the {@link ASTNode} of given {@link Class} which is {@link ASTNode} itself, or one of
+   * @return the [ASTNode] of given [Class] which is [ASTNode] itself, or one of
    * its parents.
    */
   ASTNode getAncestor(Type enclosingClass) {
     ASTNode node = this;
     while (node != null && !isInstanceOf(node, enclosingClass)) {
       node = node.parent;
     }
     ;
     return node as ASTNode;
   }
 
   /**
    * Return the first token included in this node's source range.
    * @return the first token included in this node's source range
    */
   Token get beginToken;
 
   /**
    * Return the offset of the character immediately following the last character of this node's
-   * source range. This is equivalent to {@code node.getOffset() + node.getLength()}. For a
+   * source range. This is equivalent to `node.getOffset() + node.getLength()`. For a
    * compilation unit this will be equal to the length of the unit's source. For synthetic nodes
    * this will be equivalent to the node's offset (because the length is zero (0) by definition).
    * @return the offset of the character just past the node's source range
    */
   int get end => offset + length;
 
   /**
    * Return the last token included in this node's source range.
    * @return the last token included in this node's source range
    */
@@ skipping 20 matching lines @@
    */
   int get offset {
     Token beginToken = this.beginToken;
     if (beginToken == null) {
       return -1;
     }
     return beginToken.offset;
   }
 
   /**
-   * Return this node's parent node, or {@code null} if this node is the root of an AST structure.
-   * <p>
+   * Return this node's parent node, or `null` if this node is the root of an AST structure.
+   *
    * Note that the relationship between an AST node and its parent node may change over the lifetime
    * of a node.
-   * @return the parent of this node, or {@code null} if none
+   * @return the parent of this node, or `null` if none
    */
   ASTNode get parent => _parent;
 
   /**
-   * Return the value of the property with the given name, or {@code null} if this node does not
+   * Return the value of the property with the given name, or `null` if this node does not
    * have a property with the given name.
    * @return the value of the property with the given name
    */
   Object getProperty(String propertyName) {
     if (_propertyMap == null) {
       return null;
     }
     return _propertyMap[propertyName];
   }
 
   /**
    * Return the node at the root of this node's AST structure. Note that this method's performance
    * is linear with respect to the depth of the node in the AST structure (O(depth)).
    * @return the node at the root of this node's AST structure
    */
   ASTNode get root {
     ASTNode root = this;
     ASTNode parent = this.parent;
     while (parent != null) {
       root = parent;
       parent = root.parent;
     }
     return root;
   }
 
   /**
-   * Return {@code true} if this node is a synthetic node. A synthetic node is a node that was
+   * Return `true` if this node is a synthetic node. A synthetic node is a node that was
    * introduced by the parser in order to recover from an error in the code. Synthetic nodes always
-   * have a length of zero ({@code 0}).
-   * @return {@code true} if this node is a synthetic node
+   * have a length of zero (`0`).
+   * @return `true` if this node is a synthetic node
    */
   bool isSynthetic() => false;
 
   /**
-   * Set the value of the property with the given name to the given value. If the value is{@code null}, the property will effectively be removed.
+   * Set the value of the property with the given name to the given value. If the value is`null`, the property will effectively be removed.
    * @param propertyName the name of the property whose value is to be set
    * @param propertyValue the new value of the property
    */
   void setProperty(String propertyName, Object propertyValue) {
     if (propertyValue == null) {
       if (_propertyMap != null) {
         _propertyMap.remove(propertyName);
         if (_propertyMap.isEmpty) {
           _propertyMap = null;
         }
@@ skipping 32 matching lines @@
    */
   ASTNode becomeParentOf(ASTNode child) {
     if (child != null) {
       ASTNode node = child;
       node.parent = this;
     }
     return child;
   }
 
   /**
-   * If the given child is not {@code null}, use the given visitor to visit it.
+   * If the given child is not `null`, use the given visitor to visit it.
    * @param child the child to be visited
    * @param visitor the visitor that will be used to visit the child
    */
   void safelyVisitChild(ASTNode child, ASTVisitor<Object> visitor) {
     if (child != null) {
       child.accept(visitor);
     }
   }
 
   /**
    * Set the parent of this node to the given node.
    * @param newParent the node that is to be made the parent of this node
    */
   void set parent(ASTNode newParent) {
     _parent = newParent;
   }
   static int _hashCodeGenerator = 0;
   final int hashCode = ++_hashCodeGenerator;
 }
 /**
- * The interface {@code ASTVisitor} defines the behavior of objects that can be used to visit an AST
+ * The interface `ASTVisitor` defines the behavior of objects that can be used to visit an AST
  * structure.
  * @coverage dart.engine.ast
  */
 abstract class ASTVisitor<R> {
   R visitAdjacentStrings(AdjacentStrings node);
   R visitAnnotation(Annotation node);
   R visitArgumentDefinitionTest(ArgumentDefinitionTest node);
   R visitArgumentList(ArgumentList node);
   R visitAsExpression(AsExpression node);
   R visitAssertStatement(AssertStatement assertStatement);
@@ skipping 87 matching lines @@
   R visitTypeName(TypeName node);
   R visitTypeParameter(TypeParameter node);
   R visitTypeParameterList(TypeParameterList node);
   R visitVariableDeclaration(VariableDeclaration node);
   R visitVariableDeclarationList(VariableDeclarationList node);
   R visitVariableDeclarationStatement(VariableDeclarationStatement node);
   R visitWhileStatement(WhileStatement node);
   R visitWithClause(WithClause node);
 }
 /**
- * Instances of the class {@code AdjacentStrings} represents two or more string literals that are
+ * Instances of the class `AdjacentStrings` represents two or more string literals that are
  * implicitly concatenated because of being adjacent (separated only by whitespace).
- * <p>
+ *
  * 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.
  * <pre>
- * adjacentStrings ::={@link StringLiteral string} {@link StringLiteral string}+
+ * adjacentStrings ::=[StringLiteral string] [StringLiteral string]+
  * </pre>
  * @coverage dart.engine.ast
  */
 class AdjacentStrings extends StringLiteral {
 
   /**
    * The strings that are implicitly concatenated.
    */
   NodeList<StringLiteral> _strings;
 
@@ skipping 23 matching lines @@
   void visitChildren(ASTVisitor<Object> visitor) {
     _strings.accept(visitor);
   }
   void appendStringValue(JavaStringBuilder builder) {
     for (StringLiteral stringLiteral in strings) {
       stringLiteral.appendStringValue(builder);
     }
   }
 }
 /**
- * The abstract class {@code AnnotatedNode} defines the behavior of nodes that can be annotated with
+ * The abstract class `AnnotatedNode` defines the behavior of nodes that can be annotated with
  * both a comment and metadata.
  * @coverage dart.engine.ast
  */
 abstract class AnnotatedNode extends ASTNode {
 
   /**
-   * The documentation comment associated with this node, or {@code null} if this node does not have
+   * The documentation comment associated with this node, or `null` if this node does not have
    * a documentation comment associated with it.
    */
   Comment _comment;
 
   /**
    * The annotations associated with this node.
    */
   NodeList<Annotation> _metadata;
 
   /**
@@ skipping 25 matching lines @@
     }
     Token commentToken = _comment.beginToken;
     Token metadataToken = _metadata.beginToken;
     if (commentToken.offset < metadataToken.offset) {
       return commentToken;
     }
     return metadataToken;
   }
 
   /**
-   * Return the documentation comment associated with this node, or {@code null} if this node does
+   * Return the documentation comment associated with this node, or `null` if this node does
    * not have a documentation comment associated with it.
    * @return the documentation comment associated with this node
    */
   Comment get documentationComment => _comment;
 
   /**
    * Return the annotations associated with this node.
    * @return the annotations associated with this node
    */
   NodeList<Annotation> get metadata => _metadata;
@@ skipping 25 matching lines @@
     }
   }
 
   /**
    * Return the first token following the comment and metadata.
    * @return the first token following the comment and metadata
    */
   Token get firstTokenAfterCommentAndMetadata;
 
   /**
-   * Return {@code true} if the comment is lexically before any annotations.
-   * @return {@code true} if the comment is lexically before any annotations
+   * Return `true` if the comment is lexically before any annotations.
+   * @return `true` if the comment is lexically before any annotations
    */
   bool commentIsBeforeAnnotations() {
     if (_comment == null || _metadata.isEmpty) {
       return true;
     }
     Annotation firstAnnotation = _metadata[0];
     return _comment.offset < firstAnnotation.offset;
   }
 
   /**
    * Return an array containing the comment and annotations associated with this node, sorted in
    * lexical order.
    * @return the comment and annotations associated with this node in the order in which they
    * appeared in the original source
    */
   List<ASTNode> get sortedCommentAndAnnotations {
     List<ASTNode> childList = new List<ASTNode>();
     childList.add(_comment);
     childList.addAll(_metadata);
     List<ASTNode> children = new List.from(childList);
     children.sort(ASTNode.LEXICAL_ORDER);
     return children;
   }
 }
 /**
- * Instances of the class {@code Annotation} represent an annotation that can be associated with an
+ * Instances of the class `Annotation` represent an annotation that can be associated with an
  * AST node.
  * <pre>
  * metadata ::=
  * annotation
  * annotation ::=
- * '@' {@link Identifier qualified} ('.' {@link SimpleIdentifier identifier})? {@link ArgumentList arguments}?
+ * '@' [Identifier qualified] ('.' [SimpleIdentifier identifier])? [ArgumentList arguments]?
  * </pre>
  * @coverage dart.engine.ast
  */
 class Annotation extends ASTNode {
 
   /**
    * 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.
    */
   Identifier _name;
 
   /**
-   * The period before the constructor name, or {@code null} if this annotation is not the
+   * The period before the constructor name, or `null` if this annotation is not the
    * invocation of a named constructor.
    */
   Token _period;
 
   /**
-   * The name of the constructor being invoked, or {@code null} if this annotation is not the
+   * The name of the constructor being invoked, or `null` if this annotation is not the
    * invocation of a named constructor.
    */
   SimpleIdentifier _constructorName;
 
   /**
-   * The arguments to the constructor being invoked, or {@code null} if this annotation is not the
+   * The arguments to the constructor being invoked, or `null` if this annotation is not the
    * invocation of a constructor.
    */
   ArgumentList _arguments;
 
   /**
    * Initialize a newly created annotation.
    * @param atSign the at sign that introduced the annotation
    * @param name the name of the class defining the constructor that is being invoked or the name of
    * the field that is being referenced
-   * @param period the period before the constructor name, or {@code null} if this annotation is not
+   * @param period the period before the constructor name, or `null` if this annotation is not
    * the invocation of a named constructor
-   * @param constructorName the name of the constructor being invoked, or {@code null} if this
+   * @param constructorName the name of the constructor being invoked, or `null` if this
    * annotation is not the invocation of a named constructor
-   * @param arguments the arguments to the constructor being invoked, or {@code null} if this
+   * @param arguments the arguments to the constructor being invoked, or `null` if this
    * annotation is not the invocation of a constructor
    */
   Annotation.full(Token atSign, Identifier name, Token period, SimpleIdentifier constructorName, ArgumentList arguments) {
     this._atSign = atSign;
     this._name = becomeParentOf(name);
     this._period = period;
     this._constructorName = becomeParentOf(constructorName);
     this._arguments = becomeParentOf(arguments);
   }
 
   /**
    * Initialize a newly created annotation.
    * @param atSign the at sign that introduced the annotation
    * @param name the name of the class defining the constructor that is being invoked or the name of
    * the field that is being referenced
-   * @param period the period before the constructor name, or {@code null} if this annotation is not
+   * @param period the period before the constructor name, or `null` if this annotation is not
    * the invocation of a named constructor
-   * @param constructorName the name of the constructor being invoked, or {@code null} if this
+   * @param constructorName the name of the constructor being invoked, or `null` if this
    * annotation is not the invocation of a named constructor
-   * @param arguments the arguments to the constructor being invoked, or {@code null} if this
+   * @param arguments the arguments to the constructor being invoked, or `null` if this
    * annotation is not the invocation of a constructor
    */
   Annotation({Token atSign, Identifier name, Token period, SimpleIdentifier constructorName, ArgumentList arguments}) : this.full(atSign, name, period, constructorName, arguments);
   accept(ASTVisitor visitor) => visitor.visitAnnotation(this);
 
   /**
-   * Return the arguments to the constructor being invoked, or {@code null} if this annotation is
+   * Return the arguments to the constructor being invoked, or `null` if this annotation is
    * not the invocation of a constructor.
    * @return the arguments to the constructor being invoked
    */
   ArgumentList get arguments => _arguments;
 
   /**
    * Return the at sign that introduced the annotation.
    * @return the at sign that introduced the annotation
    */
   Token get atSign => _atSign;
   Token get beginToken => _atSign;
 
   /**
-   * Return the name of the constructor being invoked, or {@code null} if this annotation is not the
+   * Return the name of the constructor being invoked, or `null` if this annotation is not the
    * invocation of a named constructor.
    * @return the name of the constructor being invoked
    */
   SimpleIdentifier get constructorName => _constructorName;
 
   /**
-   * Return the element associated with this annotation, or {@code null} if the AST structure has
+   * Return the element associated with this annotation, or `null` if the AST structure has
    * not been resolved or if this annotation could not be resolved.
    * @return the element associated with this annotation
    */
   Element get element {
     if (_constructorName != null) {
       return _constructorName.element;
     } else if (_name != null) {
       return _name.element;
     }
     return null;
   }
   Token get endToken {
     if (_arguments != null) {
       return _arguments.endToken;
     } else if (_constructorName != null) {
       return _constructorName.endToken;
     }
     return _name.endToken;
   }
 
   /**
    * Return the name of the class defining the constructor that is being invoked or the name of the
    * field that is being referenced.
    * @return the name of the constructor being invoked or the name of the field being referenced
    */
   Identifier get name => _name;
 
   /**
-   * Return the period before the constructor name, or {@code null} if this annotation is not the
+   * Return the period before the constructor name, or `null` if this annotation is not the
    * invocation of a named constructor.
    * @return the period before the constructor name
    */
   Token get period => _period;
 
   /**
    * Set the arguments to the constructor being invoked to the given arguments.
    * @param arguments the arguments to the constructor being invoked
    */
   void set arguments(ArgumentList arguments2) {
@@ skipping 32 matching lines @@
   void set period(Token period2) {
     this._period = period2;
   }
   void visitChildren(ASTVisitor<Object> visitor) {
     safelyVisitChild(_name, visitor);
     safelyVisitChild(_constructorName, visitor);
     safelyVisitChild(_arguments, visitor);
   }
 }
 /**
- * Instances of the class {@code ArgumentDefinitionTest} represent an argument definition test.
+ * Instances of the class `ArgumentDefinitionTest` represent an argument definition test.
  * <pre>
  * argumentDefinitionTest ::=
- * '?' {@link SimpleIdentifier identifier}</pre>
+ * '?' [SimpleIdentifier identifier]</pre>
  * @coverage dart.engine.ast
  */
 class ArgumentDefinitionTest extends Expression {
 
   /**
    * The token representing the question mark.
    */
   Token _question;
 
   /**
@@ skipping 46 matching lines @@
    * @param question the token representing the question mark
    */
   void set question(Token question2) {
     this._question = question2;
   }
   void visitChildren(ASTVisitor<Object> visitor) {
     safelyVisitChild(_identifier, visitor);
   }
 }
 /**
- * Instances of the class {@code ArgumentList} represent a list of arguments in the invocation of a
+ * Instances of the class `ArgumentList` represent a list of arguments in the invocation of a
  * executable element: a function, method, or constructor.
  * <pre>
  * argumentList ::=
  * '(' arguments? ')'
- * arguments ::={@link NamedExpression namedArgument} (',' {@link NamedExpression namedArgument})
- * | {@link Expression expressionList} (',' {@link NamedExpression namedArgument})
+ * arguments ::=[NamedExpression namedArgument] (',' [NamedExpression namedArgument])
+ * | [Expression expressionList] (',' [NamedExpression namedArgument])
  * </pre>
  * @coverage dart.engine.ast
  */
 class ArgumentList extends ASTNode {
 
   /**
    * The left parenthesis.
    */
   Token _leftParenthesis;
 
   /**
    * The expressions producing the values of the arguments.
    */
   NodeList<Expression> _arguments;
 
   /**
    * The right parenthesis.
    */
   Token _rightParenthesis;
 
   /**
    * An array containing the elements representing the parameters corresponding to each of the
-   * arguments in this list, or {@code null} if the AST has not been resolved or if the function or
+   * arguments in this list, or `null` if the AST has not been resolved or if the function or
    * method being invoked could not be determined based on static type information. The array must
-   * be the same length as the number of arguments, but can contain {@code null} entries if a given
+   * be the same length as the number of arguments, but can contain `null` entries if a given
    * argument does not correspond to a formal parameter.
    */
   List<ParameterElement> _correspondingStaticParameters;
 
   /**
    * An array containing the elements representing the parameters corresponding to each of the
-   * arguments in this list, or {@code null} if the AST has not been resolved or if the function or
+   * arguments in this list, or `null` if the AST has not been resolved or if the function or
    * method being invoked could not be determined based on propagated type information. The array
-   * must be the same length as the number of arguments, but can contain {@code null} entries if a
+   * must be the same length as the number of arguments, but can contain `null` entries if a
    * given argument does not correspond to a formal parameter.
    */
   List<ParameterElement> _correspondingPropagatedParameters;
 
   /**
    * Initialize a newly created list of arguments.
    * @param leftParenthesis the left parenthesis
    * @param arguments the expressions producing the values of the arguments
    * @param rightParenthesis the right parenthesis
    */
@@ skipping 31 matching lines @@
 
   /**
    * Return the right parenthesis.
    * @return the right parenthesis
    */
   Token get rightParenthesis => _rightParenthesis;
 
   /**
    * Set the parameter elements corresponding to each of the arguments in this list to the given
    * array of parameters. The array of parameters must be the same length as the number of
-   * arguments, but can contain {@code null} entries if a given argument does not correspond to a
+   * arguments, but can contain `null` entries if a given argument does not correspond to a
    * formal parameter.
    * @param parameters the parameter elements corresponding to the arguments
    */
   void set correspondingParameters(List<ParameterElement> parameters) {
     if (parameters.length != _arguments.length) {
       throw new IllegalArgumentException("Expected ${_arguments.length} parameters, not ${parameters.length}");
     }
     _correspondingPropagatedParameters = parameters;
   }
 
   /**
    * Set the parameter elements corresponding to each of the arguments in this list to the given
    * array of parameters. The array of parameters must be the same length as the number of
-   * arguments, but can contain {@code null} entries if a given argument does not correspond to a
+   * arguments, but can contain `null` entries if a given argument does not correspond to a
    * formal parameter.
    * @param parameters the parameter elements corresponding to the arguments
    */
   void set correspondingStaticParameters(List<ParameterElement> parameters) {
     if (parameters.length != _arguments.length) {
       throw new IllegalArgumentException("Expected ${_arguments.length} parameters, not ${parameters.length}");
     }
     _correspondingStaticParameters = parameters;
   }
 
@@ skipping 14 matching lines @@
   }
   void visitChildren(ASTVisitor<Object> visitor) {
     _arguments.accept(visitor);
   }
 
   /**
    * If the given expression is a child of this list, and the AST structure has been resolved, and
    * the function being invoked is known based on propagated type information, and the expression
    * corresponds to one of the parameters of the function being invoked, then return the parameter
    * element representing the parameter to which the value of the given expression will be bound.
-   * Otherwise, return {@code null}.
-   * <p>
-   * This method is only intended to be used by {@link Expression#getParameterElement()}.
+   * Otherwise, return `null`.
+   *
+   * This method is only intended to be used by [Expression#getParameterElement].
    * @param expression the expression corresponding to the parameter to be returned
    * @return the parameter element representing the parameter to which the value of the expression
    * will be bound
    */
   ParameterElement getPropagatedParameterElementFor(Expression expression) {
     if (_correspondingPropagatedParameters == null) {
       return null;
     }
     int index = _arguments.indexOf(expression);
     if (index < 0) {
       return null;
     }
     return _correspondingPropagatedParameters[index];
   }
 
   /**
    * If the given expression is a child of this list, and the AST structure has been resolved, and
    * the function being invoked is known based on static type information, and the expression
    * corresponds to one of the parameters of the function being invoked, then return the parameter
    * element representing the parameter to which the value of the given expression will be bound.
-   * Otherwise, return {@code null}.
-   * <p>
-   * This method is only intended to be used by {@link Expression#getStaticParameterElement()}.
+   * Otherwise, return `null`.
+   *
+   * This method is only intended to be used by [Expression#getStaticParameterElement].
    * @param expression the expression corresponding to the parameter to be returned
    * @return the parameter element representing the parameter to which the value of the expression
    * will be bound
    */
   ParameterElement getStaticParameterElementFor(Expression expression) {
     if (_correspondingStaticParameters == null) {
       return null;
     }
     int index = _arguments.indexOf(expression);
     if (index < 0) {
       return null;
     }
     return _correspondingStaticParameters[index];
   }
 }
 /**
- * Instances of the class {@code AsExpression} represent an 'as' expression.
+ * Instances of the class `AsExpression` represent an 'as' expression.
  * <pre>
- * asExpression ::={@link Expression expression} 'as' {@link TypeName type}</pre>
+ * asExpression ::=[Expression expression] 'as' [TypeName type]</pre>
  * @coverage dart.engine.ast
  */
 class AsExpression extends Expression {
 
   /**
    * The expression used to compute the value being cast.
    */
   Expression _expression;
 
   /**
@@ skipping 69 matching lines @@
    */
   void set type(TypeName name) {
     this._type = becomeParentOf(name);
   }
   void visitChildren(ASTVisitor<Object> visitor) {
     safelyVisitChild(_expression, visitor);
     safelyVisitChild(_type, visitor);
   }
 }
 /**
- * Instances of the class {@code AssertStatement} represent an assert statement.
+ * Instances of the class `AssertStatement` represent an assert statement.
  * <pre>
  * assertStatement ::=
- * 'assert' '(' {@link Expression conditionalExpression} ')' ';'
+ * 'assert' '(' [Expression conditionalExpression] ')' ';'
  * </pre>
  * @coverage dart.engine.ast
  */
 class AssertStatement extends Statement {
 
   /**
    * The token representing the 'assert' keyword.
    */
   Token _keyword;
 
   /**
    * The left parenthesis.
    */
   Token _leftParenthesis;
 
   /**
-   * The condition that is being asserted to be {@code true}.
+   * The condition that is being asserted to be `true`.
    */
   Expression _condition;
 
   /**
    * The right parenthesis.
    */
   Token _rightParenthesis;
 
   /**
    * The semicolon terminating the statement.
    */
   Token _semicolon;
 
   /**
    * Initialize a newly created assert statement.
    * @param keyword the token representing the 'assert' keyword
    * @param leftParenthesis the left parenthesis
-   * @param condition the condition that is being asserted to be {@code true}
+   * @param condition the condition that is being asserted to be `true`
    * @param rightParenthesis the right parenthesis
    * @param semicolon the semicolon terminating the statement
    */
   AssertStatement.full(Token keyword, Token leftParenthesis, Expression condition, Token rightParenthesis, Token semicolon) {
     this._keyword = keyword;
     this._leftParenthesis = leftParenthesis;
     this._condition = becomeParentOf(condition);
     this._rightParenthesis = rightParenthesis;
     this._semicolon = semicolon;
   }
 
   /**
    * Initialize a newly created assert statement.
    * @param keyword the token representing the 'assert' keyword
    * @param leftParenthesis the left parenthesis
-   * @param condition the condition that is being asserted to be {@code true}
+   * @param condition the condition that is being asserted to be `true`
    * @param rightParenthesis the right parenthesis
    * @param semicolon the semicolon terminating the statement
    */
   AssertStatement({Token keyword, Token leftParenthesis, Expression condition, Token rightParenthesis, Token semicolon}) : this.full(keyword, leftParenthesis, condition, rightParenthesis, semicolon);
   accept(ASTVisitor visitor) => visitor.visitAssertStatement(this);
   Token get beginToken => _keyword;
 
   /**
-   * Return the condition that is being asserted to be {@code true}.
-   * @return the condition that is being asserted to be {@code true}
+   * Return the condition that is being asserted to be `true`.
+   * @return the condition that is being asserted to be `true`
    */
   Expression get condition => _condition;
   Token get endToken => _semicolon;
 
   /**
    * Return the token representing the 'assert' keyword.
    * @return the token representing the 'assert' keyword
    */
   Token get keyword => _keyword;
 
   /**
    * Return the left parenthesis.
    * @return the left parenthesis
    */
   Token get leftParenthesis => _leftParenthesis;
 
   /**
    * Return the right parenthesis.
    * @return the right parenthesis
    */
   Token get rightParenthesis => _rightParenthesis;
 
   /**
    * Return the semicolon terminating the statement.
    * @return the semicolon terminating the statement
    */
   Token get semicolon => _semicolon;
 
   /**
-   * Set the condition that is being asserted to be {@code true} to the given expression.
-   * @param the condition that is being asserted to be {@code true}
+   * Set the condition that is being asserted to be `true` to the given expression.
+   * @param the condition that is being asserted to be `true`
    */
   void set condition(Expression condition2) {
     this._condition = becomeParentOf(condition2);
   }
 
   /**
    * Set the token representing the 'assert' keyword to the given token.
    * @param keyword the token representing the 'assert' keyword
    */
   void set keyword(Token keyword2) {
@@ skipping 21 matching lines @@
    * @param semicolon the semicolon terminating the statement
    */
   void set semicolon(Token semicolon2) {
     this._semicolon = semicolon2;
   }
   void visitChildren(ASTVisitor<Object> visitor) {
     safelyVisitChild(_condition, visitor);
   }
 }
 /**
- * Instances of the class {@code AssignmentExpression} represent an assignment expression.
+ * Instances of the class `AssignmentExpression` represent an assignment expression.
  * <pre>
- * assignmentExpression ::={@link Expression leftHandSide} {@link Token operator} {@link Expression rightHandSide}</pre>
+ * assignmentExpression ::=[Expression leftHandSide] [Token operator] [Expression rightHandSide]</pre>
  * @coverage dart.engine.ast
  */
 class AssignmentExpression extends Expression {
 
   /**
    * The expression used to compute the left hand side.
    */
   Expression _leftHandSide;
 
   /**
    * The assignment operator being applied.
    */
   Token _operator;
 
   /**
    * The expression used to compute the right hand side.
    */
   Expression _rightHandSide;
 
   /**
-   * The element associated with the operator based on the static type of the left-hand-side, or{@code null} if the AST structure has not been resolved, if the operator is not a compound
+   * The element associated with the operator based on the static type of the left-hand-side, or`null` if the AST structure has not been resolved, if the operator is not a compound
    * operator, or if the operator could not be resolved.
    */
   MethodElement _staticElement;
 
   /**
-   * The element associated with the operator based on the propagated type of the left-hand-side, or{@code null} if the AST structure has not been resolved, if the operator is not a compound
+   * The element associated with the operator based on the propagated type of the left-hand-side, or`null` if the AST structure has not been resolved, if the operator is not a compound
    * operator, or if the operator could not be resolved.
    */
   MethodElement _propagatedElement;
 
   /**
    * Initialize a newly created assignment expression.
    * @param leftHandSide the expression used to compute the left hand side
    * @param operator the assignment operator being applied
    * @param rightHandSide the expression used to compute the right hand side
    */
   AssignmentExpression.full(Expression leftHandSide, Token operator, Expression rightHandSide) {
     this._leftHandSide = becomeParentOf(leftHandSide);
     this._operator = operator;
     this._rightHandSide = becomeParentOf(rightHandSide);
   }
 
   /**
    * Initialize a newly created assignment expression.
    * @param leftHandSide the expression used to compute the left hand side
    * @param operator the assignment operator being applied
    * @param rightHandSide the expression used to compute the right hand side
    */
   AssignmentExpression({Expression leftHandSide, Token operator, Expression rightHandSide}) : this.full(leftHandSide, operator, rightHandSide);
   accept(ASTVisitor visitor) => visitor.visitAssignmentExpression(this);
   Token get beginToken => _leftHandSide.beginToken;
 
   /**
    * Return the element associated with the operator based on the propagated type of the
-   * left-hand-side, or {@code null} if the AST structure has not been resolved, if the operator is
+   * left-hand-side, or `null` if the AST structure has not been resolved, if the operator is
    * not a compound operator, or if the operator could not be resolved. One example of the latter
    * case is an operator that is not defined for the type of the left-hand operand.
    * @return the element associated with the operator
    */
   MethodElement get element => _propagatedElement;
   Token get endToken => _rightHandSide.endToken;
 
   /**
    * Set the expression used to compute the left hand side to the given expression.
    * @return the expression used to compute the left hand side
    */
   Expression get leftHandSide => _leftHandSide;
 
   /**
    * Return the assignment operator being applied.
    * @return the assignment operator being applied
    */
   Token get operator => _operator;
 
   /**
    * Return the expression used to compute the right hand side.
    * @return the expression used to compute the right hand side
    */
   Expression get rightHandSide => _rightHandSide;
 
   /**
    * Return the element associated with the operator based on the static type of the left-hand-side,
-   * or {@code null} if the AST structure has not been resolved, if the operator is not a compound
+   * or `null` if the AST structure has not been resolved, if the operator is not a compound
    * operator, or if the operator could not be resolved. One example of the latter case is an
    * operator that is not defined for the type of the left-hand operand.
    * @return the element associated with the operator
    */
   MethodElement get staticElement => _staticElement;
 
   /**
    * Set the element associated with the operator based on the propagated type of the left-hand-side
    * to the given element.
    * @param element the element to be associated with the operator
@@ skipping 33 matching lines @@
    */
   void set staticElement(MethodElement element) {
     _staticElement = element;
   }
   void visitChildren(ASTVisitor<Object> visitor) {
     safelyVisitChild(_leftHandSide, visitor);
     safelyVisitChild(_rightHandSide, visitor);
   }
 }
 /**
- * Instances of the class {@code BinaryExpression} represent a binary (infix) expression.
+ * Instances of the class `BinaryExpression` represent a binary (infix) expression.
  * <pre>
- * binaryExpression ::={@link Expression leftOperand} {@link Token operator} {@link Expression rightOperand}</pre>
+ * binaryExpression ::=[Expression leftOperand] [Token operator] [Expression rightOperand]</pre>
  * @coverage dart.engine.ast
  */
 class BinaryExpression extends Expression {
 
   /**
    * The expression used to compute the left operand.
    */
   Expression _leftOperand;
 
   /**
    * The binary operator being applied.
    */
   Token _operator;
 
   /**
    * The expression used to compute the right operand.
    */
   Expression _rightOperand;
 
   /**
-   * The element associated with the operator based on the static type of the left operand, or{@code null} if the AST structure has not been resolved, if the operator is not user definable,
+   * The element associated with the operator based on the static type of the left operand, or`null` if the AST structure has not been resolved, if the operator is not user definable,
    * or if the operator could not be resolved.
    */
   MethodElement _staticElement;
 
   /**
-   * The element associated with the operator based on the propagated type of the left operand, or{@code null} if the AST structure has not been resolved, if the operator is not user definable,
+   * The element associated with the operator based on the propagated type of the left operand, or`null` if the AST structure has not been resolved, if the operator is not user definable,
    * or if the operator could not be resolved.
    */
   MethodElement _propagatedElement;
 
   /**
    * Initialize a newly created binary expression.
    * @param leftOperand the expression used to compute the left operand
    * @param operator the binary operator being applied
    * @param rightOperand the expression used to compute the right operand
    */
   BinaryExpression.full(Expression leftOperand, Token operator, Expression rightOperand) {
     this._leftOperand = becomeParentOf(leftOperand);
     this._operator = operator;
     this._rightOperand = becomeParentOf(rightOperand);
   }
 
   /**
    * Initialize a newly created binary expression.
    * @param leftOperand the expression used to compute the left operand
    * @param operator the binary operator being applied
    * @param rightOperand the expression used to compute the right operand
    */
   BinaryExpression({Expression leftOperand, Token operator, Expression rightOperand}) : this.full(leftOperand, operator, rightOperand);
   accept(ASTVisitor visitor) => visitor.visitBinaryExpression(this);
   Token get beginToken => _leftOperand.beginToken;
 
   /**
    * Return the element associated with the operator based on the propagated type of the left
-   * operand, or {@code null} if the AST structure has not been resolved, if the operator is not
+   * operand, or `null` if the AST structure has not been resolved, if the operator is not
    * user definable, or if the operator could not be resolved. One example of the latter case is an
    * operator that is not defined for the type of the left-hand operand.
    * @return the element associated with the operator
    */
   MethodElement get element => _propagatedElement;
   Token get endToken => _rightOperand.endToken;
 
   /**
    * Return the expression used to compute the left operand.
    * @return the expression used to compute the left operand
    */
   Expression get leftOperand => _leftOperand;
 
   /**
    * Return the binary operator being applied.
    * @return the binary operator being applied
    */
   Token get operator => _operator;
 
   /**
    * Return the expression used to compute the right operand.
    * @return the expression used to compute the right operand
    */
   Expression get rightOperand => _rightOperand;
 
   /**
    * Return the element associated with the operator based on the static type of the left operand,
-   * or {@code null} if the AST structure has not been resolved, if the operator is not user
+   * or `null` if the AST structure has not been resolved, if the operator is not user
    * definable, or if the operator could not be resolved. One example of the latter case is an
    * operator that is not defined for the type of the left operand.
    * @return the element associated with the operator
    */
   MethodElement get staticElement => _staticElement;
 
   /**
    * Set the element associated with the operator based on the propagated type of the left operand
    * to the given element.
    * @param element the element to be associated with the operator
@@ skipping 35 matching lines @@
     _staticElement = element;
   }
   void visitChildren(ASTVisitor<Object> visitor) {
     safelyVisitChild(_leftOperand, visitor);
     safelyVisitChild(_rightOperand, visitor);
   }
 
   /**
    * If the AST structure has been resolved, and the function being invoked is known based on
    * propagated type information, then return the parameter element representing the parameter to
-   * which the value of the right operand will be bound. Otherwise, return {@code null}.
-   * <p>
-   * This method is only intended to be used by {@link Expression#getParameterElement()}.
+   * which the value of the right operand will be bound. Otherwise, return `null`.
+   *
+   * This method is only intended to be used by [Expression#getParameterElement].
    * @return the parameter element representing the parameter to which the value of the right
    * operand will be bound
    */
   ParameterElement get propagatedParameterElementForRightOperand {
     if (_propagatedElement == null) {
       return null;
     }
     List<ParameterElement> parameters = _propagatedElement.parameters;
     if (parameters.length < 1) {
       return null;
     }
     return parameters[0];
   }
 
   /**
    * If the AST structure has been resolved, and the function being invoked is known based on static
    * type information, then return the parameter element representing the parameter to which the
-   * value of the right operand will be bound. Otherwise, return {@code null}.
-   * <p>
-   * This method is only intended to be used by {@link Expression#getStaticParameterElement()}.
+   * value of the right operand will be bound. Otherwise, return `null`.
+   *
+   * This method is only intended to be used by [Expression#getStaticParameterElement].
    * @return the parameter element representing the parameter to which the value of the right
    * operand will be bound
    */
   ParameterElement get staticParameterElementForRightOperand {
     if (_staticElement == null) {
       return null;
     }
     List<ParameterElement> parameters = _staticElement.parameters;
     if (parameters.length < 1) {
       return null;
     }
     return parameters[0];
   }
 }
 /**
- * Instances of the class {@code Block} represent a sequence of statements.
+ * Instances of the class `Block` represent a sequence of statements.
  * <pre>
  * block ::=
  * '{' statement* '}'
  * </pre>
  * @coverage dart.engine.ast
  */
 class Block extends Statement {
 
   /**
    * The left curly bracket.
@@ skipping 65 matching lines @@
    * @param rightBracket the right curly bracket
    */
   void set rightBracket(Token rightBracket2) {
     this._rightBracket = rightBracket2;
   }
   void visitChildren(ASTVisitor<Object> visitor) {
     _statements.accept(visitor);
   }
 }
 /**
- * Instances of the class {@code BlockFunctionBody} represent a function body that consists of a
+ * Instances of the class `BlockFunctionBody` represent a function body that consists of a
  * block of statements.
  * <pre>
- * blockFunctionBody ::={@link Block block}</pre>
+ * blockFunctionBody ::=[Block block]</pre>
  * @coverage dart.engine.ast
  */
 class BlockFunctionBody extends FunctionBody {
 
   /**
    * The block representing the body of the function.
    */
   Block _block;
 
   /**
@@ skipping 24 matching lines @@
    * @param block the block representing the body of the function
    */
   void set block(Block block2) {
     this._block = becomeParentOf(block2);
   }
   void visitChildren(ASTVisitor<Object> visitor) {
     safelyVisitChild(_block, visitor);
   }
 }
 /**
- * Instances of the class {@code BooleanLiteral} represent a boolean literal expression.
+ * Instances of the class `BooleanLiteral` represent a boolean literal expression.
  * <pre>
  * booleanLiteral ::=
  * 'false' | 'true'
  * </pre>
  * @coverage dart.engine.ast
  */
 class BooleanLiteral extends Literal {
 
   /**
    * The token representing the literal.
@@ skipping 50 matching lines @@
    * Set the value of the literal to the given value.
    * @param value the value of the literal
    */
   void set value(bool value2) {
     this._value = value2;
   }
   void visitChildren(ASTVisitor<Object> visitor) {
   }
 }
 /**
- * Instances of the class {@code BreakStatement} represent a break statement.
+ * Instances of the class `BreakStatement` represent a break statement.
  * <pre>
  * breakStatement ::=
- * 'break' {@link SimpleIdentifier label}? ';'
+ * 'break' [SimpleIdentifier label]? ';'
  * </pre>
  * @coverage dart.engine.ast
  */
 class BreakStatement extends Statement {
 
   /**
    * The token representing the 'break' keyword.
    */
   Token _keyword;
 
   /**
-   * The label associated with the statement, or {@code null} if there is no label.
+   * The label associated with the statement, or `null` if there is no label.
    */
   SimpleIdentifier _label;
 
   /**
    * The semicolon terminating the statement.
    */
   Token _semicolon;
 
   /**
    * Initialize a newly created break statement.
@@ skipping 18 matching lines @@
   Token get beginToken => _keyword;
   Token get endToken => _semicolon;
 
   /**
    * Return the token representing the 'break' keyword.
    * @return the token representing the 'break' keyword
    */
   Token get keyword => _keyword;
 
   /**
-   * Return the label associated with the statement, or {@code null} if there is no label.
+   * Return the label associated with the statement, or `null` if there is no label.
    * @return the label associated with the statement
    */
   SimpleIdentifier get label => _label;
 
   /**
    * Return the semicolon terminating the statement.
    * @return the semicolon terminating the statement
    */
   Token get semicolon => _semicolon;
 
@@ skipping 18 matching lines @@
    * @param semicolon the semicolon terminating the statement
    */
   void set semicolon(Token semicolon2) {
     this._semicolon = semicolon2;
   }
   void visitChildren(ASTVisitor<Object> visitor) {
     safelyVisitChild(_label, visitor);
   }
 }
 /**
- * Instances of the class {@code CascadeExpression} represent a sequence of cascaded expressions:
+ * Instances of the class `CascadeExpression` represent 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: {@link IndexExpression}, {@link MethodInvocation} and{@link PropertyAccess}.
+ * a cascade expression: [IndexExpression], [MethodInvocation] and[PropertyAccess].
  * <pre>
- * cascadeExpression ::={@link Expression conditionalExpression} cascadeSection
+ * cascadeExpression ::=[Expression conditionalExpression] cascadeSection
  * cascadeSection ::=
  * '..'  (cascadeSelector arguments*) (assignableSelector arguments*)* (assignmentOperator expressionWithoutCascade)?
  * cascadeSelector ::=
  * '\[ ' expression '\] '
  * | identifier
  * </pre>
  * @coverage dart.engine.ast
  */
 class CascadeExpression extends Expression {
 
@@ skipping 46 matching lines @@
    */
   void set target(Expression target2) {
     this._target = becomeParentOf(target2);
   }
   void visitChildren(ASTVisitor<Object> visitor) {
     safelyVisitChild(_target, visitor);
     _cascadeSections.accept(visitor);
   }
 }
 /**
- * Instances of the class {@code CatchClause} represent a catch clause within a try statement.
+ * Instances of the class `CatchClause` represent a catch clause within a try statement.
  * <pre>
  * onPart ::=
- * catchPart {@link Block block}| 'on' type catchPart? {@link Block block}catchPart ::=
- * 'catch' '(' {@link SimpleIdentifier exceptionParameter} (',' {@link SimpleIdentifier stackTraceParameter})? ')'
+ * catchPart [Block block]| 'on' type catchPart? [Block block]catchPart ::=
+ * 'catch' '(' [SimpleIdentifier exceptionParameter] (',' [SimpleIdentifier stackTraceParameter])? ')'
  * </pre>
  * @coverage dart.engine.ast
  */
 class CatchClause extends ASTNode {
 
   /**
-   * The token representing the 'on' keyword, or {@code null} if there is no 'on' keyword.
+   * 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 {@code null} if this catch clause
+   * The type of exceptions caught by this catch clause, or `null` if this catch clause
    * catches every type of exception.
    */
   TypeName _exceptionType;
 
   /**
-   * The token representing the 'catch' keyword, or {@code null} if there is no 'catch' keyword.
+   * The token representing the 'catch' keyword, or `null` if there is no 'catch' keyword.
    */
   Token _catchKeyword;
 
   /**
    * The left parenthesis.
    */
   Token _leftParenthesis;
 
   /**
    * The parameter whose value will be the exception that was thrown.
@@ skipping 65 matching lines @@
     return _catchKeyword;
   }
 
   /**
    * Return the body of the catch block.
    * @return the body of the catch block
    */
   Block get body => _body;
 
   /**
-   * Return the token representing the 'catch' keyword, or {@code null} if there is no 'catch'
+   * Return the token representing the 'catch' keyword, or `null` if there is no 'catch'
    * keyword.
    * @return the token representing the 'catch' keyword
    */
   Token get catchKeyword => _catchKeyword;
 
   /**
    * Return the comma.
    * @return the comma
    */
   Token get comma => _comma;
   Token get endToken => _body.endToken;
 
   /**
    * Return the parameter whose value will be the exception that was thrown.
    * @return the parameter whose value will be the exception that was thrown
    */
   SimpleIdentifier get exceptionParameter => _exceptionParameter;
 
   /**
-   * Return the type of exceptions caught by this catch clause, or {@code null} if this catch clause
+   * Return the type of exceptions caught by this catch clause, or `null` if this catch clause
    * catches every type of exception.
    * @return the type of exceptions caught by this catch clause
    */
   TypeName get exceptionType => _exceptionType;
 
   /**
    * Return the left parenthesis.
    * @return the left parenthesis
    */
   Token get leftParenthesis => _leftParenthesis;
 
   /**
-   * Return the token representing the 'on' keyword, or {@code null} if there is no 'on' keyword.
+   * Return the token representing the 'on' keyword, or `null` if there is no 'on' keyword.
    * @return the token representing the 'on' keyword
    */
   Token get onKeyword => _onKeyword;
 
   /**
    * Return the right parenthesis.
    * @return the right parenthesis
    */
   Token get rightParenthesis => _rightParenthesis;
 
@@ skipping 77 matching lines @@
     _stackTraceParameter = becomeParentOf(parameter);
   }
   void visitChildren(ASTVisitor<Object> visitor) {
     safelyVisitChild(_exceptionType, visitor);
     safelyVisitChild(_exceptionParameter, visitor);
     safelyVisitChild(_stackTraceParameter, visitor);
     safelyVisitChild(_body, visitor);
   }
 }
 /**
- * Instances of the class {@code ClassDeclaration} represent the declaration of a class.
+ * Instances of the class `ClassDeclaration` represent the declaration of a class.
  * <pre>
  * classDeclaration ::=
- * 'abstract'? 'class' {@link SimpleIdentifier name} {@link TypeParameterList typeParameterList}?
- * ({@link ExtendsClause extendsClause} {@link WithClause withClause}?)?{@link ImplementsClause implementsClause}?
- * '{' {@link ClassMember classMember}* '}'
+ * 'abstract'? 'class' [SimpleIdentifier name] [TypeParameterList typeParameterList]?
+ * ([ExtendsClause extendsClause] [WithClause withClause]?)?[ImplementsClause implementsClause]?
+ * '{' [ClassMember classMember]* '}'
  * </pre>
  * @coverage dart.engine.ast
  */
 class ClassDeclaration extends CompilationUnitMember {
 
   /**
-   * The 'abstract' keyword, or {@code null} if the keyword was absent.
+   * The 'abstract' keyword, or `null` if the keyword was absent.
    */
   Token _abstractKeyword;
 
   /**
    * The token representing the 'class' keyword.
    */
   Token _classKeyword;
 
   /**
    * The name of the class being declared.
    */
   SimpleIdentifier _name;
 
   /**
-   * The type parameters for the class, or {@code null} if the class does not have any type
+   * The type parameters for the class, or `null` if the class does not have any type
    * parameters.
    */
   TypeParameterList _typeParameters;
 
   /**
-   * The extends clause for the class, or {@code null} if the class does not extend any other class.
+   * The extends clause for the class, or `null` if the class does not extend any other class.
    */
   ExtendsClause _extendsClause;
 
   /**
-   * The with clause for the class, or {@code null} if the class does not have a with clause.
+   * The with clause for the class, or `null` if the class does not have a with clause.
    */
   WithClause _withClause;
 
   /**
-   * The implements clause for the class, or {@code null} if the class does not implement any
+   * The implements clause for the class, or `null` if the class does not implement any
    * interfaces.
    */
   ImplementsClause _implementsClause;
 
   /**
    * The left curly bracket.
    */
   Token _leftBracket;
 
   /**
    * The members defined by the class.
    */
   NodeList<ClassMember> _members;
 
   /**
    * The right curly bracket.
    */
   Token _rightBracket;
 
   /**
    * Initialize a newly created class declaration.
    * @param comment the documentation comment associated with this class
    * @param metadata the annotations associated with this class
-   * @param abstractKeyword the 'abstract' keyword, or {@code null} if the keyword was absent
+   * @param abstractKeyword the 'abstract' keyword, or `null` if the keyword was absent
    * @param classKeyword the token representing the 'class' keyword
    * @param name the name of the class being declared
    * @param typeParameters the type parameters for the class
    * @param extendsClause the extends clause for the class
    * @param withClause the with clause for the class
    * @param implementsClause the implements clause for the class
    * @param leftBracket the left curly bracket
    * @param members the members defined by the class
    * @param rightBracket the right curly bracket
    */
   ClassDeclaration.full(Comment comment, List<Annotation> metadata, Token abstractKeyword, Token classKeyword, SimpleIdentifier name, TypeParameterList typeParameters, ExtendsClause extendsClause, WithClause withClause, ImplementsClause implementsClause, Token leftBracket, List<ClassMember> members, Token rightBracket) : super.full(comment, metadata) {
     this._members = new NodeList<ClassMember>(this);
     this._abstractKeyword = abstractKeyword;
     this._classKeyword = classKeyword;
     this._name = becomeParentOf(name);
     this._typeParameters = becomeParentOf(typeParameters);
     this._extendsClause = becomeParentOf(extendsClause);
     this._withClause = becomeParentOf(withClause);
     this._implementsClause = becomeParentOf(implementsClause);
     this._leftBracket = leftBracket;
     this._members.addAll(members);
     this._rightBracket = rightBracket;
   }
 
   /**
    * Initialize a newly created class declaration.
    * @param comment the documentation comment associated with this class
    * @param metadata the annotations associated with this class
-   * @param abstractKeyword the 'abstract' keyword, or {@code null} if the keyword was absent
+   * @param abstractKeyword the 'abstract' keyword, or `null` if the keyword was absent
    * @param classKeyword the token representing the 'class' keyword
    * @param name the name of the class being declared
    * @param typeParameters the type parameters for the class
    * @param extendsClause the extends clause for the class
    * @param withClause the with clause for the class
    * @param implementsClause the implements clause for the class
    * @param leftBracket the left curly bracket
    * @param members the members defined by the class
    * @param rightBracket the right curly bracket
    */
   ClassDeclaration({Comment comment, List<Annotation> metadata, Token abstractKeyword, Token classKeyword, SimpleIdentifier name, TypeParameterList typeParameters, ExtendsClause extendsClause, WithClause withClause, ImplementsClause implementsClause, Token leftBracket, List<ClassMember> members, Token rightBracket}) : this.full(comment, metadata, abstractKeyword, classKeyword, name, typeParameters, extendsClause, withClause, implementsClause, leftBracket, members, rightBracket);
   accept(ASTVisitor visitor) => visitor.visitClassDeclaration(this);
 
   /**
-   * Return the 'abstract' keyword, or {@code null} if the keyword was absent.
+   * Return the 'abstract' keyword, or `null` if the keyword was absent.
    * @return the 'abstract' keyword
    */
   Token get abstractKeyword => _abstractKeyword;
 
   /**
    * Return the token representing the 'class' keyword.
    * @return the token representing the 'class' keyword
    */
   Token get classKeyword => _classKeyword;
   ClassElement get element => _name != null ? (_name.element as ClassElement) : null;
   Token get endToken => _rightBracket;
 
   /**
-   * Return the extends clause for this class, or {@code null} if the class does not extend any
+   * Return the extends clause for this class, or `null` if the class does not extend any
    * other class.
    * @return the extends clause for this class
    */
   ExtendsClause get extendsClause => _extendsClause;
 
   /**
-   * Return the implements clause for the class, or {@code null} if the class does not implement any
+   * Return the implements clause for the class, or `null` if the class does not implement any
    * interfaces.
    * @return the implements clause for the class
    */
   ImplementsClause get implementsClause => _implementsClause;
 
   /**
    * Return the left curly bracket.
    * @return the left curly bracket
    */
   Token get leftBracket => _leftBracket;
@@ skipping 10 matching lines @@
    */
   SimpleIdentifier get name => _name;
 
   /**
    * Return the right curly bracket.
    * @return the right curly bracket
    */
   Token get rightBracket => _rightBracket;
 
   /**
-   * Return the type parameters for the class, or {@code null} if the class does not have any type
+   * Return the type parameters for the class, or `null` if the class does not have any type
    * parameters.
    * @return the type parameters for the class
    */
   TypeParameterList get typeParameters => _typeParameters;
 
   /**
-   * Return the with clause for the class, or {@code null} if the class does not have a with clause.
+   * Return the with clause for the class, or `null` if the class does not have a with clause.
    * @return the with clause for the class
    */
   WithClause get withClause => _withClause;
 
   /**
    * Set the 'abstract' keyword to the given keyword.
    * @param abstractKeyword the 'abstract' keyword
    */
   void set abstractKeyword(Token abstractKeyword2) {
     this._abstractKeyword = abstractKeyword2;
@@ skipping 72 matching lines @@
     members.accept(visitor);
   }
   Token get firstTokenAfterCommentAndMetadata {
     if (_abstractKeyword != null) {
       return _abstractKeyword;
     }
     return _classKeyword;
   }
 }
 /**
- * The abstract class {@code ClassMember} defines the behavior common to nodes that declare a name
+ * The abstract class `ClassMember` defines the behavior common to nodes that declare a name
  * within the scope of a class.
  * @coverage dart.engine.ast
  */
 abstract class ClassMember extends Declaration {
 
   /**
    * Initialize a newly created member of a class.
    * @param comment the documentation comment associated with this member
    * @param metadata the annotations associated with this member
    */
   ClassMember.full(Comment comment, List<Annotation> metadata) : super.full(comment, metadata) {
   }
 
   /**
    * Initialize a newly created member of a class.
    * @param comment the documentation comment associated with this member
    * @param metadata the annotations associated with this member
    */
   ClassMember({Comment comment, List<Annotation> metadata}) : this.full(comment, metadata);
 }
 /**
- * Instances of the class {@code ClassTypeAlias} represent a class type alias.
+ * Instances of the class `ClassTypeAlias` represent a class type alias.
  * <pre>
- * classTypeAlias ::={@link SimpleIdentifier identifier} {@link TypeParameterList typeParameters}? '=' 'abstract'? mixinApplication
- * mixinApplication ::={@link TypeName superclass} {@link WithClause withClause} {@link ImplementsClause implementsClause}? ';'
+ * classTypeAlias ::=[SimpleIdentifier identifier] [TypeParameterList typeParameters]? '=' 'abstract'? mixinApplication
+ * mixinApplication ::=[TypeName superclass] [WithClause withClause] [ImplementsClause implementsClause]? ';'
  * </pre>
  * @coverage dart.engine.ast
  */
 class ClassTypeAlias extends TypeAlias {
 
   /**
    * The name of the class being declared.
    */
   SimpleIdentifier _name;
 
   /**
-   * The type parameters for the class, or {@code null} if the class does not have any type
+   * 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.
    */
   Token _equals;
 
   /**
-   * The token for the 'abstract' keyword, or {@code null} if this is not defining an abstract
+   * The token for the 'abstract' keyword, or `null` if this is not defining an abstract
    * class.
    */
   Token _abstractKeyword;
 
   /**
    * The name of the superclass of the class being declared.
    */
   TypeName _superclass;
 
   /**
    * The with clause for this class.
    */
   WithClause _withClause;
 
   /**
-   * The implements clause for this class, or {@code null} if there is no implements clause.
+   * The implements clause for this class, or `null` if there is no implements clause.
    */
   ImplementsClause _implementsClause;
 
   /**
    * Initialize a newly created class type alias.
    * @param comment the documentation comment associated with this type alias
    * @param metadata the annotations associated with this type alias
    * @param keyword the token representing the 'typedef' keyword
    * @param name the name of the class being declared
    * @param typeParameters the type parameters for the class
@@ skipping 25 matching lines @@
    * @param abstractKeyword the token for the 'abstract' keyword
    * @param superclass the name of the superclass of the class being declared
    * @param withClause the with clause for this class
    * @param implementsClause the implements clause for this class
    * @param semicolon the semicolon terminating the declaration
    */
   ClassTypeAlias({Comment comment, List<Annotation> metadata, Token keyword, SimpleIdentifier name, TypeParameterList typeParameters, Token equals, Token abstractKeyword, TypeName superclass, WithClause withClause, ImplementsClause implementsClause, Token semicolon}) : this.full(comment, metadata, keyword, name, typeParameters, equals, abstractKeyword, superclass, withClause, implementsClause, semicolon);
   accept(ASTVisitor visitor) => visitor.visitClassTypeAlias(this);
 
   /**
-   * Return the token for the 'abstract' keyword, or {@code null} if this is not defining an
+   * Return the token for the 'abstract' keyword, or `null` if this is not defining an
    * abstract class.
    * @return the token for the 'abstract' keyword
    */
   Token get abstractKeyword => _abstractKeyword;
   ClassElement get element => _name != null ? (_name.element as ClassElement) : null;
 
   /**
    * Return the token for the '=' separating the name from the definition.
    * @return the token for the '=' separating the name from the definition
    */
   Token get equals => _equals;
 
   /**
-   * Return the implements clause for this class, or {@code null} if there is no implements clause.
+   * Return the implements clause for this class, or `null` if there is no implements clause.
    * @return the implements clause for this class
    */
   ImplementsClause get implementsClause => _implementsClause;
 
   /**
    * Return the name of the class being declared.
    * @return the name of the class being declared
    */
   SimpleIdentifier get name => _name;
 
   /**
    * Return the name of the superclass of the class being declared.
    * @return the name of the superclass of the class being declared
    */
   TypeName get superclass => _superclass;
 
   /**
-   * Return the type parameters for the class, or {@code null} if the class does not have any type
+   * Return the type parameters for the class, or `null` if the class does not have any type
    * parameters.
    * @return the type parameters for the class
    */
   TypeParameterList get typeParameters => _typeParameters;
 
   /**
    * Return the with clause for this class.
    * @return the with clause for this class
    */
   WithClause get withClause => _withClause;
@@ skipping 56 matching lines @@
   void visitChildren(ASTVisitor<Object> visitor) {
     super.visitChildren(visitor);
     safelyVisitChild(_name, visitor);
     safelyVisitChild(_typeParameters, visitor);
     safelyVisitChild(_superclass, visitor);
     safelyVisitChild(_withClause, visitor);
     safelyVisitChild(_implementsClause, visitor);
   }
 }
 /**
- * Instances of the class {@code Combinator} represent the combinator associated with an import
+ * Instances of the class `Combinator` represent the combinator associated with an import
  * directive.
  * <pre>
- * combinator ::={@link HideCombinator hideCombinator}| {@link ShowCombinator showCombinator}</pre>
+ * combinator ::=[HideCombinator hideCombinator]| [ShowCombinator showCombinator]</pre>
  * @coverage dart.engine.ast
  */
 abstract class Combinator extends ASTNode {
 
   /**
    * The keyword specifying what kind of processing is to be done on the imported names.
    */
   Token _keyword;
 
   /**
@@ skipping 23 matching lines @@
    * Set the keyword specifying what kind of processing is to be done on the imported names to the
    * given token.
    * @param keyword the keyword specifying what kind of processing is to be done on the imported
    * names
    */
   void set keyword(Token keyword2) {
     this._keyword = keyword2;
   }
 }
 /**
- * Instances of the class {@code Comment} represent a comment within the source code.
+ * Instances of the class `Comment` represent a comment within the source code.
  * <pre>
  * comment ::=
  * endOfLineComment
  * | blockComment
  * | documentationComment
  * endOfLineComment ::=
  * '//' (CHARACTER - EOL)* EOL
  * blockComment ::=
  * '/ *' CHARACTER* '&#42;/'
  * documentationComment ::=
- * '/ **' (CHARACTER | {@link CommentReference commentReference})* '&#42;/'
+ * '/ **' (CHARACTER | [CommentReference commentReference])* '&#42;/'
  * | ('///' (CHARACTER - EOL)* EOL)+
  * </pre>
  * @coverage dart.engine.ast
  */
 class Comment extends ASTNode {
 
   /**
    * Create a block comment.
    * @param tokens the tokens representing the comment
    * @return the block comment that was created
@@ skipping 68 matching lines @@
    */
   NodeList<CommentReference> get references => _references;
 
   /**
    * Return the tokens representing the comment.
    * @return the tokens representing the comment
    */
   List<Token> get tokens => _tokens;
 
   /**
-   * Return {@code true} if this is a block comment.
-   * @return {@code true} if this is a block comment
+   * Return `true` if this is a block comment.
+   * @return `true` if this is a block comment
    */
   bool isBlock() => identical(_type, CommentType.BLOCK);
 
   /**
-   * Return {@code true} if this is a documentation comment.
-   * @return {@code true} if this is a documentation comment
+   * Return `true` if this is a documentation comment.
+   * @return `true` if this is a documentation comment
    */
   bool isDocumentation() => identical(_type, CommentType.DOCUMENTATION);
 
   /**
-   * Return {@code true} if this is an end-of-line comment.
-   * @return {@code true} if this is an end-of-line comment
+   * Return `true` if this is an end-of-line comment.
+   * @return `true` if this is an end-of-line comment
    */
   bool isEndOfLine() => identical(_type, CommentType.END_OF_LINE);
   void visitChildren(ASTVisitor<Object> visitor) {
     _references.accept(visitor);
   }
 }
 /**
- * The enumeration {@code CommentType} encodes all the different types of comments that are
+ * The enumeration `CommentType` encodes all the different types of comments that are
  * recognized by the parser.
  */
 class CommentType implements Comparable<CommentType> {
 
   /**
    * An end-of-line comment.
    */
   static final CommentType END_OF_LINE = new CommentType('END_OF_LINE', 0);
 
   /**
@@ skipping 12 matching lines @@
 
   /// The position in the enum declaration.
   final int ordinal;
   CommentType(this.name, this.ordinal) {
   }
   int compareTo(CommentType other) => ordinal - other.ordinal;
   int get hashCode => ordinal;
   String toString() => name;
 }
 /**
- * Instances of the class {@code CommentReference} represent a reference to a Dart element that is
+ * Instances of the class `CommentReference` represent a reference to a Dart element that is
  * found within a documentation comment.
  * <pre>
  * commentReference ::=
- * '\[' 'new'? {@link Identifier identifier} '\]'
+ * '\[' 'new'? [Identifier identifier] '\]'
  * </pre>
  * @coverage dart.engine.ast
  */
 class CommentReference extends ASTNode {
 
   /**
-   * The token representing the 'new' keyword, or {@code null} if there was no 'new' keyword.
+   * The token representing the 'new' keyword, or `null` if there was no 'new' keyword.
    */
   Token _newKeyword;
 
   /**
    * The identifier being referenced.
    */
   Identifier _identifier;
 
   /**
    * Initialize a newly created reference to a Dart element.
@@ skipping 15 matching lines @@
   Token get beginToken => _identifier.beginToken;
   Token get endToken => _identifier.endToken;
 
   /**
    * Return the identifier being referenced.
    * @return the identifier being referenced
    */
   Identifier get identifier => _identifier;
 
   /**
-   * Return the token representing the 'new' keyword, or {@code null} if there was no 'new' keyword.
+   * Return the token representing the 'new' keyword, or `null` if there was no 'new' keyword.
    * @return the token representing the 'new' keyword
    */
   Token get newKeyword => _newKeyword;
 
   /**
    * Set the identifier being referenced to the given identifier.
    * @param identifier the identifier being referenced
    */
   void set identifier(Identifier identifier2) {
     identifier2 = becomeParentOf(identifier2);
   }
 
   /**
    * Set the token representing the 'new' keyword to the given token.
    * @param newKeyword the token representing the 'new' keyword
    */
   void set newKeyword(Token newKeyword2) {
     this._newKeyword = newKeyword2;
   }
   void visitChildren(ASTVisitor<Object> visitor) {
     safelyVisitChild(_identifier, visitor);
   }
 }
 /**
- * Instances of the class {@code CompilationUnit} represent a compilation unit.
- * <p>
+ * Instances of the class `CompilationUnit` represent 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.
  * <pre>
  * compilationUnit ::=
  * directives declarations
- * directives ::={@link ScriptTag scriptTag}? {@link LibraryDirective libraryDirective}? namespaceDirective* {@link PartDirective partDirective}| {@link PartOfDirective partOfDirective}namespaceDirective ::={@link ImportDirective importDirective}| {@link ExportDirective exportDirective}declarations ::={@link CompilationUnitMember compilationUnitMember}</pre>
+ * directives ::=[ScriptTag scriptTag]? [LibraryDirective libraryDirective]? namespaceDirective* [PartDirective partDirective]| [PartOfDirective partOfDirective]namespaceDirective ::=[ImportDirective importDirective]| [ExportDirective exportDirective]declarations ::=[CompilationUnitMember compilationUnitMember]</pre>
  * @coverage dart.engine.ast
  */
 class CompilationUnit extends ASTNode {
 
   /**
    * 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 {@code null} if there is no script
+   * The script tag at the beginning of the compilation unit, or `null` if there is no script
    * tag in this compilation unit.
    */
   ScriptTag _scriptTag;
 
   /**
    * The directives contained in this compilation unit.
    */
   NodeList<Directive> _directives;
 
   /**
    * The declarations contained in this compilation unit.
    */
   NodeList<CompilationUnitMember> _declarations;
 
   /**
    * The last token in the token stream that was parsed to form this compilation unit. This token
-   * should always have a type of {@link TokenType.EOF}.
+   * should always have a type of [TokenType.EOF].
    */
   Token _endToken;
 
   /**
-   * The element associated with this compilation unit, or {@code null} if the AST structure has not
+   * The element associated with this compilation unit, or `null` if the AST structure has not
    * been resolved.
    */
   CompilationUnitElement _element;
 
   /**
-   * The {@link LineInfo} for this {@link CompilationUnit}.
+   * The [LineInfo] for this [CompilationUnit].
    */
   LineInfo _lineInfo;
 
   /**
    * The parsing errors encountered when the receiver was parsed.
    */
   List<AnalysisError> _parsingErrors = AnalysisError.NO_ERRORS;
 
   /**
    * The resolution errors encountered when the receiver was resolved.
@@ skipping 36 matching lines @@
    */
   NodeList<CompilationUnitMember> get declarations => _declarations;
 
   /**
    * Return the directives contained in this compilation unit.
    * @return the directives contained in this compilation unit
    */
   NodeList<Directive> get directives => _directives;
 
   /**
-   * Return the element associated with this compilation unit, or {@code null} if the AST structure
+   * Return the element associated with this compilation unit, or `null` if the AST structure
    * has not been resolved.
    * @return the element associated with this compilation unit
    */
   CompilationUnitElement get element => _element;
   Token get endToken => _endToken;
 
   /**
    * Return an array containing all of the errors associated with the receiver. If the receiver has
-   * not been resolved, then return {@code null}.
-   * @return an array of errors (contains no {@code null}s) or {@code null} if the receiver has not
+   * not been resolved, then return `null`.
+   * @return an array of errors (contains no `null`s) or `null` if the receiver has not
    * been resolved
    */
   List<AnalysisError> get errors {
     List<AnalysisError> parserErrors = parsingErrors;
     List<AnalysisError> resolverErrors = resolutionErrors;
     if (resolverErrors.length == 0) {
       return parserErrors;
     } else if (parserErrors.length == 0) {
       return resolverErrors;
     } else {
       List<AnalysisError> allErrors = new List<AnalysisError>(parserErrors.length + resolverErrors.length);
       JavaSystem.arraycopy(parserErrors, 0, allErrors, 0, parserErrors.length);
       JavaSystem.arraycopy(resolverErrors, 0, allErrors, parserErrors.length, resolverErrors.length);
       return allErrors;
     }
   }
   int get length {
     Token endToken = this.endToken;
     if (endToken == null) {
       return 0;
     }
     return endToken.offset + endToken.length;
   }
 
   /**
-   * Get the {@link LineInfo} object for this compilation unit.
-   * @return the associated {@link LineInfo}
+   * Get the [LineInfo] object for this compilation unit.
+   * @return the associated [LineInfo]
    */
   LineInfo get lineInfo => _lineInfo;
   int get offset => 0;
 
   /**
    * Return an array containing all of the parsing errors associated with the receiver.
-   * @return an array of errors (not {@code null}, contains no {@code null}s).
+   * @return an array of errors (not `null`, contains no `null`s).
    */
   List<AnalysisError> get parsingErrors => _parsingErrors;
 
   /**
    * Return an array containing all of the resolution errors associated with the receiver. If the
-   * receiver has not been resolved, then return {@code null}.
-   * @return an array of errors (contains no {@code null}s) or {@code null} if the receiver has not
+   * receiver has not been resolved, then return `null`.
+   * @return an array of errors (contains no `null`s) or `null` if the receiver has not
    * been resolved
    */
   List<AnalysisError> get resolutionErrors => _resolutionErrors;
 
   /**
-   * Return the script tag at the beginning of the compilation unit, or {@code null} if there is no
+   * Return the script tag at the beginning of the compilation unit, or `null` if there is no
    * script tag in this compilation unit.
    * @return the script tag at the beginning of the compilation unit
    */
   ScriptTag get scriptTag => _scriptTag;
 
   /**
    * Set the element associated with this compilation unit to the given element.
    * @param element the element associated with this compilation unit
    */
   void set element(CompilationUnitElement element2) {
     this._element = element2;
   }
 
   /**
-   * Set the {@link LineInfo} object for this compilation unit.
+   * Set the [LineInfo] object for this compilation unit.
    * @param errors LineInfo to associate with this compilation unit
    */
   void set lineInfo(LineInfo lineInfo2) {
     this._lineInfo = lineInfo2;
   }
 
   /**
    * Called to cache the parsing errors when the unit is parsed.
-   * @param errors an array of parsing errors, if {@code null} is passed, the error array is set to
-   * an empty array, {@link AnalysisError#NO_ERRORS}
+   * @param errors an array of parsing errors, if `null` is passed, the error array is set to
+   * an empty array, [AnalysisError#NO_ERRORS]
    */
   void set parsingErrors(List<AnalysisError> errors) {
     _parsingErrors = errors == null ? AnalysisError.NO_ERRORS : errors;
   }
 
   /**
    * Called to cache the resolution errors when the unit is resolved.
-   * @param errors an array of resolution errors, if {@code null} is passed, the error array is set
-   * to an empty array, {@link AnalysisError#NO_ERRORS}
+   * @param errors an array of resolution errors, if `null` is passed, the error array is set
+   * to an empty array, [AnalysisError#NO_ERRORS]
    */
   void set resolutionErrors(List<AnalysisError> errors) {
     _resolutionErrors = errors == null ? AnalysisError.NO_ERRORS : errors;
   }
 
   /**
    * Set the script tag at the beginning of the compilation unit to the given script tag.
    * @param scriptTag the script tag at the beginning of the compilation unit
    */
   void set scriptTag(ScriptTag scriptTag2) {
     this._scriptTag = becomeParentOf(scriptTag2);
   }
   void visitChildren(ASTVisitor<Object> visitor) {
     safelyVisitChild(_scriptTag, visitor);
     if (directivesAreBeforeDeclarations()) {
       _directives.accept(visitor);
       _declarations.accept(visitor);
     } else {
       for (ASTNode child in sortedDirectivesAndDeclarations) {
         child.accept(visitor);
       }
     }
   }
 
   /**
-   * Return {@code true} if all of the directives are lexically before any declarations.
-   * @return {@code true} if all of the directives are lexically before any declarations
+   * Return `true` if all of the directives are lexically before any declarations.
+   * @return `true` if all of the directives are lexically before any declarations
    */
   bool directivesAreBeforeDeclarations() {
     if (_directives.isEmpty || _declarations.isEmpty) {
       return true;
     }
     Directive lastDirective = _directives[_directives.length - 1];
     CompilationUnitMember firstDeclaration = _declarations[0];
     return lastDirective.offset < firstDeclaration.offset;
   }
 
   /**
    * Return an array containing all of the directives and declarations in this compilation unit,
    * sorted in lexical order.
    * @return the directives and declarations in this compilation unit in the order in which they
    * appeared in the original source
    */
   List<ASTNode> get sortedDirectivesAndDeclarations {
     List<ASTNode> childList = new List<ASTNode>();
     childList.addAll(_directives);
     childList.addAll(_declarations);
     List<ASTNode> children = new List.from(childList);
     children.sort(ASTNode.LEXICAL_ORDER);
     return children;
   }
 }
 /**
- * Instances of the class {@code CompilationUnitMember} defines the behavior common to nodes that
+ * Instances of the class `CompilationUnitMember` defines the behavior common to nodes that
  * declare a name within the scope of a compilation unit.
  * <pre>
- * compilationUnitMember ::={@link ClassDeclaration classDeclaration}| {@link TypeAlias typeAlias}| {@link FunctionDeclaration functionDeclaration}| {@link MethodDeclaration getOrSetDeclaration}| {@link VariableDeclaration constantsDeclaration}| {@link VariableDeclaration variablesDeclaration}</pre>
+ * compilationUnitMember ::=[ClassDeclaration classDeclaration]| [TypeAlias typeAlias]| [FunctionDeclaration functionDeclaration]| [MethodDeclaration getOrSetDeclaration]| [VariableDeclaration constantsDeclaration]| [VariableDeclaration variablesDeclaration]</pre>
  * @coverage dart.engine.ast
  */
 abstract class CompilationUnitMember extends Declaration {
 
   /**
    * Initialize a newly created generic compilation unit member.
    * @param comment the documentation comment associated with this member
    * @param metadata the annotations associated with this member
    */
   CompilationUnitMember.full(Comment comment, List<Annotation> metadata) : super.full(comment, metadata) {
   }
 
   /**
    * Initialize a newly created generic compilation unit member.
    * @param comment the documentation comment associated with this member
    * @param metadata the annotations associated with this member
    */
   CompilationUnitMember({Comment comment, List<Annotation> metadata}) : this.full(comment, metadata);
 }
 /**
- * Instances of the class {@code ConditionalExpression} represent a conditional expression.
+ * Instances of the class `ConditionalExpression` represent a conditional expression.
  * <pre>
- * conditionalExpression ::={@link Expression condition} '?' {@link Expression thenExpression} ':' {@link Expression elseExpression}</pre>
+ * conditionalExpression ::=[Expression condition] '?' [Expression thenExpression] ':' [Expression elseExpression]</pre>
  * @coverage dart.engine.ast
  */
 class ConditionalExpression extends Expression {
 
   /**
    * 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.
    */
   Token _question;
 
   /**
-   * The expression that is executed if the condition evaluates to {@code true}.
+   * The expression that is executed if the condition evaluates to `true`.
    */
   Expression _thenExpression;
 
   /**
    * The token used to separate the then expression from the else expression.
    */
   Token _colon;
 
   /**
-   * The expression that is executed if the condition evaluates to {@code false}.
+   * The expression that is executed if the condition evaluates to `false`.
    */
   Expression _elseExpression;
 
   /**
    * Initialize a newly created conditional expression.
    * @param condition the condition used to determine which expression is executed next
    * @param question the token used to separate the condition from the then expression
-   * @param thenExpression the expression that is executed if the condition evaluates to{@code true}
+   * @param thenExpression the expression that is executed if the condition evaluates to`true`
    * @param colon the token used to separate the then expression from the else expression
-   * @param elseExpression the expression that is executed if the condition evaluates to{@code false}
+   * @param elseExpression the expression that is executed if the condition evaluates to`false`
    */
   ConditionalExpression.full(Expression condition, Token question, Expression thenExpression, Token colon, Expression elseExpression) {
     this._condition = becomeParentOf(condition);
     this._question = question;
     this._thenExpression = becomeParentOf(thenExpression);
     this._colon = colon;
     this._elseExpression = becomeParentOf(elseExpression);
   }
 
   /**
    * Initialize a newly created conditional expression.
    * @param condition the condition used to determine which expression is executed next
    * @param question the token used to separate the condition from the then expression
-   * @param thenExpression the expression that is executed if the condition evaluates to{@code true}
+   * @param thenExpression the expression that is executed if the condition evaluates to`true`
    * @param colon the token used to separate the then expression from the else expression
-   * @param elseExpression the expression that is executed if the condition evaluates to{@code false}
+   * @param elseExpression the expression that is executed if the condition evaluates to`false`
    */
   ConditionalExpression({Expression condition, Token question, Expression thenExpression, Token colon, Expression elseExpression}) : this.full(condition, question, thenExpression, colon, elseExpression);
   accept(ASTVisitor visitor) => visitor.visitConditionalExpression(this);
   Token get beginToken => _condition.beginToken;
 
   /**
    * Return the token used to separate the then expression from the else expression.
    * @return the token used to separate the then expression from the else expression
    */
   Token get colon => _colon;
 
   /**
    * Return the condition used to determine which of the expressions is executed next.
    * @return the condition used to determine which expression is executed next
    */
   Expression get condition => _condition;
 
   /**
-   * Return the expression that is executed if the condition evaluates to {@code false}.
-   * @return the expression that is executed if the condition evaluates to {@code false}
+   * Return the expression that is executed if the condition evaluates to `false`.
+   * @return the expression that is executed if the condition evaluates to `false`
    */
   Expression get elseExpression => _elseExpression;
   Token get endToken => _elseExpression.endToken;
 
   /**
    * Return the token used to separate the condition from the then expression.
    * @return the token used to separate the condition from the then expression
    */
   Token get question => _question;
 
   /**
-   * Return the expression that is executed if the condition evaluates to {@code true}.
-   * @return the expression that is executed if the condition evaluates to {@code true}
+   * Return the expression that is executed if the condition evaluates to `true`.
+   * @return the expression that is executed if the condition evaluates to `true`
    */
   Expression get thenExpression => _thenExpression;
 
   /**
    * Set the token used to separate the then expression from the else expression to the given token.
    * @param colon the token used to separate the then expression from the else expression
    */
   void set colon(Token colon2) {
     this._colon = colon2;
   }
 
   /**
    * Set the condition used to determine which of the expressions is executed next to the given
    * expression.
    * @param expression the condition used to determine which expression is executed next
    */
   void set condition(Expression expression) {
     _condition = becomeParentOf(expression);
   }
 
   /**
-   * Set the expression that is executed if the condition evaluates to {@code false} to the given
+   * Set the expression that is executed if the condition evaluates to `false` to the given
    * expression.
-   * @param expression the expression that is executed if the condition evaluates to {@code false}
+   * @param expression the expression that is executed if the condition evaluates to `false`
    */
   void set elseExpression(Expression expression) {
     _elseExpression = becomeParentOf(expression);
   }
 
   /**
    * Set the token used to separate the condition from the then expression to the given token.
    * @param question the token used to separate the condition from the then expression
    */
   void set question(Token question2) {
     this._question = question2;
   }
 
   /**
-   * Set the expression that is executed if the condition evaluates to {@code true} to the given
+   * Set the expression that is executed if the condition evaluates to `true` to the given
    * expression.
-   * @param expression the expression that is executed if the condition evaluates to {@code true}
+   * @param expression the expression that is executed if the condition evaluates to `true`
    */
   void set thenExpression(Expression expression) {
     _thenExpression = becomeParentOf(expression);
   }
   void visitChildren(ASTVisitor<Object> visitor) {
     safelyVisitChild(_condition, visitor);
     safelyVisitChild(_thenExpression, visitor);
     safelyVisitChild(_elseExpression, visitor);
   }
 }
 /**
- * Instances of the class {@code ConstructorDeclaration} represent a constructor declaration.
+ * Instances of the class `ConstructorDeclaration` represent a constructor declaration.
  * <pre>
  * constructorDeclaration ::=
- * constructorSignature {@link FunctionBody body}?
- * | constructorName formalParameterList ':' 'this' ('.' {@link SimpleIdentifier name})? arguments
+ * constructorSignature [FunctionBody body]?
+ * | constructorName formalParameterList ':' 'this' ('.' [SimpleIdentifier name])? arguments
  * constructorSignature ::=
  * 'external'? constructorName formalParameterList initializerList?
  * | 'external'? 'factory' factoryName formalParameterList initializerList?
  * | 'external'? 'const'  constructorName formalParameterList initializerList?
- * constructorName ::={@link SimpleIdentifier returnType} ('.' {@link SimpleIdentifier name})?
- * factoryName ::={@link Identifier returnType} ('.' {@link SimpleIdentifier name})?
+ * constructorName ::=[SimpleIdentifier returnType] ('.' [SimpleIdentifier name])?
+ * factoryName ::=[Identifier returnType] ('.' [SimpleIdentifier name])?
  * initializerList ::=
- * ':' {@link ConstructorInitializer initializer} (',' {@link ConstructorInitializer initializer})
+ * ':' [ConstructorInitializer initializer] (',' [ConstructorInitializer initializer])
  * </pre>
  * @coverage dart.engine.ast
  */
 class ConstructorDeclaration extends ClassMember {
 
   /**
-   * The token for the 'external' keyword, or {@code null} if the constructor is not external.
+   * The token for the 'external' keyword, or `null` if the constructor is not external.
    */
   Token _externalKeyword;
 
   /**
-   * The token for the 'const' keyword, or {@code null} if the constructor is not a const
+   * The token for the 'const' keyword, or `null` if the constructor is not a const
    * constructor.
    */
   Token _constKeyword;
 
   /**
-   * The token for the 'factory' keyword, or {@code null} if the constructor is not a factory
+   * The token for the 'factory' keyword, or `null` if the constructor is not a factory
    * constructor.
    */
   Token _factoryKeyword;
 
   /**
    * The type of object being created. This can be different than the type in which the constructor
    * is being declared if the constructor is the implementation of a factory constructor.
    */
   Identifier _returnType;
 
   /**
-   * The token for the period before the constructor name, or {@code null} if the constructor being
+   * The token for the period before the constructor name, or `null` if the constructor being
    * declared is unnamed.
    */
   Token _period;
 
   /**
-   * The name of the constructor, or {@code null} if the constructor being declared is unnamed.
+   * The name of the constructor, or `null` if the constructor being declared is unnamed.
    */
   SimpleIdentifier _name;
 
   /**
-   * The element associated with this constructor, or {@code null} if the AST structure has not been
+   * The element associated with this constructor, or `null` if the AST structure has not been
    * resolved or if this constructor could not be resolved.
    */
   ConstructorElement _element;
 
   /**
    * The parameters associated with the constructor.
    */
   FormalParameterList _parameters;
 
   /**
-   * The token for the separator (colon or equals) before the initializers, or {@code null} if there
+   * The token for the separator (colon or equals) before the initializers, or `null` if there
    * are no initializers.
    */
   Token _separator;
 
   /**
    * The initializers associated with the constructor.
    */
   NodeList<ConstructorInitializer> _initializers;
 
   /**
-   * The name of the constructor to which this constructor will be redirected, or {@code null} if
+   * The name of the constructor to which this constructor will be redirected, or `null` if
    * this is not a redirecting factory constructor.
    */
   ConstructorName _redirectedConstructor;
 
   /**
-   * The body of the constructor, or {@code null} if the constructor does not have a body.
+   * The body of the constructor, or `null` if the constructor does not have a body.
    */
   FunctionBody _body;
 
   /**
    * Initialize a newly created constructor declaration.
    * @param externalKeyword the token for the 'external' keyword
    * @param comment the documentation comment associated with this constructor
    * @param metadata the annotations associated with this constructor
    * @param constKeyword the token for the 'const' keyword
    * @param factoryKeyword the token for the 'factory' keyword
@@ skipping 36 matching lines @@
    * @param separator the token for the colon or equals before the initializers
    * @param initializers the initializers associated with the constructor
    * @param redirectedConstructor the name of the constructor to which this constructor will be
    * redirected
    * @param body the body of the constructor
    */
   ConstructorDeclaration({Comment comment, List<Annotation> metadata, Token externalKeyword, Token constKeyword, Token factoryKeyword, Identifier returnType, Token period, SimpleIdentifier name, FormalParameterList parameters, Token separator, List<ConstructorInitializer> initializers, ConstructorName redirectedConstructor, FunctionBody body}) : this.full(comment, metadata, externalKeyword, constKeyword, factoryKeyword, returnType, period, name, parameters, separator, initializers, redirectedConstructor, body);
   accept(ASTVisitor visitor) => visitor.visitConstructorDeclaration(this);
 
   /**
-   * Return the body of the constructor, or {@code null} if the constructor does not have a body.
+   * Return the body of the constructor, or `null` if the constructor does not have a body.
    * @return the body of the constructor
    */
   FunctionBody get body => _body;
 
   /**
    * Return the token for the 'const' keyword.
    * @return the token for the 'const' keyword
    */
   Token get constKeyword => _constKeyword;
   ConstructorElement get element => _element;
   Token get endToken {
     if (_body != null) {
       return _body.endToken;
     } else if (!_initializers.isEmpty) {
       return _initializers.endToken;
     }
     return _parameters.endToken;
   }
 
   /**
-   * Return the token for the 'external' keyword, or {@code null} if the constructor is not
+   * Return the token for the 'external' keyword, or `null` if the constructor is not
    * external.
    * @return the token for the 'external' keyword
    */
   Token get externalKeyword => _externalKeyword;
 
   /**
    * Return the token for the 'factory' keyword.
    * @return the token for the 'factory' keyword
    */
   Token get factoryKeyword => _factoryKeyword;
 
   /**
    * Return the initializers associated with the constructor.
    * @return the initializers associated with the constructor
    */
   NodeList<ConstructorInitializer> get initializers => _initializers;
 
   /**
-   * Return the name of the constructor, or {@code null} if the constructor being declared is
+   * Return the name of the constructor, or `null` if the constructor being declared is
    * unnamed.
    * @return the name of the constructor
    */
   SimpleIdentifier get name => _name;
 
   /**
    * Return the parameters associated with the constructor.
    * @return the parameters associated with the constructor
    */
   FormalParameterList get parameters => _parameters;
 
   /**
-   * Return the token for the period before the constructor name, or {@code null} if the constructor
+   * Return the token for the period before the constructor name, or `null` if the constructor
    * being declared is unnamed.
    * @return the token for the period before the constructor name
    */
   Token get period => _period;
 
   /**
-   * Return the name of the constructor to which this constructor will be redirected, or{@code null} if this is not a redirecting factory constructor.
+   * Return the name of the constructor to which this constructor will be redirected, or`null` if this is not a redirecting factory constructor.
    * @return the name of the constructor to which this constructor will be redirected
    */
   ConstructorName get redirectedConstructor => _redirectedConstructor;
 
   /**
    * Return the type of object being created. This can be different than the type in which the
    * constructor is being declared if the constructor is the implementation of a factory
    * constructor.
    * @return the type of object being created
    */
   Identifier get returnType => _returnType;
 
   /**
-   * Return the token for the separator (colon or equals) before the initializers, or {@code null}if there are no initializers.
+   * Return the token for the separator (colon or equals) before the initializers, or `null`if there are no initializers.
    * @return the token for the separator (colon or equals) before the initializers
    */
   Token get separator => _separator;
 
   /**
    * Set the body of the constructor to the given function body.
    * @param functionBody the body of the constructor
    */
   void set body(FunctionBody functionBody) {
     _body = becomeParentOf(functionBody);
@@ skipping 91 matching lines @@
   }
   Token get firstTokenAfterCommentAndMetadata {
     Token leftMost2 = leftMost([_externalKeyword, _constKeyword, _factoryKeyword]);
     if (leftMost2 != null) {
       return leftMost2;
     }
     return _returnType.beginToken;
   }
 
   /**
-   * Return the left-most of the given tokens, or {@code null} if there are no tokens given or if
-   * all of the given tokens are {@code null}.
+   * Return the left-most of the given tokens, or `null` if there are no tokens given or if
+   * all of the given tokens are `null`.
    * @param tokens the tokens being compared to find the left-most token
    * @return the left-most of the given tokens
    */
   Token leftMost(List<Token> tokens) {
     Token leftMost = null;
     int offset = 2147483647;
     for (Token token in tokens) {
       if (token != null && token.offset < offset) {
         leftMost = token;
       }
     }
     return leftMost;
   }
 }
 /**
- * Instances of the class {@code ConstructorFieldInitializer} represent the initialization of a
+ * Instances of the class `ConstructorFieldInitializer` represent the initialization of a
  * field within a constructor's initialization list.
  * <pre>
  * fieldInitializer ::=
- * ('this' '.')? {@link SimpleIdentifier fieldName} '=' {@link Expression conditionalExpression cascadeSection*}</pre>
+ * ('this' '.')? [SimpleIdentifier fieldName] '=' [Expression conditionalExpression cascadeSection*]</pre>
  * @coverage dart.engine.ast
  */
 class ConstructorFieldInitializer extends ConstructorInitializer {
 
   /**
-   * The token for the 'this' keyword, or {@code null} if there is no 'this' keyword.
+   * The token for the 'this' keyword, or `null` if there is no 'this' keyword.
    */
   Token _keyword;
 
   /**
-   * The token for the period after the 'this' keyword, or {@code null} if there is no 'this'
+   * The token for the period after the 'this' keyword, or `null` if there is no 'this'
    * keyword.
    */
   Token _period;
 
   /**
    * The name of the field being initialized.
    */
   SimpleIdentifier _fieldName;
 
   /**
@@ skipping 54 matching lines @@
    */
   Expression get expression => _expression;
 
   /**
    * Return the name of the field being initialized.
    * @return the name of the field being initialized
    */
   SimpleIdentifier get fieldName => _fieldName;
 
   /**
-   * Return the token for the 'this' keyword, or {@code null} if there is no 'this' keyword.
+   * Return the token for the 'this' keyword, or `null` if there is no 'this' keyword.
    * @return the token for the 'this' keyword
    */
   Token get keyword => _keyword;
 
   /**
-   * Return the token for the period after the 'this' keyword, or {@code null} if there is no 'this'
+   * Return the token for the period after the 'this' keyword, or `null` if there is no 'this'
    * keyword.
    * @return the token for the period after the 'this' keyword
    */
   Token get period => _period;
 
   /**
    * Set the token for the equal sign between the field name and the expression to the given token.
    * @param equals the token for the equal sign between the field name and the expression
    */
   void set equals(Token equals2) {
@@ skipping 31 matching lines @@
    */
   void set period(Token period2) {
     this._period = period2;
   }
   void visitChildren(ASTVisitor<Object> visitor) {
     safelyVisitChild(_fieldName, visitor);
     safelyVisitChild(_expression, visitor);
   }
 }
 /**
- * Instances of the class {@code ConstructorInitializer} defines the behavior of nodes that can
+ * Instances of the class `ConstructorInitializer` defines the behavior of nodes that can
  * occur in the initializer list of a constructor declaration.
  * <pre>
- * constructorInitializer ::={@link SuperConstructorInvocation superInvocation}| {@link ConstructorFieldInitializer fieldInitializer}</pre>
+ * constructorInitializer ::=[SuperConstructorInvocation superInvocation]| [ConstructorFieldInitializer fieldInitializer]</pre>
  * @coverage dart.engine.ast
  */
 abstract class ConstructorInitializer extends ASTNode {
 }
 /**
- * Instances of the class {@code ConstructorName} represent the name of the constructor.
+ * Instances of the class `ConstructorName` represent the name of the constructor.
  * <pre>
  * constructorName:
  * type ('.' identifier)?
  * </pre>
  * @coverage dart.engine.ast
  */
 class ConstructorName extends ASTNode {
 
   /**
    * The name of the type defining the constructor.
    */
   TypeName _type;
 
   /**
-   * The token for the period before the constructor name, or {@code null} if the specified
+   * The token for the period before the constructor name, or `null` if the specified
    * constructor is the unnamed constructor.
    */
   Token _period;
 
   /**
-   * The name of the constructor, or {@code null} if the specified constructor is the unnamed
+   * The name of the constructor, or `null` if the specified constructor is the unnamed
    * constructor.
    */
   SimpleIdentifier _name;
 
   /**
-   * The element associated with this constructor name based on static type information, or{@code null} if the AST structure has not been resolved or if this constructor name could not
+   * The element associated with this constructor name based on static type information, or`null` if the AST structure has not been resolved or if this constructor name could not
    * be resolved.
    */
   ConstructorElement _staticElement;
 
   /**
-   * The element associated with this constructor name based on propagated type information, or{@code null} if the AST structure has not been resolved or if this constructor name could not
+   * The element associated with this constructor name based on propagated type information, or`null` if the AST structure has not been resolved or if this constructor name could not
    * be resolved.
    */
   ConstructorElement _propagatedElement;
 
   /**
    * Initialize a newly created constructor name.
    * @param type the name of the type defining the constructor
    * @param period the token for the period before the constructor name
    * @param name the name of the constructor
    */
   ConstructorName.full(TypeName type, Token period, SimpleIdentifier name) {
     this._type = becomeParentOf(type);
     this._period = period;
     this._name = becomeParentOf(name);
   }
 
   /**
    * Initialize a newly created constructor name.
    * @param type the name of the type defining the constructor
    * @param period the token for the period before the constructor name
    * @param name the name of the constructor
    */
   ConstructorName({TypeName type, Token period, SimpleIdentifier name}) : this.full(type, period, name);
   accept(ASTVisitor visitor) => visitor.visitConstructorName(this);
   Token get beginToken => _type.beginToken;
 
   /**
    * Return the element associated with this constructor name based on propagated type information,
-   * or {@code null} if the AST structure has not been resolved or if this constructor name could
+   * or `null` if the AST structure has not been resolved or if this constructor name could
    * not be resolved.
    * @return the element associated with this constructor name
    */
   ConstructorElement get element => _propagatedElement;
   Token get endToken {
     if (_name != null) {
       return _name.endToken;
     }
     return _type.endToken;
   }
 
   /**
-   * Return the name of the constructor, or {@code null} if the specified constructor is the unnamed
+   * Return the name of the constructor, or `null` if the specified constructor is the unnamed
    * constructor.
    * @return the name of the constructor
    */
   SimpleIdentifier get name => _name;
 
   /**
-   * Return the token for the period before the constructor name, or {@code null} if the specified
+   * Return the token for the period before the constructor name, or `null` if the specified
    * constructor is the unnamed constructor.
    * @return the token for the period before the constructor name
    */
   Token get period => _period;
 
   /**
-   * Return the element associated with this constructor name based on static type information, or{@code null} if the AST structure has not been resolved or if this constructor name could not
+   * Return the element associated with this constructor name based on static type information, or`null` if the AST structure has not been resolved or if this constructor name could not
    * be resolved.
    * @return the element associated with this constructor name
    */
   ConstructorElement get staticElement => _staticElement;
 
   /**
    * Return the name of the type defining the constructor.
    * @return the name of the type defining the constructor
    */
   TypeName get type => _type;
@@ skipping 38 matching lines @@
    */
   void set type(TypeName type2) {
     this._type = becomeParentOf(type2);
   }
   void visitChildren(ASTVisitor<Object> visitor) {
     safelyVisitChild(_type, visitor);
     safelyVisitChild(_name, visitor);
   }
 }
 /**
- * Instances of the class {@code ContinueStatement} represent a continue statement.
+ * Instances of the class `ContinueStatement` represent a continue statement.
  * <pre>
  * continueStatement ::=
- * 'continue' {@link SimpleIdentifier label}? ';'
+ * 'continue' [SimpleIdentifier label]? ';'
  * </pre>
  * @coverage dart.engine.ast
  */
 class ContinueStatement extends Statement {
 
   /**
    * The token representing the 'continue' keyword.
    */
   Token _keyword;
 
   /**
-   * The label associated with the statement, or {@code null} if there is no label.
+   * The label associated with the statement, or `null` if there is no label.
    */
   SimpleIdentifier _label;
 
   /**
    * The semicolon terminating the statement.
    */
   Token _semicolon;
 
   /**
    * Initialize a newly created continue statement.
@@ skipping 18 matching lines @@
   Token get beginToken => _keyword;
   Token get endToken => _semicolon;
 
   /**
    * Return the token representing the 'continue' keyword.
    * @return the token representing the 'continue' keyword
    */
   Token get keyword => _keyword;
 
   /**
-   * Return the label associated with the statement, or {@code null} if there is no label.
+   * Return the label associated with the statement, or `null` if there is no label.
    * @return the label associated with the statement
    */
   SimpleIdentifier get label => _label;
 
   /**
    * Return the semicolon terminating the statement.
    * @return the semicolon terminating the statement
    */
   Token get semicolon => _semicolon;
 
@@ skipping 18 matching lines @@
    * @param semicolon the semicolon terminating the statement
    */
   void set semicolon(Token semicolon2) {
     this._semicolon = semicolon2;
   }
   void visitChildren(ASTVisitor<Object> visitor) {
     safelyVisitChild(_label, visitor);
   }
 }
 /**
- * The abstract class {@code Declaration} defines the behavior common to nodes that represent the
+ * The abstract class `Declaration` defines the behavior common to nodes that represent the
  * declaration of a name. Each declared name is visible within a name scope.
  * @coverage dart.engine.ast
  */
 abstract class Declaration extends AnnotatedNode {
 
   /**
    * Initialize a newly created declaration.
    * @param comment the documentation comment associated with this declaration
    * @param metadata the annotations associated with this declaration
    */
   Declaration.full(Comment comment, List<Annotation> metadata) : super.full(comment, metadata) {
   }
 
   /**
    * Initialize a newly created declaration.
    * @param comment the documentation comment associated with this declaration
    * @param metadata the annotations associated with this declaration
    */
   Declaration({Comment comment, List<Annotation> metadata}) : this.full(comment, metadata);
 
   /**
-   * Return the element associated with this declaration, or {@code null} if either this node
+   * Return the element associated with this declaration, or `null` if either this node
    * corresponds to a list of declarations or if the AST structure has not been resolved.
    * @return the element associated with this declaration
    */
   Element get element;
 }
 /**
- * Instances of the class {@code DeclaredIdentifier} represent the declaration of a single
+ * Instances of the class `DeclaredIdentifier` represent the declaration of a single
  * identifier.
  * <pre>
  * declaredIdentifier ::=
- * ({@link Annotation metadata} finalConstVarOrType {@link SimpleIdentifier identifier}</pre>
+ * ([Annotation metadata] finalConstVarOrType [SimpleIdentifier identifier]</pre>
  * @coverage dart.engine.ast
  */
 class DeclaredIdentifier extends Declaration {
 
   /**
-   * The token representing either the 'final', 'const' or 'var' keyword, or {@code null} if no
+   * The token representing either the 'final', 'const' or 'var' keyword, or `null` if no
    * keyword was used.
    */
   Token _keyword;
 
   /**
-   * The name of the declared type of the parameter, or {@code null} if the parameter does not have
+   * The name of the declared type of the parameter, or `null` if the parameter does not have
    * a declared type.
    */
   TypeName _type;
 
   /**
    * The name of the variable being declared.
    */
   SimpleIdentifier _identifier;
 
   /**
@@ skipping 35 matching lines @@
    */
   SimpleIdentifier get identifier => _identifier;
 
   /**
    * Return the token representing either the 'final', 'const' or 'var' keyword.
    * @return the token representing either the 'final', 'const' or 'var' keyword
    */
   Token get keyword => _keyword;
 
   /**
-   * Return the name of the declared type of the parameter, or {@code null} if the parameter does
+   * Return the name of the declared type of the parameter, or `null` if the parameter does
    * not have a declared type.
    * @return the name of the declared type of the parameter
    */
   TypeName get type => _type;
 
   /**
-   * Return {@code true} if this variable was declared with the 'const' modifier.
-   * @return {@code true} if this variable was declared with the 'const' modifier
+   * Return `true` if this variable was declared with the 'const' modifier.
+   * @return `true` if this variable was declared with the 'const' modifier
    */
   bool isConst() => (_keyword is KeywordToken) && identical(((_keyword as KeywordToken)).keyword, Keyword.CONST);
 
   /**
-   * Return {@code true} if this variable was declared with the 'final' modifier. Variables that are
-   * declared with the 'const' modifier will return {@code false} even though they are implicitly
+   * Return `true` if this variable was declared with the 'final' modifier. Variables that are
+   * declared with the 'const' modifier will return `false` even though they are implicitly
    * final.
-   * @return {@code true} if this variable was declared with the 'final' modifier
+   * @return `true` if this variable was declared with the 'final' modifier
    */
   bool isFinal() => (_keyword is KeywordToken) && identical(((_keyword as KeywordToken)).keyword, Keyword.FINAL);
 
   /**
    * Set the token representing either the 'final', 'const' or 'var' keyword to the given token.
    * @param keyword the token representing either the 'final', 'const' or 'var' keyword
    */
   void set keyword(Token keyword2) {
     this._keyword = keyword2;
   }
@@ skipping 13 matching lines @@
   Token get firstTokenAfterCommentAndMetadata {
     if (_keyword != null) {
       return _keyword;
     } else if (_type != null) {
       return _type.beginToken;
     }
     return _identifier.beginToken;
   }
 }
 /**
- * Instances of the class {@code DefaultFormalParameter} represent a formal parameter with a default
+ * Instances of the class `DefaultFormalParameter` represent 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.
  * <pre>
- * defaultFormalParameter ::={@link NormalFormalParameter normalFormalParameter} ('=' {@link Expression defaultValue})?
- * defaultNamedParameter ::={@link NormalFormalParameter normalFormalParameter} (':' {@link Expression defaultValue})?
+ * defaultFormalParameter ::=[NormalFormalParameter normalFormalParameter] ('=' [Expression defaultValue])?
+ * defaultNamedParameter ::=[NormalFormalParameter normalFormalParameter] (':' [Expression defaultValue])?
  * </pre>
  * @coverage dart.engine.ast
  */
 class DefaultFormalParameter extends FormalParameter {
 
   /**
    * The formal parameter with which the default value is associated.
    */
   NormalFormalParameter _parameter;
 
   /**
    * The kind of this parameter.
    */
   ParameterKind _kind;
 
   /**
-   * The token separating the parameter from the default value, or {@code null} if there is no
+   * The token separating the parameter from the default value, or `null` if there is no
    * default value.
    */
   Token _separator;
 
   /**
-   * The expression computing the default value for the parameter, or {@code null} if there is no
+   * The expression computing the default value for the parameter, or `null` if there is no
    * default value.
    */
   Expression _defaultValue;
 
   /**
    * Initialize a newly created default formal parameter.
    * @param parameter the formal parameter with which the default value is associated
    * @param kind the kind of this parameter
    * @param separator the token separating the parameter from the default value
    * @param defaultValue the expression computing the default value for the parameter
@@ skipping 10 matching lines @@
    * @param parameter the formal parameter with which the default value is associated
    * @param kind the kind of this parameter
    * @param separator the token separating the parameter from the default value
    * @param defaultValue the expression computing the default value for the parameter
    */
   DefaultFormalParameter({NormalFormalParameter parameter, ParameterKind kind, Token separator, Expression defaultValue}) : this.full(parameter, kind, separator, defaultValue);
   accept(ASTVisitor visitor) => visitor.visitDefaultFormalParameter(this);
   Token get beginToken => _parameter.beginToken;
 
   /**
-   * Return the expression computing the default value for the parameter, or {@code null} if there
+   * Return the expression computing the default value for the parameter, or `null` if there
    * is no default value.
    * @return the expression computing the default value for the parameter
    */
   Expression get defaultValue => _defaultValue;
   Token get endToken {
     if (_defaultValue != null) {
       return _defaultValue.endToken;
     }
     return _parameter.endToken;
   }
   SimpleIdentifier get identifier => _parameter.identifier;
   ParameterKind get kind => _kind;
 
   /**
    * Return the formal parameter with which the default value is associated.
    * @return the formal parameter with which the default value is associated
    */
   NormalFormalParameter get parameter => _parameter;
 
   /**
-   * Return the token separating the parameter from the default value, or {@code null} if there is
+   * Return the token separating the parameter from the default value, or `null` if there is
    * no default value.
    * @return the token separating the parameter from the default value
    */
   Token get separator => _separator;
 
   /**
-   * Return {@code true} if this parameter was declared with the 'const' modifier.
-   * @return {@code true} if this parameter was declared with the 'const' modifier
+   * Return `true` if this parameter was declared with the 'const' modifier.
+   * @return `true` if this parameter was declared with the 'const' modifier
    */
   bool isConst() => _parameter != null && _parameter.isConst();
 
   /**
-   * Return {@code true} if this parameter was declared with the 'final' modifier. Parameters that
-   * are declared with the 'const' modifier will return {@code false} even though they are
+   * Return `true` if this parameter was declared with the 'final' modifier. Parameters that
+   * are declared with the 'const' modifier will return `false` even though they are
    * implicitly final.
-   * @return {@code true} if this parameter was declared with the 'final' modifier
+   * @return `true` if this parameter was declared with the 'final' modifier
    */
   bool isFinal() => _parameter != null && _parameter.isFinal();
 
   /**
    * Set the expression computing the default value for the parameter to the given expression.
    * @param expression the expression computing the default value for the parameter
    */
   void set defaultValue(Expression expression) {
     _defaultValue = becomeParentOf(expression);
   }
@@ skipping 20 matching lines @@
    */
   void set separator(Token separator2) {
     this._separator = separator2;
   }
   void visitChildren(ASTVisitor<Object> visitor) {
     safelyVisitChild(_parameter, visitor);
     safelyVisitChild(_defaultValue, visitor);
   }
 }
 /**
- * The abstract class {@code Directive} defines the behavior common to nodes that represent a
+ * The abstract class `Directive` defines the behavior common to nodes that represent a
  * directive.
  * <pre>
- * directive ::={@link ExportDirective exportDirective}| {@link ImportDirective importDirective}| {@link LibraryDirective libraryDirective}| {@link PartDirective partDirective}| {@link PartOfDirective partOfDirective}</pre>
+ * directive ::=[ExportDirective exportDirective]| [ImportDirective importDirective]| [LibraryDirective libraryDirective]| [PartDirective partDirective]| [PartOfDirective partOfDirective]</pre>
  * @coverage dart.engine.ast
  */
 abstract class Directive extends AnnotatedNode {
 
   /**
-   * The element associated with this directive, or {@code null} if the AST structure has not been
+   * 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.
    * @param comment the documentation comment associated with this directive
    * @param metadata the annotations associated with the directive
    */
   Directive.full(Comment comment, List<Annotation> metadata) : super.full(comment, metadata) {
   }
 
   /**
    * Initialize a newly create directive.
    * @param comment the documentation comment associated with this directive
    * @param metadata the annotations associated with the directive
    */
   Directive({Comment comment, List<Annotation> metadata}) : this.full(comment, metadata);
 
   /**
-   * Return the element associated with this directive, or {@code null} if the AST structure has not
+   * Return the element associated with this directive, or `null` if the AST structure has not
    * been resolved or if this directive could not be resolved. Examples of the latter case include a
    * directive that contains an invalid URL or a URL that does not exist.
    * @return the element associated with this directive
    */
   Element get element => _element;
 
   /**
    * Return the token representing the keyword that introduces this directive ('import', 'export',
    * 'library' or 'part').
    * @return the token representing the keyword that introduces this directive
    */
   Token get keyword;
 
   /**
    * Set the element associated with this directive to the given element.
    * @param element the element associated with this directive
    */
   void set element(Element element2) {
     this._element = element2;
   }
 }
 /**
- * Instances of the class {@code DoStatement} represent a do statement.
+ * Instances of the class `DoStatement` represent a do statement.
  * <pre>
  * doStatement ::=
- * 'do' {@link Statement body} 'while' '(' {@link Expression condition} ')' ';'
+ * 'do' [Statement body] 'while' '(' [Expression condition] ')' ';'
  * </pre>
  * @coverage dart.engine.ast
  */
 class DoStatement extends Statement {
 
   /**
    * The token representing the 'do' keyword.
    */
   Token _doKeyword;
 
@@ skipping 158 matching lines @@
    */
   void set whileKeyword(Token whileKeyword2) {
     this._whileKeyword = whileKeyword2;
   }
   void visitChildren(ASTVisitor<Object> visitor) {
     safelyVisitChild(_body, visitor);
     safelyVisitChild(_condition, visitor);
   }
 }
 /**
- * Instances of the class {@code DoubleLiteral} represent a floating point literal expression.
+ * Instances of the class `DoubleLiteral` represent a floating point literal expression.
  * <pre>
  * doubleLiteral ::=
  * decimalDigit+ ('.' decimalDigit*)? exponent?
  * | '.' decimalDigit+ exponent?
  * exponent ::=
  * ('e' | 'E') ('+' | '-')? decimalDigit+
  * </pre>
  * @coverage dart.engine.ast
  */
 class DoubleLiteral extends Literal {
@@ skipping 52 matching lines @@
    * Set the value of the literal to the given value.
    * @param value the value of the literal
    */
   void set value(double value2) {
     this._value = value2;
   }
   void visitChildren(ASTVisitor<Object> visitor) {
   }
 }
 /**
- * Instances of the class {@code EmptyFunctionBody} represent an empty function body, which can only
+ * Instances of the class `EmptyFunctionBody` represent an empty function body, which can only
  * appear in constructors or abstract methods.
  * <pre>
  * emptyFunctionBody ::=
  * ';'
  * </pre>
  * @coverage dart.engine.ast
  */
 class EmptyFunctionBody extends FunctionBody {
 
   /**
@@ skipping 29 matching lines @@
    * token.
    * @param semicolon the token representing the semicolon that marks the end of the function body
    */
   void set semicolon(Token semicolon2) {
     this._semicolon = semicolon2;
   }
   void visitChildren(ASTVisitor<Object> visitor) {
   }
 }
 /**
- * Instances of the class {@code EmptyStatement} represent an empty statement.
+ * Instances of the class `EmptyStatement` represent an empty statement.
  * <pre>
  * emptyStatement ::=
  * ';'
  * </pre>
  * @coverage dart.engine.ast
  */
 class EmptyStatement extends Statement {
 
   /**
    * The semicolon terminating the statement.
@@ skipping 37 matching lines @@
  * Ephemeral identifiers are created as needed to mimic the presence of an empty identifier.
  * @coverage dart.engine.ast
  */
 class EphemeralIdentifier extends SimpleIdentifier {
   EphemeralIdentifier.full(ASTNode parent, int location) : super.full(new Token(TokenType.IDENTIFIER, location)) {
     parent.becomeParentOf(this);
   }
   EphemeralIdentifier({ASTNode parent, int location}) : this.full(parent, location);
 }
 /**
- * Instances of the class {@code ExportDirective} represent an export directive.
+ * Instances of the class `ExportDirective` represent an export directive.
  * <pre>
- * exportDirective ::={@link Annotation metadata} 'export' {@link StringLiteral libraryUri} {@link Combinator combinator}* ';'
+ * exportDirective ::=[Annotation metadata] 'export' [StringLiteral libraryUri] [Combinator combinator]* ';'
  * </pre>
  * @coverage dart.engine.ast
  */
 class ExportDirective extends NamespaceDirective {
 
   /**
    * Initialize a newly created export directive.
    * @param comment the documentation comment associated with this directive
    * @param metadata the annotations associated with the directive
    * @param keyword the token representing the 'export' keyword
@@ skipping 21 matching lines @@
       return ((element as ExportElement)).exportedLibrary;
     }
     return null;
   }
   void visitChildren(ASTVisitor<Object> visitor) {
     super.visitChildren(visitor);
     combinators.accept(visitor);
   }
 }
 /**
- * Instances of the class {@code Expression} defines the behavior common to nodes that represent an
+ * Instances of the class `Expression` defines the behavior common to nodes that represent an
  * expression.
  * <pre>
- * expression ::={@link AssignmentExpression assignmentExpression}| {@link ConditionalExpression conditionalExpression} cascadeSection
- * | {@link ThrowExpression throwExpression}</pre>
+ * expression ::=[AssignmentExpression assignmentExpression]| [ConditionalExpression conditionalExpression] cascadeSection
+ * | [ThrowExpression throwExpression]</pre>
  * @coverage dart.engine.ast
  */
 abstract class Expression extends ASTNode {
 
   /**
-   * The static type of this expression, or {@code null} if the AST structure has not been resolved.
+   * The static type of this expression, or `null` if the AST structure has not been resolved.
    */
   Type2 _staticType;
 
   /**
-   * The propagated type of this expression, or {@code null} if type propagation has not been
+   * The propagated type of this expression, or `null` if type propagation has not been
    * performed on the AST structure.
    */
   Type2 _propagatedType;
 
   /**
    * If this expression is an argument to an invocation, and the AST structure has been resolved,
    * and the function being invoked is known based on propagated type information, and this
    * expression corresponds to one of the parameters of the function being invoked, then return the
    * parameter element representing the parameter to which the value of this expression will be
-   * bound. Otherwise, return {@code null}.
+   * bound. Otherwise, return `null`.
    * @return the parameter element representing the parameter to which the value of this expression
    * will be bound
    */
   ParameterElement get parameterElement {
     ASTNode parent = this.parent;
     if (parent is ArgumentList) {
       return ((parent as ArgumentList)).getPropagatedParameterElementFor(this);
     } else if (parent is IndexExpression) {
       IndexExpression indexExpression = parent as IndexExpression;
       if (identical(indexExpression.index, this)) {
         return indexExpression.propagatedParameterElementForIndex;
       }
     } else if (parent is BinaryExpression) {
       BinaryExpression binaryExpression = parent as BinaryExpression;
       if (identical(binaryExpression.rightOperand, this)) {
         return binaryExpression.propagatedParameterElementForRightOperand;
       }
     } else if (parent is PrefixExpression) {
       return ((parent as PrefixExpression)).propagatedParameterElementForOperand;
     } else if (parent is PostfixExpression) {
       return ((parent as PostfixExpression)).propagatedParameterElementForOperand;
     }
     return null;
   }
 
   /**
-   * Return the propagated type of this expression, or {@code null} if type propagation has not been
+   * Return the propagated type of this expression, or `null` if type propagation has not been
    * performed on the AST structure.
    * @return the propagated type of this expression
    */
   Type2 get propagatedType => _propagatedType;
 
   /**
    * If this expression is an argument to an invocation, and the AST structure has been resolved,
    * and the function being invoked is known based on static type information, and this expression
    * corresponds to one of the parameters of the function being invoked, then return the parameter
    * element representing the parameter to which the value of this expression will be bound.
-   * Otherwise, return {@code null}.
+   * Otherwise, return `null`.
    * @return the parameter element representing the parameter to which the value of this expression
    * will be bound
    */
   ParameterElement get staticParameterElement {
     ASTNode parent = this.parent;
     if (parent is ArgumentList) {
       return ((parent as ArgumentList)).getStaticParameterElementFor(this);
     } else if (parent is IndexExpression) {
       IndexExpression indexExpression = parent as IndexExpression;
       if (identical(indexExpression.index, this)) {
         return indexExpression.staticParameterElementForIndex;
       }
     } else if (parent is BinaryExpression) {
       BinaryExpression binaryExpression = parent as BinaryExpression;
       if (identical(binaryExpression.rightOperand, this)) {
         return binaryExpression.staticParameterElementForRightOperand;
       }
     } else if (parent is PrefixExpression) {
       return ((parent as PrefixExpression)).staticParameterElementForOperand;
     } else if (parent is PostfixExpression) {
       return ((parent as PostfixExpression)).staticParameterElementForOperand;
     }
     return null;
   }
 
   /**
-   * Return the static type of this expression, or {@code null} if the AST structure has not been
+   * Return the static type of this expression, or `null` if the AST structure has not been
    * resolved.
    * @return the static type of this expression
    */
   Type2 get staticType => _staticType;
 
   /**
-   * Return {@code true} if this expression is syntactically valid for the LHS of an{@link AssignmentExpression assignment expression}.
-   * @return {@code true} if this expression matches the {@code assignableExpression} production
+   * Return `true` if this expression is syntactically valid for the LHS of an[AssignmentExpression assignment expression].
+   * @return `true` if this expression matches the `assignableExpression` production
    */
   bool isAssignable() => false;
 
   /**
    * Set the propagated type of this expression to the given type.
    * @param propagatedType the propagated type of this expression
    */
   void set propagatedType(Type2 propagatedType2) {
     this._propagatedType = propagatedType2;
   }
 
   /**
    * Set the static type of this expression to the given type.
    * @param staticType the static type of this expression
    */
   void set staticType(Type2 staticType2) {
     this._staticType = staticType2;
   }
 }
 /**
- * Instances of the class {@code ExpressionFunctionBody} represent a function body consisting of a
+ * Instances of the class `ExpressionFunctionBody` represent a function body consisting of a
  * single expression.
  * <pre>
  * expressionFunctionBody ::=
- * '=>' {@link Expression expression} ';'
+ * '=>' [Expression expression] ';'
  * </pre>
  * @coverage dart.engine.ast
  */
 class ExpressionFunctionBody extends FunctionBody {
 
   /**
    * The token introducing the expression that represents the body of the function.
    */
   Token _functionDefinition;
 
@@ skipping 77 matching lines @@
    * @param semicolon the semicolon terminating the statement
    */
   void set semicolon(Token semicolon2) {
     this._semicolon = semicolon2;
   }
   void visitChildren(ASTVisitor<Object> visitor) {
     safelyVisitChild(_expression, visitor);
   }
 }
 /**
- * Instances of the class {@code ExpressionStatement} wrap an expression as a statement.
+ * Instances of the class `ExpressionStatement` wrap an expression as a statement.
  * <pre>
- * expressionStatement ::={@link Expression expression}? ';'
+ * expressionStatement ::=[Expression expression]? ';'
  * </pre>
  * @coverage dart.engine.ast
  */
 class ExpressionStatement extends Statement {
 
   /**
    * The expression that comprises the statement.
    */
   Expression _expression;
 
   /**
-   * The semicolon terminating the statement, or {@code null} if the expression is a function
+   * The semicolon terminating the statement, or `null` if the expression is a function
    * expression and isn't followed by a semicolon.
    */
   Token _semicolon;
 
   /**
    * Initialize a newly created expression statement.
    * @param expression the expression that comprises the statement
    * @param semicolon the semicolon terminating the statement
    */
   ExpressionStatement.full(Expression expression, Token semicolon) {
@@ skipping 42 matching lines @@
    * @param semicolon the semicolon terminating the statement
    */
   void set semicolon(Token semicolon2) {
     this._semicolon = semicolon2;
   }
   void visitChildren(ASTVisitor<Object> visitor) {
     safelyVisitChild(_expression, visitor);
   }
 }
 /**
- * Instances of the class {@code ExtendsClause} represent the "extends" clause in a class
+ * Instances of the class `ExtendsClause` represent the "extends" clause in a class
  * declaration.
  * <pre>
  * extendsClause ::=
- * 'extends' {@link TypeName superclass}</pre>
+ * 'extends' [TypeName superclass]</pre>
  * @coverage dart.engine.ast
  */
 class ExtendsClause extends ASTNode {
 
   /**
    * The token representing the 'extends' keyword.
    */
   Token _keyword;
 
   /**
@@ skipping 46 matching lines @@
    * @param name the name of the class that is being extended
    */
   void set superclass(TypeName name) {
     _superclass = becomeParentOf(name);
   }
   void visitChildren(ASTVisitor<Object> visitor) {
     safelyVisitChild(_superclass, visitor);
   }
 }
 /**
- * Instances of the class {@code FieldDeclaration} represent the declaration of one or more fields
+ * Instances of the class `FieldDeclaration` represent the declaration of one or more fields
  * of the same type.
  * <pre>
  * fieldDeclaration ::=
- * 'static'? {@link VariableDeclarationList fieldList} ';'
+ * 'static'? [VariableDeclarationList fieldList] ';'
  * </pre>
  * @coverage dart.engine.ast
  */
 class FieldDeclaration extends ClassMember {
 
   /**
-   * The token representing the 'static' keyword, or {@code null} if the fields are not static.
+   * The token representing the 'static' keyword, or `null` if the fields are not static.
    */
   Token _keyword;
 
   /**
    * The fields being declared.
    */
   VariableDeclarationList _fieldList;
 
   /**
    * The semicolon terminating the declaration.
@@ skipping 27 matching lines @@
   Element get element => null;
   Token get endToken => _semicolon;
 
   /**
    * Return the fields being declared.
    * @return the fields being declared
    */
   VariableDeclarationList get fields => _fieldList;
 
   /**
-   * Return the token representing the 'static' keyword, or {@code null} if the fields are not
+   * Return the token representing the 'static' keyword, or `null` if the fields are not
    * static.
    * @return the token representing the 'static' keyword
    */
   Token get keyword => _keyword;
 
   /**
    * Return the semicolon terminating the declaration.
    * @return the semicolon terminating the declaration
    */
   Token get semicolon => _semicolon;
 
   /**
-   * Return {@code true} if the fields are static.
-   * @return {@code true} if the fields are declared to be static
+   * Return `true` if the fields are static.
+   * @return `true` if the fields are declared to be static
    */
   bool isStatic() => _keyword != null;
 
   /**
    * Set the fields being declared to the given list of variables.
    * @param fieldList the fields being declared
    */
   void set fields(VariableDeclarationList fieldList) {
     fieldList = becomeParentOf(fieldList);
   }
@@ skipping 18 matching lines @@
     safelyVisitChild(_fieldList, visitor);
   }
   Token get firstTokenAfterCommentAndMetadata {
     if (_keyword != null) {
       return _keyword;
     }
     return _fieldList.beginToken;
   }
 }
 /**
- * Instances of the class {@code FieldFormalParameter} represent a field formal parameter.
+ * Instances of the class `FieldFormalParameter` represent a field formal parameter.
  * <pre>
  * fieldFormalParameter ::=
- * ('final' {@link TypeName type} | 'const' {@link TypeName type} | 'var' | {@link TypeName type})? 'this' '.' {@link SimpleIdentifier identifier}</pre>
+ * ('final' [TypeName type] | 'const' [TypeName type] | 'var' | [TypeName type])? 'this' '.' [SimpleIdentifier identifier]</pre>
  * @coverage dart.engine.ast
  */
 class FieldFormalParameter extends NormalFormalParameter {
 
   /**
-   * The token representing either the 'final', 'const' or 'var' keyword, or {@code null} if no
+   * The token representing either the 'final', 'const' or 'var' keyword, or `null` if no
    * keyword was used.
    */
   Token _keyword;
 
   /**
-   * The name of the declared type of the parameter, or {@code null} if the parameter does not have
+   * The name of the declared type of the parameter, or `null` if the parameter does not have
    * a declared type.
    */
   TypeName _type;
 
   /**
    * The token representing the 'this' keyword.
    */
   Token _thisToken;
 
   /**
@@ skipping 52 matching lines @@
    */
   Token get period => _period;
 
   /**
    * Return the token representing the 'this' keyword.
    * @return the token representing the 'this' keyword
    */
   Token get thisToken => _thisToken;
 
   /**
-   * Return the name of the declared type of the parameter, or {@code null} if the parameter does
+   * Return the name of the declared type of the parameter, or `null` if the parameter does
    * not have a declared type.
    * @return the name of the declared type of the parameter
    */
   TypeName get type => _type;
   bool isConst() => (_keyword is KeywordToken) && identical(((_keyword as KeywordToken)).keyword, Keyword.CONST);
   bool isFinal() => (_keyword is KeywordToken) && identical(((_keyword as KeywordToken)).keyword, Keyword.FINAL);
 
   /**
    * Set the token representing either the 'final', 'const' or 'var' keyword to the given token.
    * @param keyword the token representing either the 'final', 'const' or 'var' keyword
@@ skipping 25 matching lines @@
   void set type(TypeName typeName) {
     _type = becomeParentOf(typeName);
   }
   void visitChildren(ASTVisitor<Object> visitor) {
     super.visitChildren(visitor);
     safelyVisitChild(_type, visitor);
     safelyVisitChild(identifier, visitor);
   }
 }
 /**
- * Instances of the class {@code ForEachStatement} represent a for-each statement.
+ * Instances of the class `ForEachStatement` represent a for-each statement.
  * <pre>
  * forEachStatement ::=
- * 'for' '(' {@link SimpleFormalParameter loopParameter} 'in' {@link Expression iterator} ')' {@link Block body}</pre>
+ * 'for' '(' [SimpleFormalParameter loopParameter] 'in' [Expression iterator] ')' [Block body]</pre>
  * @coverage dart.engine.ast
  */
 class ForEachStatement extends Statement {
 
   /**
    * The token representing the 'for' keyword.
    */
   Token _forKeyword;
 
   /**
@@ skipping 156 matching lines @@
   void set rightParenthesis(Token rightParenthesis2) {
     this._rightParenthesis = rightParenthesis2;
   }
   void visitChildren(ASTVisitor<Object> visitor) {
     safelyVisitChild(_loopVariable, visitor);
     safelyVisitChild(_iterator, visitor);
     safelyVisitChild(_body, visitor);
   }
 }
 /**
- * Instances of the class {@code ForStatement} represent a for statement.
+ * Instances of the class `ForStatement` represent a for statement.
  * <pre>
  * forStatement ::=
- * 'for' '(' forLoopParts ')' {@link Statement statement}forLoopParts ::=
- * forInitializerStatement ';' {@link Expression expression}? ';' {@link Expression expressionList}?
- * forInitializerStatement ::={@link DefaultFormalParameter initializedVariableDeclaration}| {@link Expression expression}?
+ * 'for' '(' forLoopParts ')' [Statement statement]forLoopParts ::=
+ * forInitializerStatement ';' [Expression expression]? ';' [Expression expressionList]?
+ * forInitializerStatement ::=[DefaultFormalParameter initializedVariableDeclaration]| [Expression expression]?
  * </pre>
  * @coverage dart.engine.ast
  */
 class ForStatement extends Statement {
 
   /**
    * The token representing the 'for' keyword.
    */
   Token _forKeyword;
 
   /**
    * The left parenthesis.
    */
   Token _leftParenthesis;
 
   /**
-   * The declaration of the loop variables, or {@code null} if there are no variables. Note that a
+   * The declaration of the loop variables, or `null` if there are no variables. Note that a
    * for statement cannot have both a variable list and an initialization expression, but can
    * validly have neither.
    */
   VariableDeclarationList _variableList;
 
   /**
-   * The initialization expression, or {@code null} if there is no initialization expression. Note
+   * The initialization expression, or `null` if there is no initialization expression. Note
    * that a for statement cannot have both a variable list and an initialization expression, but can
    * validly have neither.
    */
   Expression _initialization;
 
   /**
    * The semicolon separating the initializer and the condition.
    */
   Token _leftSeparator;
 
@@ skipping 79 matching lines @@
   Expression get condition => _condition;
   Token get endToken => _body.endToken;
 
   /**
    * Return the token representing the 'for' keyword.
    * @return the token representing the 'for' keyword
    */
   Token get forKeyword => _forKeyword;
 
   /**
-   * Return the initialization expression, or {@code null} if there is no initialization expression.
+   * Return the initialization expression, or `null` if there is no initialization expression.
    * @return the initialization expression
    */
   Expression get initialization => _initialization;
 
   /**
    * Return the left parenthesis.
    * @return the left parenthesis
    */
   Token get leftParenthesis => _leftParenthesis;
 
@@ skipping 15 matching lines @@
    */
   Token get rightSeparator => _rightSeparator;
 
   /**
    * Return the list of expressions run after each execution of the loop body.
    * @return the list of expressions run after each execution of the loop body
    */
   NodeList<Expression> get updaters => _updaters;
 
   /**
-   * Return the declaration of the loop variables, or {@code null} if there are no variables.
-   * @return the declaration of the loop variables, or {@code null} if there are no variables
+   * Return the declaration of the loop variables, or `null` if there are no variables.
+   * @return the declaration of the loop variables, or `null` if there are no variables
    */
   VariableDeclarationList get variables => _variableList;
 
   /**
    * Set the body of the loop to the given statement.
    * @param body the body of the loop
    */
   void set body(Statement body2) {
     this._body = becomeParentOf(body2);
   }
@@ skipping 63 matching lines @@
   }
   void visitChildren(ASTVisitor<Object> visitor) {
     safelyVisitChild(_variableList, visitor);
     safelyVisitChild(_initialization, visitor);
     safelyVisitChild(_condition, visitor);
     _updaters.accept(visitor);
     safelyVisitChild(_body, visitor);
   }
 }
 /**
- * The abstract class {@code FormalParameter} defines the behavior of objects representing a
+ * The abstract class `FormalParameter` defines the behavior of objects representing a
  * parameter to a function.
  * <pre>
- * formalParameter ::={@link NormalFormalParameter normalFormalParameter}| {@link DefaultFormalParameter namedFormalParameter}| {@link DefaultFormalParameter optionalFormalParameter}</pre>
+ * formalParameter ::=[NormalFormalParameter normalFormalParameter]| [DefaultFormalParameter namedFormalParameter]| [DefaultFormalParameter optionalFormalParameter]</pre>
  * @coverage dart.engine.ast
  */
 abstract class FormalParameter extends ASTNode {
 
   /**
-   * Return the element representing this parameter, or {@code null} if this parameter has not been
+   * Return the element representing this parameter, or `null` if this parameter has not been
    * resolved.
    * @return the element representing this parameter
    */
   ParameterElement get element {
     SimpleIdentifier identifier = this.identifier;
     if (identifier == null) {
       return null;
     }
     return identifier.element as ParameterElement;
   }
 
   /**
    * Return the name of the parameter being declared.
    * @return the name of the parameter being declared
    */
   SimpleIdentifier get identifier;
 
   /**
    * Return the kind of this parameter.
    * @return the kind of this parameter
    */
   ParameterKind get kind;
 }
 /**
- * Instances of the class {@code FormalParameterList} represent the formal parameter list of a
+ * Instances of the class `FormalParameterList` represent the formal parameter list of a
  * method declaration, function declaration, or function type alias.
- * <p>
+ *
  * 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.
  * <pre>
  * formalParameterList ::=
  * '(' ')'
  * | '(' normalFormalParameters (',' optionalFormalParameters)? ')'
  * | '(' optionalFormalParameters ')'
- * normalFormalParameters ::={@link NormalFormalParameter normalFormalParameter} (',' {@link NormalFormalParameter normalFormalParameter})
+ * normalFormalParameters ::=[NormalFormalParameter normalFormalParameter] (',' [NormalFormalParameter normalFormalParameter])
  * optionalFormalParameters ::=
  * optionalPositionalFormalParameters
  * | namedFormalParameters
  * optionalPositionalFormalParameters ::=
- * '\[' {@link DefaultFormalParameter positionalFormalParameter} (',' {@link DefaultFormalParameter positionalFormalParameter})* '\]'
+ * '\[' [DefaultFormalParameter positionalFormalParameter] (',' [DefaultFormalParameter positionalFormalParameter])* '\]'
  * namedFormalParameters ::=
- * '{' {@link DefaultFormalParameter namedFormalParameter} (',' {@link DefaultFormalParameter namedFormalParameter})* '}'
+ * '{' [DefaultFormalParameter namedFormalParameter] (',' [DefaultFormalParameter namedFormalParameter])* '}'
  * </pre>
  * @coverage dart.engine.ast
  */
 class FormalParameterList extends ASTNode {
 
   /**
    * The left parenthesis.
    */
   Token _leftParenthesis;
 
@@ skipping 41 matching lines @@
    * @param leftDelimiter the left delimiter introducing the optional parameters
    * @param rightDelimiter the right delimiter introducing the optional parameters
    * @param rightParenthesis the right parenthesis
    */
   FormalParameterList({Token leftParenthesis, List<FormalParameter> parameters, Token leftDelimiter, Token rightDelimiter, Token rightParenthesis}) : this.full(leftParenthesis, parameters, leftDelimiter, rightDelimiter, rightParenthesis);
   accept(ASTVisitor visitor) => visitor.visitFormalParameterList(this);
   Token get beginToken => _leftParenthesis;
 
   /**
    * Return an array containing the elements representing the parameters in this list. The array
-   * will contain {@code null}s if the parameters in this list have not been resolved.
+   * will contain `null`s if the parameters in this list have not been resolved.
    * @return the elements representing the parameters in this list
    */
   List<ParameterElement> get elements {
     int count = _parameters.length;
     List<ParameterElement> types = new List<ParameterElement>(count);
     for (int i = 0; i < count; i++) {
       types[i] = _parameters[i].element;
     }
     return types;
   }
@@ skipping 64 matching lines @@
    * @param parenthesis the right parenthesis
    */
   void set rightParenthesis(Token parenthesis) {
     _rightParenthesis = parenthesis;
   }
   void visitChildren(ASTVisitor<Object> visitor) {
     _parameters.accept(visitor);
   }
 }
 /**
- * The abstract class {@code FunctionBody} defines the behavior common to objects representing the
+ * The abstract class `FunctionBody` defines the behavior common to objects representing the
  * body of a function or method.
  * <pre>
- * functionBody ::={@link BlockFunctionBody blockFunctionBody}| {@link EmptyFunctionBody emptyFunctionBody}| {@link ExpressionFunctionBody expressionFunctionBody}</pre>
+ * functionBody ::=[BlockFunctionBody blockFunctionBody]| [EmptyFunctionBody emptyFunctionBody]| [ExpressionFunctionBody expressionFunctionBody]</pre>
  * @coverage dart.engine.ast
  */
 abstract class FunctionBody extends ASTNode {
 }
 /**
- * Instances of the class {@code FunctionDeclaration} wrap a {@link FunctionExpression function
- * expression} as a top-level declaration.
+ * Instances of the class `FunctionDeclaration` wrap a [FunctionExpression function
+ * expression] as a top-level declaration.
  * <pre>
  * functionDeclaration ::=
  * 'external' functionSignature
- * | functionSignature {@link FunctionBody functionBody}functionSignature ::={@link Type returnType}? ('get' | 'set')? {@link SimpleIdentifier functionName} {@link FormalParameterList formalParameterList}</pre>
+ * | functionSignature [FunctionBody functionBody]functionSignature ::=[Type returnType]? ('get' | 'set')? [SimpleIdentifier functionName] [FormalParameterList formalParameterList]</pre>
  * @coverage dart.engine.ast
  */
 class FunctionDeclaration extends CompilationUnitMember {
 
   /**
-   * The token representing the 'external' keyword, or {@code null} if this is not an external
+   * The token representing the 'external' keyword, or `null` if this is not an external
    * function.
    */
   Token _externalKeyword;
 
   /**
-   * The return type of the function, or {@code null} if no return type was declared.
+   * The return type of the function, or `null` if no return type was declared.
    */
   TypeName _returnType;
 
   /**
-   * The token representing the 'get' or 'set' keyword, or {@code null} if this is a function
+   * The token representing the 'get' or 'set' keyword, or `null` if this is a function
    * declaration rather than a property declaration.
    */
   Token _propertyKeyword;
 
   /**
-   * The name of the function, or {@code null} if the function is not named.
+   * The name of the function, or `null` if the function is not named.
    */
   SimpleIdentifier _name;
 
   /**
    * The function expression being wrapped.
    */
   FunctionExpression _functionExpression;
 
   /**
    * Initialize a newly created function declaration.
@@ skipping 22 matching lines @@
    * @param propertyKeyword the token representing the 'get' or 'set' keyword
    * @param name the name of the function
    * @param functionExpression the function expression being wrapped
    */
   FunctionDeclaration({Comment comment, List<Annotation> metadata, Token externalKeyword, TypeName returnType, Token propertyKeyword, SimpleIdentifier name, FunctionExpression functionExpression}) : this.full(comment, metadata, externalKeyword, returnType, propertyKeyword, name, functionExpression);
   accept(ASTVisitor visitor) => visitor.visitFunctionDeclaration(this);
   ExecutableElement get element => _name != null ? (_name.element as ExecutableElement) : null;
   Token get endToken => _functionExpression.endToken;
 
   /**
-   * Return the token representing the 'external' keyword, or {@code null} if this is not an
+   * Return the token representing the 'external' keyword, or `null` if this is not an
    * external function.
    * @return the token representing the 'external' keyword
    */
   Token get externalKeyword => _externalKeyword;
 
   /**
    * Return the function expression being wrapped.
    * @return the function expression being wrapped
    */
   FunctionExpression get functionExpression => _functionExpression;
 
   /**
-   * Return the name of the function, or {@code null} if the function is not named.
+   * Return the name of the function, or `null` if the function is not named.
    * @return the name of the function
    */
   SimpleIdentifier get name => _name;
 
   /**
-   * Return the token representing the 'get' or 'set' keyword, or {@code null} if this is a function
+   * Return the token representing the 'get' or 'set' keyword, or `null` if this is a function
    * declaration rather than a property declaration.
    * @return the token representing the 'get' or 'set' keyword
    */
   Token get propertyKeyword => _propertyKeyword;
 
   /**
-   * Return the return type of the function, or {@code null} if no return type was declared.
+   * Return the return type of the function, or `null` if no return type was declared.
    * @return the return type of the function
    */
   TypeName get returnType => _returnType;
 
   /**
-   * Return {@code true} if this function declares a getter.
-   * @return {@code true} if this function declares a getter
+   * Return `true` if this function declares a getter.
+   * @return `true` if this function declares a getter
    */
   bool isGetter() => _propertyKeyword != null && identical(((_propertyKeyword as KeywordToken)).keyword, Keyword.GET);
 
   /**
-   * Return {@code true} if this function declares a setter.
-   * @return {@code true} if this function declares a setter
+   * Return `true` if this function declares a setter.
+   * @return `true` if this function declares a setter
    */
   bool isSetter() => _propertyKeyword != null && identical(((_propertyKeyword as KeywordToken)).keyword, Keyword.SET);
 
   /**
    * Set the token representing the 'external' keyword to the given token.
    * @param externalKeyword the token representing the 'external' keyword
    */
   void set externalKeyword(Token externalKeyword2) {
     this._externalKeyword = externalKeyword2;
   }
@@ skipping 43 matching lines @@
       return _returnType.beginToken;
     } else if (_propertyKeyword != null) {
       return _propertyKeyword;
     } else if (_name != null) {
       return _name.beginToken;
     }
     return _functionExpression.beginToken;
   }
 }
 /**
- * Instances of the class {@code FunctionDeclarationStatement} wrap a {@link FunctionDeclarationfunction declaration} as a statement.
+ * Instances of the class `FunctionDeclarationStatement` wrap a [FunctionDeclarationfunction declaration] as a statement.
  * @coverage dart.engine.ast
  */
 class FunctionDeclarationStatement extends Statement {
 
   /**
    * The function declaration being wrapped.
    */
   FunctionDeclaration _functionDeclaration;
 
   /**
@@ skipping 24 matching lines @@
    * @param functionDeclaration the function declaration being wrapped
    */
   void set functionExpression(FunctionDeclaration functionDeclaration2) {
     this._functionDeclaration = becomeParentOf(functionDeclaration2);
   }
   void visitChildren(ASTVisitor<Object> visitor) {
     safelyVisitChild(_functionDeclaration, visitor);
   }
 }
 /**
- * Instances of the class {@code FunctionExpression} represent a function expression.
+ * Instances of the class `FunctionExpression` represent a function expression.
  * <pre>
- * functionExpression ::={@link FormalParameterList formalParameterList} {@link FunctionBody functionBody}</pre>
+ * functionExpression ::=[FormalParameterList formalParameterList] [FunctionBody functionBody]</pre>
  * @coverage dart.engine.ast
  */
 class FunctionExpression extends Expression {
 
   /**
    * The parameters associated with the function.
    */
   FormalParameterList _parameters;
 
   /**
-   * The body of the function, or {@code null} if this is an external function.
+   * The body of the function, or `null` if this is an external function.
    */
   FunctionBody _body;
 
   /**
-   * The element associated with the function, or {@code null} if the AST structure has not been
+   * The element associated with the function, or `null` if the AST structure has not been
    * resolved.
    */
   ExecutableElement _element;
 
   /**
    * Initialize a newly created function declaration.
    * @param parameters the parameters associated with the function
    * @param body the body of the function
    */
   FunctionExpression.full(FormalParameterList parameters, FunctionBody body) {
@@ skipping 11 matching lines @@
   Token get beginToken {
     if (_parameters != null) {
       return _parameters.beginToken;
     } else if (_body != null) {
       return _body.beginToken;
     }
     throw new IllegalStateException("Non-external functions must have a body");
   }
 
   /**
-   * Return the body of the function, or {@code null} if this is an external function.
+   * Return the body of the function, or `null` if this is an external function.
    * @return the body of the function
    */
   FunctionBody get body => _body;
 
   /**
-   * Return the element associated with this function, or {@code null} if the AST structure has not
+   * Return the element associated with this function, or `null` if the AST structure has not
    * been resolved.
    * @return the element associated with this function
    */
   ExecutableElement get element => _element;
   Token get endToken {
     if (_body != null) {
       return _body.endToken;
     } else if (_parameters != null) {
       return _parameters.endToken;
     }
@@ skipping 28 matching lines @@
    */
   void set parameters(FormalParameterList parameters2) {
     this._parameters = becomeParentOf(parameters2);
   }
   void visitChildren(ASTVisitor<Object> visitor) {
     safelyVisitChild(_parameters, visitor);
     safelyVisitChild(_body, visitor);
   }
 }
 /**
- * Instances of the class {@code FunctionExpressionInvocation} represent the invocation of a
+ * Instances of the class `FunctionExpressionInvocation` represent the invocation of a
  * function resulting from evaluating an expression. Invocations of methods and other forms of
- * functions are represented by {@link MethodInvocation method invocation} nodes. Invocations of
- * getters and setters are represented by either {@link PrefixedIdentifier prefixed identifier} or{@link PropertyAccess property access} nodes.
+ * functions are represented by [MethodInvocation method invocation] nodes. Invocations of
+ * getters and setters are represented by either [PrefixedIdentifier prefixed identifier] or[PropertyAccess property access] nodes.
  * <pre>
- * functionExpressionInvoction ::={@link Expression function} {@link ArgumentList argumentList}</pre>
+ * functionExpressionInvoction ::=[Expression function] [ArgumentList argumentList]</pre>
  * @coverage dart.engine.ast
  */
 class FunctionExpressionInvocation extends Expression {
 
   /**
    * The expression producing the function being invoked.
    */
   Expression _function;
 
   /**
    * The list of arguments to the function.
    */
   ArgumentList _argumentList;
 
   /**
-   * The element associated with the function being invoked based on static type information, or{@code null} if the AST structure has not been resolved or the function could not be resolved.
+   * The element associated with the function being invoked based on static type information, or`null` if the AST structure has not been resolved or the function could not be resolved.
    */
   ExecutableElement _staticElement;
 
   /**
-   * The element associated with the function being invoked based on propagated type information, or{@code null} if the AST structure has not been resolved or the function could not be resolved.
+   * The element associated with the function being invoked based on propagated type information, or`null` if the AST structure has not been resolved or the function could not be resolved.
    */
   ExecutableElement _propagatedElement;
 
   /**
    * Initialize a newly created function expression invocation.
    * @param function the expression producing the function being invoked
    * @param argumentList the list of arguments to the method
    */
   FunctionExpressionInvocation.full(Expression function, ArgumentList argumentList) {
     this._function = becomeParentOf(function);
@@ skipping 10 matching lines @@
 
   /**
    * Return the list of arguments to the method.
    * @return the list of arguments to the method
    */
   ArgumentList get argumentList => _argumentList;
   Token get beginToken => _function.beginToken;
 
   /**
    * Return the element associated with the function being invoked based on propagated type
-   * information, or {@code null} if the AST structure has not been resolved or the function could
+   * information, or `null` if the AST structure has not been resolved or the function could
    * not be resolved. One common example of the latter case is an expression whose value can change
    * over time.
    * @return the element associated with the function being invoked
    */
   ExecutableElement get element => _propagatedElement;
   Token get endToken => _argumentList.endToken;
 
   /**
    * Return the expression producing the function being invoked.
    * @return the expression producing the function being invoked
    */
   Expression get function => _function;
 
   /**
    * Return the element associated with the function being invoked based on static type information,
-   * or {@code null} if the AST structure has not been resolved or the function could not be
+   * or `null` if the AST structure has not been resolved or the function could not be
    * resolved. One common example of the latter case is an expression whose value can change over
    * time.
    * @return the element associated with the function
    */
   ExecutableElement get staticElement => _staticElement;
 
   /**
    * Set the list of arguments to the method to the given list.
    * @param argumentList the list of arguments to the method
    */
@@ skipping 25 matching lines @@
    */
   void set staticElement(ExecutableElement element) {
     this._staticElement = element;
   }
   void visitChildren(ASTVisitor<Object> visitor) {
     safelyVisitChild(_function, visitor);
     safelyVisitChild(_argumentList, visitor);
   }
 }
 /**
- * Instances of the class {@code FunctionTypeAlias} represent a function type alias.
+ * Instances of the class `FunctionTypeAlias` represent a function type alias.
  * <pre>
  * functionTypeAlias ::=
- * functionPrefix {@link TypeParameterList typeParameterList}? {@link FormalParameterList formalParameterList} ';'
- * functionPrefix ::={@link TypeName returnType}? {@link SimpleIdentifier name}</pre>
+ * functionPrefix [TypeParameterList typeParameterList]? [FormalParameterList formalParameterList] ';'
+ * functionPrefix ::=[TypeName returnType]? [SimpleIdentifier name]</pre>
  * @coverage dart.engine.ast
  */
 class FunctionTypeAlias extends TypeAlias {
 
   /**
-   * The name of the return type of the function type being defined, or {@code null} if no return
+   * The name of the return type of the function type being defined, or `null` if no return
    * type was given.
    */
   TypeName _returnType;
 
   /**
    * The name of the function type being declared.
    */
   SimpleIdentifier _name;
 
   /**
-   * The type parameters for the function type, or {@code null} if the function type does not have
+   * The type parameters for the function type, or `null` if the function type does not have
    * any type parameters.
    */
   TypeParameterList _typeParameters;
 
   /**
    * The parameters associated with the function type.
    */
   FormalParameterList _parameters;
 
   /**
@@ skipping 35 matching lines @@
    */
   SimpleIdentifier get name => _name;
 
   /**
    * Return the parameters associated with the function type.
    * @return the parameters associated with the function type
    */
   FormalParameterList get parameters => _parameters;
 
   /**
-   * Return the name of the return type of the function type being defined, or {@code null} if no
+   * Return the name of the return type of the function type being defined, or `null` if no
    * return type was given.
    * @return the name of the return type of the function type being defined
    */
   TypeName get returnType => _returnType;
 
   /**
-   * Return the type parameters for the function type, or {@code null} if the function type does not
+   * Return the type parameters for the function type, or `null` if the function type does not
    * have any type parameters.
    * @return the type parameters for the function type
    */
   TypeParameterList get typeParameters => _typeParameters;
 
   /**
    * Set the name of the function type being declared to the given identifier.
    * @param name the name of the function type being declared
    */
   void set name(SimpleIdentifier name2) {
@@ skipping 25 matching lines @@
   }
   void visitChildren(ASTVisitor<Object> visitor) {
     super.visitChildren(visitor);
     safelyVisitChild(_returnType, visitor);
     safelyVisitChild(_name, visitor);
     safelyVisitChild(_typeParameters, visitor);
     safelyVisitChild(_parameters, visitor);
   }
 }
 /**
- * Instances of the class {@code FunctionTypedFormalParameter} represent a function-typed formal
+ * Instances of the class `FunctionTypedFormalParameter` represent a function-typed formal
  * parameter.
  * <pre>
- * functionSignature ::={@link TypeName returnType}? {@link SimpleIdentifier identifier} {@link FormalParameterList formalParameterList}</pre>
+ * functionSignature ::=[TypeName returnType]? [SimpleIdentifier identifier] [FormalParameterList formalParameterList]</pre>
  * @coverage dart.engine.ast
  */
 class FunctionTypedFormalParameter extends NormalFormalParameter {
 
   /**
-   * The return type of the function, or {@code null} if the function does not have a return type.
+   * The return type of the function, or `null` if the function does not have a return type.
    */
   TypeName _returnType;
 
   /**
    * The parameters of the function-typed parameter.
    */
   FormalParameterList _parameters;
 
   /**
    * Initialize a newly created formal parameter.
    * @param comment the documentation comment associated with this parameter
    * @param metadata the annotations associated with this parameter
-   * @param returnType the return type of the function, or {@code null} if the function does not
+   * @param returnType the return type of the function, or `null` if the function does not
    * have a return type
    * @param identifier the name of the function-typed parameter
    * @param parameters the parameters of the function-typed parameter
    */
   FunctionTypedFormalParameter.full(Comment comment, List<Annotation> metadata, TypeName returnType, SimpleIdentifier identifier, FormalParameterList parameters) : super.full(comment, metadata, identifier) {
     this._returnType = becomeParentOf(returnType);
     this._parameters = becomeParentOf(parameters);
   }
 
   /**
    * Initialize a newly created formal parameter.
    * @param comment the documentation comment associated with this parameter
    * @param metadata the annotations associated with this parameter
-   * @param returnType the return type of the function, or {@code null} if the function does not
+   * @param returnType the return type of the function, or `null` if the function does not
    * have a return type
    * @param identifier the name of the function-typed parameter
    * @param parameters the parameters of the function-typed parameter
    */
   FunctionTypedFormalParameter({Comment comment, List<Annotation> metadata, TypeName returnType, SimpleIdentifier identifier, FormalParameterList parameters}) : this.full(comment, metadata, returnType, identifier, parameters);
   accept(ASTVisitor visitor) => visitor.visitFunctionTypedFormalParameter(this);
   Token get beginToken {
     if (_returnType != null) {
       return _returnType.beginToken;
     }
     return identifier.beginToken;
   }
   Token get endToken => _parameters.endToken;
 
   /**
    * Return the parameters of the function-typed parameter.
    * @return the parameters of the function-typed parameter
    */
   FormalParameterList get parameters => _parameters;
 
   /**
-   * Return the return type of the function, or {@code null} if the function does not have a return
+   * Return the return type of the function, or `null` if the function does not have a return
    * type.
    * @return the return type of the function
    */
   TypeName get returnType => _returnType;
   bool isConst() => false;
   bool isFinal() => false;
 
   /**
    * Set the parameters of the function-typed parameter to the given parameters.
    * @param parameters the parameters of the function-typed parameter
@@ skipping 10 matching lines @@
     this._returnType = becomeParentOf(returnType2);
   }
   void visitChildren(ASTVisitor<Object> visitor) {
     super.visitChildren(visitor);
     safelyVisitChild(_returnType, visitor);
     safelyVisitChild(identifier, visitor);
     safelyVisitChild(_parameters, visitor);
   }
 }
 /**
- * Instances of the class {@code HideCombinator} represent a combinator that restricts the names
+ * Instances of the class `HideCombinator` represent a combinator that restricts the names
  * being imported to those that are not in a given list.
  * <pre>
  * hideCombinator ::=
- * 'hide' {@link SimpleIdentifier identifier} (',' {@link SimpleIdentifier identifier})
+ * 'hide' [SimpleIdentifier identifier] (',' [SimpleIdentifier identifier])
  * </pre>
  * @coverage dart.engine.ast
  */
 class HideCombinator extends Combinator {
 
   /**
    * The list of names from the library that are hidden by this combinator.
    */
   NodeList<SimpleIdentifier> _hiddenNames;
 
@@ skipping 19 matching lines @@
   /**
    * Return the list of names from the library that are hidden by this combinator.
    * @return the list of names from the library that are hidden by this combinator
    */
   NodeList<SimpleIdentifier> get hiddenNames => _hiddenNames;
   void visitChildren(ASTVisitor<Object> visitor) {
     _hiddenNames.accept(visitor);
   }
 }
 /**
- * The abstract class {@code Identifier} defines the behavior common to nodes that represent an
+ * The abstract class `Identifier` defines the behavior common to nodes that represent an
  * identifier.
  * <pre>
- * identifier ::={@link SimpleIdentifier simpleIdentifier}| {@link PrefixedIdentifier prefixedIdentifier}</pre>
+ * identifier ::=[SimpleIdentifier simpleIdentifier]| [PrefixedIdentifier prefixedIdentifier]</pre>
  * @coverage dart.engine.ast
  */
 abstract class Identifier extends Expression {
 
   /**
-   * Return {@code true} if the given name is visible only within the library in which it is
+   * Return `true` if the given name is visible only within the library in which it is
    * declared.
    * @param name the name being tested
-   * @return {@code true} if the given name is private
+   * @return `true` if the given name is private
    */
   static bool isPrivateName(String name) => name.startsWith("_");
 
   /**
-   * Return the element associated with this identifier based on propagated type information, or{@code null} if the AST structure has not been resolved or if this identifier could not be
+   * Return the element associated with this identifier based on propagated type information, or`null` if the AST structure has not been resolved or if this identifier could not be
    * resolved. One example of the latter case is an identifier that is not defined within the scope
    * in which it appears.
    * @return the element associated with this identifier
    */
   Element get element;
 
   /**
    * Return the lexical representation of the identifier.
    * @return the lexical representation of the identifier
    */
   String get name;
 
   /**
-   * Return the element associated with this identifier based on static type information, or{@code null} if the AST structure has not been resolved or if this identifier could not be
+   * Return the element associated with this identifier based on static type information, or`null` if the AST structure has not been resolved or if this identifier could not be
    * resolved. One example of the latter case is an identifier that is not defined within the scope
    * in which it appears
    * @return the element associated with the operator
    */
   Element get staticElement;
   bool isAssignable() => true;
 }
 /**
- * Instances of the class {@code IfStatement} represent an if statement.
+ * Instances of the class `IfStatement` represent an if statement.
  * <pre>
  * ifStatement ::=
- * 'if' '(' {@link Expression expression} ')' {@link Statement thenStatement} ('else' {@link Statement elseStatement})?
+ * 'if' '(' [Expression expression] ')' [Statement thenStatement] ('else' [Statement elseStatement])?
  * </pre>
  * @coverage dart.engine.ast
  */
 class IfStatement extends Statement {
 
   /**
    * The token representing the 'if' keyword.
    */
   Token _ifKeyword;
 
   /**
    * The left parenthesis.
    */
   Token _leftParenthesis;
 
   /**
    * The condition used to determine which of the statements is executed next.
    */
   Expression _condition;
 
   /**
    * The right parenthesis.
    */
   Token _rightParenthesis;
 
   /**
-   * The statement that is executed if the condition evaluates to {@code true}.
+   * The statement that is executed if the condition evaluates to `true`.
    */
   Statement _thenStatement;
 
   /**
    * The token representing the 'else' keyword.
    */
   Token _elseKeyword;
 
   /**
-   * The statement that is executed if the condition evaluates to {@code false}, or {@code null} if
+   * The statement that is executed if the condition evaluates to `false`, or `null` if
    * there is no else statement.
    */
   Statement _elseStatement;
 
   /**
    * Initialize a newly created if statement.
    * @param ifKeyword the token representing the 'if' keyword
    * @param leftParenthesis the left parenthesis
    * @param condition the condition used to determine which of the statements is executed next
    * @param rightParenthesis the right parenthesis
-   * @param thenStatement the statement that is executed if the condition evaluates to {@code true}
+   * @param thenStatement the statement that is executed if the condition evaluates to `true`
    * @param elseKeyword the token representing the 'else' keyword
-   * @param elseStatement the statement that is executed if the condition evaluates to {@code false}
+   * @param elseStatement the statement that is executed if the condition evaluates to `false`
    */
   IfStatement.full(Token ifKeyword, Token leftParenthesis, Expression condition, Token rightParenthesis, Statement thenStatement, Token elseKeyword, Statement elseStatement) {
     this._ifKeyword = ifKeyword;
     this._leftParenthesis = leftParenthesis;
     this._condition = becomeParentOf(condition);
     this._rightParenthesis = rightParenthesis;
     this._thenStatement = becomeParentOf(thenStatement);
     this._elseKeyword = elseKeyword;
     this._elseStatement = becomeParentOf(elseStatement);
   }
 
   /**
    * Initialize a newly created if statement.
    * @param ifKeyword the token representing the 'if' keyword
    * @param leftParenthesis the left parenthesis
    * @param condition the condition used to determine which of the statements is executed next
    * @param rightParenthesis the right parenthesis
-   * @param thenStatement the statement that is executed if the condition evaluates to {@code true}
+   * @param thenStatement the statement that is executed if the condition evaluates to `true`
    * @param elseKeyword the token representing the 'else' keyword
-   * @param elseStatement the statement that is executed if the condition evaluates to {@code false}
+   * @param elseStatement the statement that is executed if the condition evaluates to `false`
    */
   IfStatement({Token ifKeyword, Token leftParenthesis, Expression condition, Token rightParenthesis, Statement thenStatement, Token elseKeyword, Statement elseStatement}) : this.full(ifKeyword, leftParenthesis, condition, rightParenthesis, thenStatement, elseKeyword, elseStatement);
   accept(ASTVisitor visitor) => visitor.visitIfStatement(this);
   Token get beginToken => _ifKeyword;
 
   /**
    * Return the condition used to determine which of the statements is executed next.
    * @return the condition used to determine which statement is executed next
    */
   Expression get condition => _condition;
 
   /**
    * Return the token representing the 'else' keyword.
    * @return the token representing the 'else' keyword
    */
   Token get elseKeyword => _elseKeyword;
 
   /**
-   * Return the statement that is executed if the condition evaluates to {@code false}, or{@code null} if there is no else statement.
-   * @return the statement that is executed if the condition evaluates to {@code false}
+   * Return the statement that is executed if the condition evaluates to `false`, or`null` if there is no else statement.
+   * @return the statement that is executed if the condition evaluates to `false`
    */
   Statement get elseStatement => _elseStatement;
   Token get endToken {
     if (_elseStatement != null) {
       return _elseStatement.endToken;
     }
     return _thenStatement.endToken;
   }
 
   /**
    * Return the token representing the 'if' keyword.
    * @return the token representing the 'if' keyword
    */
   Token get ifKeyword => _ifKeyword;
 
   /**
    * Return the left parenthesis.
    * @return the left parenthesis
    */
   Token get leftParenthesis => _leftParenthesis;
 
   /**
    * Return the right parenthesis.
    * @return the right parenthesis
    */
   Token get rightParenthesis => _rightParenthesis;
 
   /**
-   * Return the statement that is executed if the condition evaluates to {@code true}.
-   * @return the statement that is executed if the condition evaluates to {@code true}
+   * Return the statement that is executed if the condition evaluates to `true`.
+   * @return the statement that is executed if the condition evaluates to `true`
    */
   Statement get thenStatement => _thenStatement;
 
   /**
    * Set the condition used to determine which of the statements is executed next to the given
    * expression.
    * @param expression the condition used to determine which statement is executed next
    */
   void set condition(Expression expression) {
     _condition = becomeParentOf(expression);
   }
 
   /**
    * Set the token representing the 'else' keyword to the given token.
    * @param elseKeyword the token representing the 'else' keyword
    */
   void set elseKeyword(Token elseKeyword2) {
     this._elseKeyword = elseKeyword2;
   }
 
   /**
-   * Set the statement that is executed if the condition evaluates to {@code false} to the given
+   * Set the statement that is executed if the condition evaluates to `false` to the given
    * statement.
-   * @param statement the statement that is executed if the condition evaluates to {@code false}
+   * @param statement the statement that is executed if the condition evaluates to `false`
    */
   void set elseStatement(Statement statement) {
     _elseStatement = becomeParentOf(statement);
   }
 
   /**
    * Set the token representing the 'if' keyword to the given token.
    * @param ifKeyword the token representing the 'if' keyword
    */
   void set ifKeyword(Token ifKeyword2) {
@@ skipping 10 matching lines @@
 
   /**
    * Set the right parenthesis to the given token.
    * @param rightParenthesis the right parenthesis
    */
   void set rightParenthesis(Token rightParenthesis2) {
     this._rightParenthesis = rightParenthesis2;
   }
 
   /**
-   * Set the statement that is executed if the condition evaluates to {@code true} to the given
+   * Set the statement that is executed if the condition evaluates to `true` to the given
    * statement.
-   * @param statement the statement that is executed if the condition evaluates to {@code true}
+   * @param statement the statement that is executed if the condition evaluates to `true`
    */
   void set thenStatement(Statement statement) {
     _thenStatement = becomeParentOf(statement);
   }
   void visitChildren(ASTVisitor<Object> visitor) {
     safelyVisitChild(_condition, visitor);
     safelyVisitChild(_thenStatement, visitor);
     safelyVisitChild(_elseStatement, visitor);
   }
 }
 /**
- * Instances of the class {@code ImplementsClause} represent the "implements" clause in an class
+ * Instances of the class `ImplementsClause` represent the "implements" clause in an class
  * declaration.
  * <pre>
  * implementsClause ::=
- * 'implements' {@link TypeName superclass} (',' {@link TypeName superclass})
+ * 'implements' [TypeName superclass] (',' [TypeName superclass])
  * </pre>
  * @coverage dart.engine.ast
  */
 class ImplementsClause extends ASTNode {
 
   /**
    * The token representing the 'implements' keyword.
    */
   Token _keyword;
 
@@ skipping 40 matching lines @@
    * @param keyword the token representing the 'implements' keyword
    */
   void set keyword(Token keyword2) {
     this._keyword = keyword2;
   }
   void visitChildren(ASTVisitor<Object> visitor) {
     _interfaces.accept(visitor);
   }
 }
 /**
- * Instances of the class {@code ImportDirective} represent an import directive.
+ * Instances of the class `ImportDirective` represent an import directive.
  * <pre>
- * importDirective ::={@link Annotation metadata} 'import' {@link StringLiteral libraryUri} ('as' identifier)? {@link Combinator combinator}* ';'
+ * importDirective ::=[Annotation metadata] 'import' [StringLiteral libraryUri] ('as' identifier)? [Combinator combinator]* ';'
  * </pre>
  * @coverage dart.engine.ast
  */
 class ImportDirective extends NamespaceDirective {
 
   /**
-   * The token representing the 'as' token, or {@code null} if the imported names are not prefixed.
+   * The token representing the 'as' token, or `null` if the imported names are not prefixed.
    */
   Token _asToken;
 
   /**
-   * The prefix to be used with the imported names, or {@code null} if the imported names are not
+   * The prefix to be used with the imported names, or `null` if the imported names are not
    * prefixed.
    */
   SimpleIdentifier _prefix;
 
   /**
    * Initialize a newly created import directive.
    * @param comment the documentation comment associated with this directive
    * @param metadata the annotations associated with the directive
    * @param keyword the token representing the 'import' keyword
    * @param libraryUri the URI of the library being imported
@@ skipping 15 matching lines @@
    * @param libraryUri the URI of the library being imported
    * @param asToken the token representing the 'as' token
    * @param prefix the prefix to be used with the imported names
    * @param combinators the combinators used to control how names are imported
    * @param semicolon the semicolon terminating the directive
    */
   ImportDirective({Comment comment, List<Annotation> metadata, Token keyword, StringLiteral libraryUri, Token asToken, SimpleIdentifier prefix, List<Combinator> combinators, Token semicolon}) : this.full(comment, metadata, keyword, libraryUri, asToken, prefix, combinators, semicolon);
   accept(ASTVisitor visitor) => visitor.visitImportDirective(this);
 
   /**
-   * Return the token representing the 'as' token, or {@code null} if the imported names are not
+   * Return the token representing the 'as' token, or `null` if the imported names are not
    * prefixed.
    * @return the token representing the 'as' token
    */
   Token get asToken => _asToken;
 
   /**
-   * Return the prefix to be used with the imported names, or {@code null} if the imported names are
+   * Return the prefix to be used with the imported names, or `null` if the imported names are
    * not prefixed.
    * @return the prefix to be used with the imported names
    */
   SimpleIdentifier get prefix => _prefix;
   LibraryElement get uriElement {
     Element element = this.element;
     if (element is ImportElement) {
       return ((element as ImportElement)).importedLibrary;
     }
     return null;
@@ skipping 14 matching lines @@
   void set prefix(SimpleIdentifier prefix2) {
     this._prefix = becomeParentOf(prefix2);
   }
   void visitChildren(ASTVisitor<Object> visitor) {
     super.visitChildren(visitor);
     safelyVisitChild(_prefix, visitor);
     combinators.accept(visitor);
   }
 }
 /**
- * Instances of the class {@code IndexExpression} represent an index expression.
+ * Instances of the class `IndexExpression` represent an index expression.
  * <pre>
- * indexExpression ::={@link Expression target} '\[' {@link Expression index} '\]'
+ * indexExpression ::=[Expression target] '\[' [Expression index] '\]'
  * </pre>
  * @coverage dart.engine.ast
  */
 class IndexExpression extends Expression {
 
   /**
-   * The expression used to compute the object being indexed, or {@code null} if this index
+   * 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 {@code null} if this index expression
+   * The period ("..") before a cascaded index expression, or `null` if this index expression
    * is not part of a cascade expression.
    */
   Token _period;
 
   /**
    * The left square bracket.
    */
   Token _leftBracket;
 
   /**
    * The expression used to compute the index.
    */
   Expression _index;
 
   /**
    * The right square bracket.
    */
   Token _rightBracket;
 
   /**
-   * The element associated with the operator based on the static type of the target, or{@code null} if the AST structure has not been resolved or if the operator could not be
+   * The element associated with the operator based on the static type of the target, or`null` if the AST structure has not been resolved or if the operator could not be
    * resolved.
    */
   MethodElement _staticElement;
 
   /**
-   * The element associated with the operator based on the propagated type of the target, or{@code null} if the AST structure has not been resolved or if the operator could not be
+   * The element associated with the operator based on the propagated type of the target, or`null` if the AST structure has not been resolved or if the operator could not be
    * resolved.
    */
   MethodElement _propagatedElement;
 
   /**
    * Initialize a newly created index expression.
    * @param target the expression used to compute the object being indexed
    * @param leftBracket the left square bracket
    * @param index the expression used to compute the index
    * @param rightBracket the right square bracket
@@ skipping 38 matching lines @@
   IndexExpression.forCascade({Token period2, Token leftBracket2, Expression index2, Token rightBracket2}) : this.forCascade_full(period2, leftBracket2, index2, rightBracket2);
   _jtd_constructor_59_impl(Token period2, Token leftBracket2, Expression index2, Token rightBracket2) {
     this._period = period2;
     this._leftBracket = leftBracket2;
     this._index = becomeParentOf(index2);
     this._rightBracket = rightBracket2;
   }
   accept(ASTVisitor visitor) => visitor.visitIndexExpression(this);
 
   /**
-   * Return the expression used to compute the object being indexed, or {@code null} if this index
+   * Return the expression used to compute the object being indexed, or `null` if this index
    * expression is part of a cascade expression.
    * @return the expression used to compute the object being indexed
    * @see #getRealTarget()
    */
   Expression get array => _target;
   Token get beginToken {
     if (_target != null) {
       return _target.beginToken;
     }
     return _period;
   }
 
   /**
-   * Return the element associated with the operator based on the propagated type of the target, or{@code null} if the AST structure has not been resolved or if the operator could not be
+   * Return the element associated with the operator based on the propagated type of the target, or`null` if the AST structure has not been resolved or if the operator could not be
    * resolved. One example of the latter case is an operator that is not defined for the type of the
    * target.
    * @return the element associated with this operator
    */
   MethodElement get element => _propagatedElement;
   Token get endToken => _rightBracket;
 
   /**
    * Return the expression used to compute the index.
    * @return the expression used to compute the index
    */
   Expression get index => _index;
 
   /**
    * Return the left square bracket.
    * @return the left square bracket
    */
   Token get leftBracket => _leftBracket;
 
   /**
-   * Return the period ("..") before a cascaded index expression, or {@code null} if this index
+   * Return the period ("..") before a cascaded index expression, or `null` if this index
    * expression is not part of a cascade expression.
    * @return the period ("..") before a cascaded index expression
    */
   Token get period => _period;
 
   /**
    * Return the expression used to compute the object being indexed. If this index expression is not
-   * part of a cascade expression, then this is the same as {@link #getArray()}. If this index
+   * part of a cascade expression, then this is the same as [getArray]. If this index
    * expression is part of a cascade expression, then the target expression stored with the cascade
    * expression is returned.
    * @return the expression used to compute the object being indexed
    * @see #getArray()
    */
   Expression get realTarget {
     if (isCascaded()) {
       ASTNode ancestor = parent;
       while (ancestor is! CascadeExpression) {
         if (ancestor == null) {
           return _target;
         }
         ancestor = ancestor.parent;
       }
       return ((ancestor as CascadeExpression)).target;
     }
     return _target;
   }
 
   /**
    * Return the right square bracket.
    * @return the right square bracket
    */
   Token get rightBracket => _rightBracket;
 
   /**
-   * Return the element associated with the operator based on the static type of the target, or{@code null} if the AST structure has not been resolved or if the operator could not be
+   * Return the element associated with the operator based on the static type of the target, or`null` if the AST structure has not been resolved or if the operator could not be
    * resolved. One example of the latter case is an operator that is not defined for the type of the
    * target.
    * @return the element associated with the operator
    */
   MethodElement get staticElement => _staticElement;
 
   /**
-   * Return {@code true} if this expression is computing a right-hand value.
-   * <p>
-   * Note that {@link #inGetterContext()} and {@link #inSetterContext()} are not opposites, nor are
-   * they mutually exclusive. In other words, it is possible for both methods to return {@code true}when invoked on the same node.
-   * @return {@code true} if this expression is in a context where the operator '\[\]' will be invoked
+   * Return `true` if this expression is computing a right-hand value.
+   *
+   * Note that [inGetterContext] and [inSetterContext] are not opposites, nor are
+   * they mutually exclusive. In other words, it is possible for both methods to return `true`when invoked on the same node.
+   * @return `true` if this expression is in a context where the operator '\[\]' will be invoked
    */
   bool inGetterContext() {
     ASTNode parent = this.parent;
     if (parent is AssignmentExpression) {
       AssignmentExpression assignment = parent as AssignmentExpression;
       if (identical(assignment.leftHandSide, this) && identical(assignment.operator.type, TokenType.EQ)) {
         return false;
       }
     }
     return true;
   }
 
   /**
-   * Return {@code true} if this expression is computing a left-hand value.
-   * <p>
-   * Note that {@link #inGetterContext()} and {@link #inSetterContext()} are not opposites, nor are
-   * they mutually exclusive. In other words, it is possible for both methods to return {@code true}when invoked on the same node.
-   * @return {@code true} if this expression is in a context where the operator '\[\]=' will be
+   * Return `true` if this expression is computing a left-hand value.
+   *
+   * Note that [inGetterContext] and [inSetterContext] are not opposites, nor are
+   * they mutually exclusive. In other words, it is possible for both methods to return `true`when invoked on the same node.
+   * @return `true` if this expression is in a context where the operator '\[\]=' will be
    * invoked
    */
   bool inSetterContext() {
     ASTNode parent = this.parent;
     if (parent is PrefixExpression) {
       return ((parent as PrefixExpression)).operator.type.isIncrementOperator();
     } else if (parent is PostfixExpression) {
       return true;
     } else if (parent is AssignmentExpression) {
       return identical(((parent as AssignmentExpression)).leftHandSide, this);
     }
     return false;
   }
   bool isAssignable() => true;
 
   /**
-   * Return {@code true} if this expression is cascaded. If it is, then the target of this
-   * expression is not stored locally but is stored in the nearest ancestor that is a{@link CascadeExpression}.
-   * @return {@code true} if this expression is cascaded
+   * Return `true` if this expression is cascaded. If it is, then the target of this
+   * expression is not stored locally but is stored in the nearest ancestor that is a[CascadeExpression].
+   * @return `true` if this expression is cascaded
    */
   bool isCascaded() => _period != null;
 
   /**
    * Set the expression used to compute the object being indexed to the given expression.
    * @param expression the expression used to compute the object being indexed
    */
   void set array(Expression expression) {
     _target = becomeParentOf(expression);
   }
@@ skipping 48 matching lines @@
     _staticElement = element;
   }
   void visitChildren(ASTVisitor<Object> visitor) {
     safelyVisitChild(_target, visitor);
     safelyVisitChild(_index, visitor);
   }
 
   /**
    * If the AST structure has been resolved, and the function being invoked is known based on
    * propagated type information, then return the parameter element representing the parameter to
-   * which the value of the index expression will be bound. Otherwise, return {@code null}.
-   * <p>
-   * This method is only intended to be used by {@link Expression#getParameterElement()}.
+   * which the value of the index expression will be bound. Otherwise, return `null`.
+   *
+   * This method is only intended to be used by [Expression#getParameterElement].
    * @return the parameter element representing the parameter to which the value of the index
    * expression will be bound
    */
   ParameterElement get propagatedParameterElementForIndex {
     if (_propagatedElement == null) {
       return null;
     }
     List<ParameterElement> parameters = _propagatedElement.parameters;
     if (parameters.length < 1) {
       return null;
     }
     return parameters[0];
   }
 
   /**
    * If the AST structure has been resolved, and the function being invoked is known based on static
    * type information, then return the parameter element representing the parameter to which the
-   * value of the index expression will be bound. Otherwise, return {@code null}.
-   * <p>
-   * This method is only intended to be used by {@link Expression#getStaticParameterElement()}.
+   * value of the index expression will be bound. Otherwise, return `null`.
+   *
+   * This method is only intended to be used by [Expression#getStaticParameterElement].
    * @return the parameter element representing the parameter to which the value of the index
    * expression will be bound
    */
   ParameterElement get staticParameterElementForIndex {
     if (_staticElement == null) {
       return null;
     }
     List<ParameterElement> parameters = _staticElement.parameters;
     if (parameters.length < 1) {
       return null;
     }
     return parameters[0];
   }
 }
 /**
- * Instances of the class {@code InstanceCreationExpression} represent an instance creation
+ * Instances of the class `InstanceCreationExpression` represent an instance creation
  * expression.
  * <pre>
  * newExpression ::=
- * ('new' | 'const') {@link TypeName type} ('.' {@link SimpleIdentifier identifier})? {@link ArgumentList argumentList}</pre>
+ * ('new' | 'const') [TypeName type] ('.' [SimpleIdentifier identifier])? [ArgumentList argumentList]</pre>
  * @coverage dart.engine.ast
  */
 class InstanceCreationExpression extends Expression {
 
   /**
    * The keyword used to indicate how an object should be created.
    */
   Token _keyword;
 
   /**
    * The name of the constructor to be invoked.
    */
   ConstructorName _constructorName;
 
   /**
    * The list of arguments to the constructor.
    */
   ArgumentList _argumentList;
 
   /**
-   * The element associated with the constructor based on static type information, or {@code null}if the AST structure has not been resolved or if the constructor could not be resolved.
+   * The element associated with the constructor based on static type information, or `null`if the AST structure has not been resolved or if the constructor could not be resolved.
    */
   ConstructorElement _staticElement;
 
   /**
-   * The element associated with the constructor based on propagated type information, or{@code null} if the AST structure has not been resolved or if the constructor could not be
+   * The element associated with the constructor based on propagated type information, or`null` if the AST structure has not been resolved or if the constructor could not be
    * resolved.
    */
   ConstructorElement _propagatedElement;
 
   /**
    * Initialize a newly created instance creation expression.
    * @param keyword the keyword used to indicate how an object should be created
    * @param constructorName the name of the constructor to be invoked
    * @param argumentList the list of arguments to the constructor
    */
@@ skipping 19 matching lines @@
   ArgumentList get argumentList => _argumentList;
   Token get beginToken => _keyword;
 
   /**
    * Return the name of the constructor to be invoked.
    * @return the name of the constructor to be invoked
    */
   ConstructorName get constructorName => _constructorName;
 
   /**
-   * Return the element associated with the constructor based on propagated type information, or{@code null} if the AST structure has not been resolved or if the constructor could not be
+   * Return the element associated with the constructor based on propagated type information, or`null` if the AST structure has not been resolved or if the constructor could not be
    * resolved.
    * @return the element associated with the constructor
    */
   ConstructorElement get element => _propagatedElement;
   Token get endToken => _argumentList.endToken;
 
   /**
    * Return the keyword used to indicate how an object should be created.
    * @return the keyword used to indicate how an object should be created
    */
   Token get keyword => _keyword;
 
   /**
-   * Return the element associated with the constructor based on static type information, or{@code null} if the AST structure has not been resolved or if the constructor could not be
+   * Return the element associated with the constructor based on static type information, or`null` if the AST structure has not been resolved or if the constructor could not be
    * resolved.
    * @return the element associated with the constructor
    */
   ConstructorElement get staticElement => _staticElement;
 
   /**
-   * Return {@code true} if this creation expression is used to invoke a constant constructor.
-   * @return {@code true} if this creation expression is used to invoke a constant constructor
+   * Return `true` if this creation expression is used to invoke a constant constructor.
+   * @return `true` if this creation expression is used to invoke a constant constructor
    */
   bool isConst() => _keyword is KeywordToken && identical(((_keyword as KeywordToken)).keyword, Keyword.CONST);
 
   /**
    * Set the list of arguments to the constructor to the given list.
    * @param argumentList the list of arguments to the constructor
    */
   void set argumentList(ArgumentList argumentList2) {
     this._argumentList = becomeParentOf(argumentList2);
   }
@@ skipping 30 matching lines @@
    */
   void set staticElement(ConstructorElement element) {
     this._staticElement = element;
   }
   void visitChildren(ASTVisitor<Object> visitor) {
     safelyVisitChild(_constructorName, visitor);
     safelyVisitChild(_argumentList, visitor);
   }
 }
 /**
- * Instances of the class {@code IntegerLiteral} represent an integer literal expression.
+ * Instances of the class `IntegerLiteral` represent an integer literal expression.
  * <pre>
  * integerLiteral ::=
  * decimalIntegerLiteral
  * | hexidecimalIntegerLiteral
  * decimalIntegerLiteral ::=
  * decimalDigit+
  * hexidecimalIntegerLiteral ::=
  * '0x' hexidecimalDigit+
  * | '0X' hexidecimalDigit+
  * </pre>
@@ skipping 55 matching lines @@
    * Set the value of the literal to the given value.
    * @param value the value of the literal
    */
   void set value(int value2) {
     this._value = value2;
   }
   void visitChildren(ASTVisitor<Object> visitor) {
   }
 }
 /**
- * The abstract class {@code InterpolationElement} defines the behavior common to elements within a{@link StringInterpolation string interpolation}.
+ * The abstract class `InterpolationElement` defines the behavior common to elements within a[StringInterpolation string interpolation].
  * <pre>
- * interpolationElement ::={@link InterpolationExpression interpolationExpression}| {@link InterpolationString interpolationString}</pre>
+ * interpolationElement ::=[InterpolationExpression interpolationExpression]| [InterpolationString interpolationString]</pre>
  * @coverage dart.engine.ast
  */
 abstract class InterpolationElement extends ASTNode {
 }
 /**
- * Instances of the class {@code InterpolationExpression} represent an expression embedded in a
+ * Instances of the class `InterpolationExpression` represent an expression embedded in a
  * string interpolation.
  * <pre>
  * interpolationExpression ::=
- * '$' {@link SimpleIdentifier identifier}| '$' '{' {@link Expression expression} '}'
+ * '$' [SimpleIdentifier identifier]| '$' '{' [Expression expression] '}'
  * </pre>
  * @coverage dart.engine.ast
  */
 class InterpolationExpression extends InterpolationElement {
 
   /**
    * 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;
 
   /**
    * The expression to be evaluated for the value to be converted into a string.
    */
   Expression _expression;
 
   /**
-   * The right curly bracket, or {@code null} if the expression is an identifier without brackets.
+   * The right curly bracket, or `null` if the expression is an identifier without brackets.
    */
   Token _rightBracket;
 
   /**
    * Initialize a newly created interpolation expression.
    * @param leftBracket the left curly bracket
    * @param expression the expression to be evaluated for the value to be converted into a string
    * @param rightBracket the right curly bracket
    */
   InterpolationExpression.full(Token leftBracket, Expression expression, Token rightBracket) {
@@ skipping 58 matching lines @@
    * @param rightBracket the right curly bracket
    */
   void set rightBracket(Token rightBracket2) {
     this._rightBracket = rightBracket2;
   }
   void visitChildren(ASTVisitor<Object> visitor) {
     safelyVisitChild(_expression, visitor);
   }
 }
 /**
- * Instances of the class {@code InterpolationString} represent a non-empty substring of an
+ * Instances of the class `InterpolationString` represent a non-empty substring of an
  * interpolated string.
  * <pre>
  * interpolationString ::=
  * characters
  * </pre>
  * @coverage dart.engine.ast
  */
 class InterpolationString extends InterpolationElement {
 
   /**
@@ skipping 50 matching lines @@
    * Set the value of the literal to the given string.
    * @param string the value of the literal
    */
   void set value(String string) {
     _value = string;
   }
   void visitChildren(ASTVisitor<Object> visitor) {
   }
 }
 /**
- * Instances of the class {@code IsExpression} represent an is expression.
+ * Instances of the class `IsExpression` represent an is expression.
  * <pre>
- * isExpression ::={@link Expression expression} 'is' '!'? {@link TypeName type}</pre>
+ * isExpression ::=[Expression expression] 'is' '!'? [TypeName type]</pre>
  * @coverage dart.engine.ast
  */
 class IsExpression extends Expression {
 
   /**
    * The expression used to compute the value whose type is being tested.
    */
   Expression _expression;
 
   /**
    * The is operator.
    */
   Token _isOperator;
 
   /**
-   * The not operator, or {@code null} if the sense of the test is not negated.
+   * The not operator, or `null` if the sense of the test is not negated.
    */
   Token _notOperator;
 
   /**
    * The name of the type being tested for.
    */
   TypeName _type;
 
   /**
    * Initialize a newly created is expression.
    * @param expression the expression used to compute the value whose type is being tested
    * @param isOperator the is operator
-   * @param notOperator the not operator, or {@code null} if the sense of the test is not negated
+   * @param notOperator the not operator, or `null` if the sense of the test is not negated
    * @param type the name of the type being tested for
    */
   IsExpression.full(Expression expression, Token isOperator, Token notOperator, TypeName type) {
     this._expression = becomeParentOf(expression);
     this._isOperator = isOperator;
     this._notOperator = notOperator;
     this._type = becomeParentOf(type);
   }
 
   /**
    * Initialize a newly created is expression.
    * @param expression the expression used to compute the value whose type is being tested
    * @param isOperator the is operator
-   * @param notOperator the not operator, or {@code null} if the sense of the test is not negated
+   * @param notOperator the not operator, or `null` if the sense of the test is not negated
    * @param type the name of the type being tested for
    */
   IsExpression({Expression expression, Token isOperator, Token notOperator, TypeName type}) : this.full(expression, isOperator, notOperator, type);
   accept(ASTVisitor visitor) => visitor.visitIsExpression(this);
   Token get beginToken => _expression.beginToken;
   Token get endToken => _type.endToken;
 
   /**
    * Return the expression used to compute the value whose type is being tested.
    * @return the expression used to compute the value whose type is being tested
@@ skipping 49 matching lines @@
    */
   void set type(TypeName name) {
     this._type = becomeParentOf(name);
   }
   void visitChildren(ASTVisitor<Object> visitor) {
     safelyVisitChild(_expression, visitor);
     safelyVisitChild(_type, visitor);
   }
 }
 /**
- * Instances of the class {@code Label} represent a label.
+ * Instances of the class `Label` represent a label.
  * <pre>
- * label ::={@link SimpleIdentifier label} ':'
+ * label ::=[SimpleIdentifier label] ':'
  * </pre>
  * @coverage dart.engine.ast
  */
 class Label extends ASTNode {
 
   /**
    * The label being associated with the statement.
    */
   SimpleIdentifier _label;
 
@@ skipping 47 matching lines @@
    * @param label the label being associated with the statement
    */
   void set label(SimpleIdentifier label2) {
     this._label = becomeParentOf(label2);
   }
   void visitChildren(ASTVisitor<Object> visitor) {
     safelyVisitChild(_label, visitor);
   }
 }
 /**
- * Instances of the class {@code LabeledStatement} represent a statement that has a label associated
+ * Instances of the class `LabeledStatement` represent a statement that has a label associated
  * with them.
  * <pre>
- * labeledStatement ::={@link Label label}+ {@link Statement statement}</pre>
+ * labeledStatement ::=[Label label]+ [Statement statement]</pre>
  * @coverage dart.engine.ast
  */
 class LabeledStatement extends Statement {
 
   /**
    * The labels being associated with the statement.
    */
   NodeList<Label> _labels;
 
   /**
@@ skipping 45 matching lines @@
    */
   void set statement(Statement statement2) {
     this._statement = becomeParentOf(statement2);
   }
   void visitChildren(ASTVisitor<Object> visitor) {
     _labels.accept(visitor);
     safelyVisitChild(_statement, visitor);
   }
 }
 /**
- * Instances of the class {@code LibraryDirective} represent a library directive.
+ * Instances of the class `LibraryDirective` represent a library directive.
  * <pre>
- * libraryDirective ::={@link Annotation metadata} 'library' {@link Identifier name} ';'
+ * libraryDirective ::=[Annotation metadata] 'library' [Identifier name] ';'
  * </pre>
  * @coverage dart.engine.ast
  */
 class LibraryDirective extends Directive {
 
   /**
    * The token representing the 'library' token.
    */
   Token _libraryToken;
 
@@ skipping 75 matching lines @@
   void set semicolon(Token semicolon2) {
     this._semicolon = semicolon2;
   }
   void visitChildren(ASTVisitor<Object> visitor) {
     super.visitChildren(visitor);
     safelyVisitChild(_name, visitor);
   }
   Token get firstTokenAfterCommentAndMetadata => _libraryToken;
 }
 /**
- * Instances of the class {@code LibraryIdentifier} represent the identifier for a library.
+ * Instances of the class `LibraryIdentifier` represent the identifier for a library.
  * <pre>
- * libraryIdentifier ::={@link SimpleIdentifier component} ('.' {@link SimpleIdentifier component})
+ * libraryIdentifier ::=[SimpleIdentifier component] ('.' [SimpleIdentifier component])
  * </pre>
  * @coverage dart.engine.ast
  */
 class LibraryIdentifier extends Identifier {
 
   /**
    * The components of the identifier.
    */
   NodeList<SimpleIdentifier> _components;
 
@@ skipping 33 matching lines @@
       builder.append(identifier.name);
     }
     return builder.toString();
   }
   Element get staticElement => null;
   void visitChildren(ASTVisitor<Object> visitor) {
     _components.accept(visitor);
   }
 }
 /**
- * Instances of the class {@code ListLiteral} represent a list literal.
+ * Instances of the class `ListLiteral` represent a list literal.
  * <pre>
  * listLiteral ::=
- * 'const'? ('<' {@link TypeName type} '>')? '\[' ({@link Expression expressionList} ','?)? '\]'
+ * 'const'? ('<' [TypeName type] '>')? '\[' ([Expression expressionList] ','?)? '\]'
  * </pre>
  * @coverage dart.engine.ast
  */
 class ListLiteral extends TypedLiteral {
 
   /**
    * The left square bracket.
    */
   Token _leftBracket;
 
   /**
    * The expressions used to compute the elements of the list.
    */
   NodeList<Expression> _elements;
 
   /**
    * The right square bracket.
    */
   Token _rightBracket;
 
   /**
    * Initialize a newly created list literal.
    * @param modifier the const modifier associated with this literal
-   * @param typeArguments the type argument associated with this literal, or {@code null} if no type
+   * @param typeArguments the type argument associated with this literal, or `null` if no type
    * arguments were declared
    * @param leftBracket the left square bracket
    * @param elements the expressions used to compute the elements of the list
    * @param rightBracket the right square bracket
    */
   ListLiteral.full(Token modifier, TypeArgumentList typeArguments, Token leftBracket, List<Expression> elements, Token rightBracket) : super.full(modifier, typeArguments) {
     this._elements = new NodeList<Expression>(this);
     this._leftBracket = leftBracket;
     this._elements.addAll(elements);
     this._rightBracket = rightBracket;
   }
 
   /**
    * Initialize a newly created list literal.
    * @param modifier the const modifier associated with this literal
-   * @param typeArguments the type argument associated with this literal, or {@code null} if no type
+   * @param typeArguments the type argument associated with this literal, or `null` if no type
    * arguments were declared
    * @param leftBracket the left square bracket
    * @param elements the expressions used to compute the elements of the list
    * @param rightBracket the right square bracket
    */
   ListLiteral({Token modifier, TypeArgumentList typeArguments, Token leftBracket, List<Expression> elements, Token rightBracket}) : this.full(modifier, typeArguments, leftBracket, elements, rightBracket);
   accept(ASTVisitor visitor) => visitor.visitListLiteral(this);
   Token get beginToken {
     Token token = modifier;
     if (token != null) {
@@ skipping 39 matching lines @@
    */
   void set rightBracket(Token bracket) {
     _rightBracket = bracket;
   }
   void visitChildren(ASTVisitor<Object> visitor) {
     super.visitChildren(visitor);
     _elements.accept(visitor);
   }
 }
 /**
- * The abstract class {@code Literal} defines the behavior common to nodes that represent a literal
+ * The abstract class `Literal` defines the behavior common to nodes that represent a literal
  * expression.
  * <pre>
- * literal ::={@link BooleanLiteral booleanLiteral}| {@link DoubleLiteral doubleLiteral}| {@link IntegerLiteral integerLiteral}| {@link ListLiteral listLiteral}| {@link MapLiteral mapLiteral}| {@link NullLiteral nullLiteral}| {@link StringLiteral stringLiteral}</pre>
+ * literal ::=[BooleanLiteral booleanLiteral]| [DoubleLiteral doubleLiteral]| [IntegerLiteral integerLiteral]| [ListLiteral listLiteral]| [MapLiteral mapLiteral]| [NullLiteral nullLiteral]| [StringLiteral stringLiteral]</pre>
  * @coverage dart.engine.ast
  */
 abstract class Literal extends Expression {
 }
 /**
- * Instances of the class {@code MapLiteral} represent a literal map.
+ * Instances of the class `MapLiteral` represent a literal map.
  * <pre>
  * mapLiteral ::=
- * 'const'? ('<' {@link TypeName type} (',' {@link TypeName type})* '>')? '{' ({@link MapLiteralEntry entry} (',' {@link MapLiteralEntry entry})* ','?)? '}'
+ * 'const'? ('<' [TypeName type] (',' [TypeName type])* '>')? '{' ([MapLiteralEntry entry] (',' [MapLiteralEntry entry])* ','?)? '}'
  * </pre>
  * @coverage dart.engine.ast
  */
 class MapLiteral extends TypedLiteral {
 
   /**
    * The left curly bracket.
    */
   Token _leftBracket;
 
   /**
    * The entries in the map.
    */
   NodeList<MapLiteralEntry> _entries;
 
   /**
    * The right curly bracket.
    */
   Token _rightBracket;
 
   /**
    * Initialize a newly created map literal.
    * @param modifier the const modifier associated with this literal
-   * @param typeArguments the type argument associated with this literal, or {@code null} if no type
+   * @param typeArguments the type argument associated with this literal, or `null` if no type
    * arguments were declared
    * @param leftBracket the left curly bracket
    * @param entries the entries in the map
    * @param rightBracket the right curly bracket
    */
   MapLiteral.full(Token modifier, TypeArgumentList typeArguments, Token leftBracket, List<MapLiteralEntry> entries, Token rightBracket) : super.full(modifier, typeArguments) {
     this._entries = new NodeList<MapLiteralEntry>(this);
     this._leftBracket = leftBracket;
     this._entries.addAll(entries);
     this._rightBracket = rightBracket;
   }
 
   /**
    * Initialize a newly created map literal.
    * @param modifier the const modifier associated with this literal
-   * @param typeArguments the type argument associated with this literal, or {@code null} if no type
+   * @param typeArguments the type argument associated with this literal, or `null` if no type
    * arguments were declared
    * @param leftBracket the left curly bracket
    * @param entries the entries in the map
    * @param rightBracket the right curly bracket
    */
   MapLiteral({Token modifier, TypeArgumentList typeArguments, Token leftBracket, List<MapLiteralEntry> entries, Token rightBracket}) : this.full(modifier, typeArguments, leftBracket, entries, rightBracket);
   accept(ASTVisitor visitor) => visitor.visitMapLiteral(this);
   Token get beginToken {
     Token token = modifier;
     if (token != null) {
@@ skipping 39 matching lines @@
    */
   void set rightBracket(Token bracket) {
     _rightBracket = bracket;
   }
   void visitChildren(ASTVisitor<Object> visitor) {
     super.visitChildren(visitor);
     _entries.accept(visitor);
   }
 }
 /**
- * Instances of the class {@code MapLiteralEntry} represent a single key/value pair in a map
+ * Instances of the class `MapLiteralEntry` represent a single key/value pair in a map
  * literal.
  * <pre>
- * mapLiteralEntry ::={@link Expression key} ':' {@link Expression value}</pre>
+ * mapLiteralEntry ::=[Expression key] ':' [Expression value]</pre>
  * @coverage dart.engine.ast
  */
 class MapLiteralEntry extends ASTNode {
 
   /**
    * The expression computing the key with which the value will be associated.
    */
   Expression _key;
 
   /**
@@ skipping 71 matching lines @@
    */
   void set value(Expression expression) {
     _value = becomeParentOf(expression);
   }
   void visitChildren(ASTVisitor<Object> visitor) {
     safelyVisitChild(_key, visitor);
     safelyVisitChild(_value, visitor);
   }
 }
 /**
- * Instances of the class {@code MethodDeclaration} represent a method declaration.
+ * Instances of the class `MethodDeclaration` represent a method declaration.
  * <pre>
  * methodDeclaration ::=
- * methodSignature {@link FunctionBody body}methodSignature ::=
- * 'external'? ('abstract' | 'static')? {@link Type returnType}? ('get' | 'set')? methodName{@link FormalParameterList formalParameterList}methodName ::={@link SimpleIdentifier name}| 'operator' {@link SimpleIdentifier operator}</pre>
+ * methodSignature [FunctionBody body]methodSignature ::=
+ * 'external'? ('abstract' | 'static')? [Type returnType]? ('get' | 'set')? methodName[FormalParameterList formalParameterList]methodName ::=[SimpleIdentifier name]| 'operator' [SimpleIdentifier operator]</pre>
  * @coverage dart.engine.ast
  */
 class MethodDeclaration extends ClassMember {
 
   /**
-   * The token for the 'external' keyword, or {@code null} if the constructor is not external.
+   * The token for the 'external' keyword, or `null` if the constructor is not external.
    */
   Token _externalKeyword;
 
   /**
-   * The token representing the 'abstract' or 'static' keyword, or {@code null} if neither modifier
+   * The token representing the 'abstract' or 'static' keyword, or `null` if neither modifier
    * was specified.
    */
   Token _modifierKeyword;
 
   /**
-   * The return type of the method, or {@code null} if no return type was declared.
+   * The return type of the method, or `null` if no return type was declared.
    */
   TypeName _returnType;
 
   /**
-   * The token representing the 'get' or 'set' keyword, or {@code null} if this is a method
+   * The token representing the 'get' or 'set' keyword, or `null` if this is a method
    * declaration rather than a property declaration.
    */
   Token _propertyKeyword;
 
   /**
-   * The token representing the 'operator' keyword, or {@code null} if this method does not declare
+   * The token representing the 'operator' keyword, or `null` if this method does not declare
    * an operator.
    */
   Token _operatorKeyword;
 
   /**
    * The name of the method.
    */
   SimpleIdentifier _name;
 
   /**
-   * The parameters associated with the method, or {@code null} if this method declares a getter.
+   * The parameters associated with the method, or `null` if this method declares a getter.
    */
   FormalParameterList _parameters;
 
   /**
    * The body of the method.
    */
   FunctionBody _body;
 
   /**
    * Initialize a newly created method declaration.
    * @param externalKeyword the token for the 'external' keyword
    * @param comment the documentation comment associated with this method
    * @param metadata the annotations associated with this method
    * @param modifierKeyword the token representing the 'abstract' or 'static' keyword
    * @param returnType the return type of the method
    * @param propertyKeyword the token representing the 'get' or 'set' keyword
    * @param operatorKeyword the token representing the 'operator' keyword
    * @param name the name of the method
-   * @param parameters the parameters associated with the method, or {@code null} if this method
+   * @param parameters the parameters associated with the method, or `null` if this method
    * declares a getter
    * @param body the body of the method
    */
   MethodDeclaration.full(Comment comment, List<Annotation> metadata, Token externalKeyword, Token modifierKeyword, TypeName returnType, Token propertyKeyword, Token operatorKeyword, SimpleIdentifier name, FormalParameterList parameters, FunctionBody body) : super.full(comment, metadata) {
     this._externalKeyword = externalKeyword;
     this._modifierKeyword = modifierKeyword;
     this._returnType = becomeParentOf(returnType);
     this._propertyKeyword = propertyKeyword;
     this._operatorKeyword = operatorKeyword;
     this._name = becomeParentOf(name);
     this._parameters = becomeParentOf(parameters);
     this._body = becomeParentOf(body);
   }
 
   /**
    * Initialize a newly created method declaration.
    * @param externalKeyword the token for the 'external' keyword
    * @param comment the documentation comment associated with this method
    * @param metadata the annotations associated with this method
    * @param modifierKeyword the token representing the 'abstract' or 'static' keyword
    * @param returnType the return type of the method
    * @param propertyKeyword the token representing the 'get' or 'set' keyword
    * @param operatorKeyword the token representing the 'operator' keyword
    * @param name the name of the method
-   * @param parameters the parameters associated with the method, or {@code null} if this method
+   * @param parameters the parameters associated with the method, or `null` if this method
    * declares a getter
    * @param body the body of the method
    */
   MethodDeclaration({Comment comment, List<Annotation> metadata, Token externalKeyword, Token modifierKeyword, TypeName returnType, Token propertyKeyword, Token operatorKeyword, SimpleIdentifier name, FormalParameterList parameters, FunctionBody body}) : this.full(comment, metadata, externalKeyword, modifierKeyword, returnType, propertyKeyword, operatorKeyword, name, parameters, body);
   accept(ASTVisitor visitor) => visitor.visitMethodDeclaration(this);
 
   /**
    * Return the body of the method.
    * @return the body of the method
    */
   FunctionBody get body => _body;
 
   /**
-   * Return the element associated with this method, or {@code null} if the AST structure has not
-   * been resolved. The element can either be a {@link MethodElement}, if this represents the
-   * declaration of a normal method, or a {@link PropertyAccessorElement} if this represents the
+   * Return the element associated with this method, or `null` if the AST structure has not
+   * been resolved. The element can either be a [MethodElement], if this represents the
+   * declaration of a normal method, or a [PropertyAccessorElement] if this represents the
    * declaration of either a getter or a setter.
    * @return the element associated with this method
    */
   ExecutableElement get element => _name != null ? (_name.element as ExecutableElement) : null;
   Token get endToken => _body.endToken;
 
   /**
-   * Return the token for the 'external' keyword, or {@code null} if the constructor is not
+   * Return the token for the 'external' keyword, or `null` if the constructor is not
    * external.
    * @return the token for the 'external' keyword
    */
   Token get externalKeyword => _externalKeyword;
 
   /**
-   * Return the token representing the 'abstract' or 'static' keyword, or {@code null} if neither
+   * Return the token representing the 'abstract' or 'static' keyword, or `null` if neither
    * modifier was specified.
    * @return the token representing the 'abstract' or 'static' keyword
    */
   Token get modifierKeyword => _modifierKeyword;
 
   /**
    * Return the name of the method.
    * @return the name of the method
    */
   SimpleIdentifier get name => _name;
 
   /**
-   * Return the token representing the 'operator' keyword, or {@code null} if this method does not
+   * Return the token representing the 'operator' keyword, or `null` if this method does not
    * declare an operator.
    * @return the token representing the 'operator' keyword
    */
   Token get operatorKeyword => _operatorKeyword;
 
   /**
-   * Return the parameters associated with the method, or {@code null} if this method declares a
+   * Return the parameters associated with the method, or `null` if this method declares a
    * getter.
    * @return the parameters associated with the method
    */
   FormalParameterList get parameters => _parameters;
 
   /**
-   * Return the token representing the 'get' or 'set' keyword, or {@code null} if this is a method
+   * Return the token representing the 'get' or 'set' keyword, or `null` if this is a method
    * declaration rather than a property declaration.
    * @return the token representing the 'get' or 'set' keyword
    */
   Token get propertyKeyword => _propertyKeyword;
 
   /**
-   * Return the return type of the method, or {@code null} if no return type was declared.
+   * Return the return type of the method, or `null` if no return type was declared.
    * @return the return type of the method
    */
   TypeName get returnType => _returnType;
 
   /**
-   * Return {@code true} if this method is declared to be an abstract method.
-   * @return {@code true} if this method is declared to be an abstract method
+   * Return `true` if this method is declared to be an abstract method.
+   * @return `true` if this method is declared to be an abstract method
    */
   bool isAbstract() => _externalKeyword == null && (_body is EmptyFunctionBody);
 
   /**
-   * Return {@code true} if this method declares a getter.
-   * @return {@code true} if this method declares a getter
+   * Return `true` if this method declares a getter.
+   * @return `true` if this method declares a getter
    */
   bool isGetter() => _propertyKeyword != null && identical(((_propertyKeyword as KeywordToken)).keyword, Keyword.GET);
 
   /**
-   * Return {@code true} if this method declares an operator.
-   * @return {@code true} if this method declares an operator
+   * Return `true` if this method declares an operator.
+   * @return `true` if this method declares an operator
    */
   bool isOperator() => _operatorKeyword != null;
 
   /**
-   * Return {@code true} if this method declares a setter.
-   * @return {@code true} if this method declares a setter
+   * Return `true` if this method declares a setter.
+   * @return `true` if this method declares a setter
    */
   bool isSetter() => _propertyKeyword != null && identical(((_propertyKeyword as KeywordToken)).keyword, Keyword.SET);
 
   /**
-   * Return {@code true} if this method is declared to be a static method.
-   * @return {@code true} if this method is declared to be a static method
+   * Return `true` if this method is declared to be a static method.
+   * @return `true` if this method is declared to be a static method
    */
   bool isStatic() => _modifierKeyword != null && identical(((_modifierKeyword as KeywordToken)).keyword, Keyword.STATIC);
 
   /**
    * Set the body of the method to the given function body.
    * @param functionBody the body of the method
    */
   void set body(FunctionBody functionBody) {
     _body = becomeParentOf(functionBody);
   }
@@ skipping 67 matching lines @@
       return _returnType.beginToken;
     } else if (_propertyKeyword != null) {
       return _propertyKeyword;
     } else if (_operatorKeyword != null) {
       return _operatorKeyword;
     }
     return _name.beginToken;
   }
 }
 /**
- * Instances of the class {@code MethodInvocation} represent the invocation of either a function or
- * a method. Invocations of functions resulting from evaluating an expression are represented by{@link FunctionExpressionInvocation function expression invocation} nodes. Invocations of getters
- * and setters are represented by either {@link PrefixedIdentifier prefixed identifier} or{@link PropertyAccess property access} nodes.
+ * Instances of the class `MethodInvocation` represent the invocation of either a function or
+ * a method. Invocations of functions resulting from evaluating an expression are represented by[FunctionExpressionInvocation function expression invocation] nodes. Invocations of getters
+ * and setters are represented by either [PrefixedIdentifier prefixed identifier] or[PropertyAccess property access] nodes.
  * <pre>
  * methodInvoction ::=
- * ({@link Expression target} '.')? {@link SimpleIdentifier methodName} {@link ArgumentList argumentList}</pre>
+ * ([Expression target] '.')? [SimpleIdentifier methodName] [ArgumentList argumentList]</pre>
  * @coverage dart.engine.ast
  */
 class MethodInvocation extends Expression {
 
   /**
-   * The expression producing the object on which the method is defined, or {@code null} if there is
-   * no target (that is, the target is implicitly {@code this}).
+   * 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;
 
   /**
-   * The period that separates the target from the method name, or {@code null} if there is no
+   * The period that separates the target from the method name, or `null` if there is no
    * target.
    */
   Token _period;
 
   /**
    * The name of the method being invoked.
    */
   SimpleIdentifier _methodName;
 
   /**
@@ skipping 40 matching lines @@
   }
   Token get endToken => _argumentList.endToken;
 
   /**
    * Return the name of the method being invoked.
    * @return the name of the method being invoked
    */
   SimpleIdentifier get methodName => _methodName;
 
   /**
-   * Return the period that separates the target from the method name, or {@code null} if there is
+   * Return the period that separates the target from the method name, or `null` if there is
    * no target.
    * @return the period that separates the target from the method name
    */
   Token get period => _period;
 
   /**
    * Return the expression used to compute the receiver of the invocation. If this invocation is not
-   * part of a cascade expression, then this is the same as {@link #getTarget()}. If this invocation
+   * part of a cascade expression, then this is the same as [getTarget]. If this invocation
    * is part of a cascade expression, then the target stored with the cascade expression is
    * returned.
    * @return the expression used to compute the receiver of the invocation
    * @see #getTarget()
    */
   Expression get realTarget {
     if (isCascaded()) {
       ASTNode ancestor = parent;
       while (ancestor is! CascadeExpression) {
         if (ancestor == null) {
           return _target;
         }
         ancestor = ancestor.parent;
       }
       return ((ancestor as CascadeExpression)).target;
     }
     return _target;
   }
 
   /**
-   * Return the expression producing the object on which the method is defined, or {@code null} if
-   * there is no target (that is, the target is implicitly {@code this}) or if this method
+   * Return 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`) or if this method
    * invocation is part of a cascade expression.
    * @return the expression producing the object on which the method is defined
    * @see #getRealTarget()
    */
   Expression get target => _target;
 
   /**
-   * Return {@code true} if this expression is cascaded. If it is, then the target of this
-   * expression is not stored locally but is stored in the nearest ancestor that is a{@link CascadeExpression}.
-   * @return {@code true} if this expression is cascaded
+   * Return `true` if this expression is cascaded. If it is, then the target of this
+   * expression is not stored locally but is stored in the nearest ancestor that is a[CascadeExpression].
+   * @return `true` if this expression is cascaded
    */
   bool isCascaded() => _period != null && identical(_period.type, TokenType.PERIOD_PERIOD);
 
   /**
    * Set the list of arguments to the method to the given list.
    * @param argumentList the list of arguments to the method
    */
   void set argumentList(ArgumentList argumentList2) {
     this._argumentList = becomeParentOf(argumentList2);
   }
@@ skipping 21 matching lines @@
   void set target(Expression expression) {
     _target = becomeParentOf(expression);
   }
   void visitChildren(ASTVisitor<Object> visitor) {
     safelyVisitChild(_target, visitor);
     safelyVisitChild(_methodName, visitor);
     safelyVisitChild(_argumentList, visitor);
   }
 }
 /**
- * Instances of the class {@code NamedExpression} represent an expression that has a name associated
+ * Instances of the class `NamedExpression` represent an expression that has a name associated
  * with it. They are used in method invocations when there are named parameters.
  * <pre>
- * namedExpression ::={@link Label name} {@link Expression expression}</pre>
+ * namedExpression ::=[Label name] [Expression expression]</pre>
  * @coverage dart.engine.ast
  */
 class NamedExpression extends Expression {
 
   /**
    * The name associated with the expression.
    */
   Label _name;
 
   /**
@@ skipping 14 matching lines @@
   /**
    * Initialize a newly created named expression.
    * @param name the name associated with the expression
    * @param expression the expression with which the name is associated
    */
   NamedExpression({Label name, Expression expression}) : this.full(name, expression);
   accept(ASTVisitor visitor) => visitor.visitNamedExpression(this);
   Token get beginToken => _name.beginToken;
 
   /**
-   * Return the element representing the parameter being named by this expression, or {@code null}if the AST structure has not been resolved or if there is no parameter with the same name as
+   * Return the element representing the parameter being named by this expression, or `null`if the AST structure has not been resolved or if there is no parameter with the same name as
    * this expression.
    * @return the element representing the parameter being named by this expression
    */
   ParameterElement get element {
     Element element = _name.label.element;
     if (element is ParameterElement) {
       return element as ParameterElement;
     }
     return null;
   }
@@ skipping 25 matching lines @@
    */
   void set name(Label identifier) {
     _name = becomeParentOf(identifier);
   }
   void visitChildren(ASTVisitor<Object> visitor) {
     safelyVisitChild(_name, visitor);
     safelyVisitChild(_expression, visitor);
   }
 }
 /**
- * The abstract class {@code NamespaceDirective} defines the behavior common to nodes that represent
+ * The abstract class `NamespaceDirective` defines the behavior common to nodes that represent
  * a directive that impacts the namespace of a library.
  * <pre>
- * directive ::={@link ExportDirective exportDirective}| {@link ImportDirective importDirective}</pre>
+ * directive ::=[ExportDirective exportDirective]| [ImportDirective importDirective]</pre>
  * @coverage dart.engine.ast
  */
 abstract class NamespaceDirective extends UriBasedDirective {
 
   /**
    * The token representing the 'import' or 'export' keyword.
    */
   Token _keyword;
 
   /**
@@ skipping 59 matching lines @@
   /**
    * Set the semicolon terminating the directive to the given token.
    * @param semicolon the semicolon terminating the directive
    */
   void set semicolon(Token semicolon2) {
     this._semicolon = semicolon2;
   }
   Token get firstTokenAfterCommentAndMetadata => _keyword;
 }
 /**
- * Instances of the class {@code NativeFunctionBody} represent a function body that consists of a
+ * Instances of the class `NativeFunctionBody` represent a function body that consists of a
  * native keyword followed by a string literal.
  * <pre>
  * nativeFunctionBody ::=
- * 'native' {@link SimpleStringLiteral simpleStringLiteral} ';'
+ * 'native' [SimpleStringLiteral simpleStringLiteral] ';'
  * </pre>
  * @coverage dart.engine.ast
  */
 class NativeFunctionBody extends FunctionBody {
 
   /**
    * The token representing 'native' that marks the start of the function body.
    */
   Token _nativeToken;
 
@@ skipping 47 matching lines @@
   /**
    * Return the string literal representing the string after the 'native' token.
    * @return the string literal representing the string after the 'native' token
    */
   StringLiteral get stringLiteral => _stringLiteral;
   void visitChildren(ASTVisitor<Object> visitor) {
     safelyVisitChild(_stringLiteral, visitor);
   }
 }
 /**
- * The abstract class {@code NormalFormalParameter} defines the behavior common to formal parameters
+ * The abstract class `NormalFormalParameter` defines the behavior common to formal parameters
  * that are required (are not optional).
  * <pre>
- * normalFormalParameter ::={@link FunctionTypedFormalParameter functionSignature}| {@link FieldFormalParameter fieldFormalParameter}| {@link SimpleFormalParameter simpleFormalParameter}</pre>
+ * normalFormalParameter ::=[FunctionTypedFormalParameter functionSignature]| [FieldFormalParameter fieldFormalParameter]| [SimpleFormalParameter simpleFormalParameter]</pre>
  * @coverage dart.engine.ast
  */
 abstract class NormalFormalParameter extends FormalParameter {
 
   /**
-   * The documentation comment associated with this parameter, or {@code null} if this parameter
+   * The documentation comment associated with this parameter, or `null` if this parameter
    * does not have a documentation comment associated with it.
    */
   Comment _comment;
 
   /**
    * The annotations associated with this parameter.
    */
   NodeList<Annotation> _metadata;
 
   /**
@@ skipping 16 matching lines @@
 
   /**
    * Initialize a newly created formal parameter.
    * @param comment the documentation comment associated with this parameter
    * @param metadata the annotations associated with this parameter
    * @param identifier the name of the parameter being declared
    */
   NormalFormalParameter({Comment comment, List<Annotation> metadata, SimpleIdentifier identifier}) : this.full(comment, metadata, identifier);
 
   /**
-   * Return the documentation comment associated with this parameter, or {@code null} if this
+   * Return the documentation comment associated with this parameter, or `null` if this
    * parameter does not have a documentation comment associated with it.
    * @return the documentation comment associated with this parameter
    */
   Comment get documentationComment => _comment;
   SimpleIdentifier get identifier => _identifier;
   ParameterKind get kind {
     ASTNode parent = this.parent;
     if (parent is DefaultFormalParameter) {
       return ((parent as DefaultFormalParameter)).kind;
     }
     return ParameterKind.REQUIRED;
   }
 
   /**
    * Return the annotations associated with this parameter.
    * @return the annotations associated with this parameter
    */
   NodeList<Annotation> get metadata => _metadata;
 
   /**
-   * Return {@code true} if this parameter was declared with the 'const' modifier.
-   * @return {@code true} if this parameter was declared with the 'const' modifier
+   * Return `true` if this parameter was declared with the 'const' modifier.
+   * @return `true` if this parameter was declared with the 'const' modifier
    */
   bool isConst();
 
   /**
-   * Return {@code true} if this parameter was declared with the 'final' modifier. Parameters that
-   * are declared with the 'const' modifier will return {@code false} even though they are
+   * Return `true` if this parameter was declared with the 'final' modifier. Parameters that
+   * are declared with the 'const' modifier will return `false` even though they are
    * implicitly final.
-   * @return {@code true} if this parameter was declared with the 'final' modifier
+   * @return `true` if this parameter was declared with the 'final' modifier
    */
   bool isFinal();
 
   /**
    * Set the documentation comment associated with this parameter to the given comment
    * @param comment the documentation comment to be associated with this parameter
    */
   void set documentationComment(Comment comment2) {
     this._comment = becomeParentOf(comment2);
   }
@@ skipping 10 matching lines @@
       safelyVisitChild(_comment, visitor);
       _metadata.accept(visitor);
     } else {
       for (ASTNode child in sortedCommentAndAnnotations) {
         child.accept(visitor);
       }
     }
   }
 
   /**
-   * Return {@code true} if the comment is lexically before any annotations.
-   * @return {@code true} if the comment is lexically before any annotations
+   * Return `true` if the comment is lexically before any annotations.
+   * @return `true` if the comment is lexically before any annotations
    */
   bool commentIsBeforeAnnotations() {
     if (_comment == null || _metadata.isEmpty) {
       return true;
     }
     Annotation firstAnnotation = _metadata[0];
     return _comment.offset < firstAnnotation.offset;
   }
 
   /**
    * Return an array containing the comment and annotations associated with this parameter, sorted
    * in lexical order.
    * @return the comment and annotations associated with this parameter in the order in which they
    * appeared in the original source
    */
   List<ASTNode> get sortedCommentAndAnnotations {
     List<ASTNode> childList = new List<ASTNode>();
     childList.add(_comment);
     childList.addAll(_metadata);
     List<ASTNode> children = new List.from(childList);
     children.sort(ASTNode.LEXICAL_ORDER);
     return children;
   }
 }
 /**
- * Instances of the class {@code NullLiteral} represent a null literal expression.
+ * Instances of the class `NullLiteral` represent a null literal expression.
  * <pre>
  * nullLiteral ::=
  * 'null'
  * </pre>
  * @coverage dart.engine.ast
  */
 class NullLiteral extends Literal {
 
   /**
    * The token representing the literal.
@@ skipping 27 matching lines @@
    * Set the token representing the literal to the given token.
    * @param literal the token representing the literal
    */
   void set literal(Token literal2) {
     this._literal = literal2;
   }
   void visitChildren(ASTVisitor<Object> visitor) {
   }
 }
 /**
- * Instances of the class {@code ParenthesizedExpression} represent a parenthesized expression.
+ * Instances of the class `ParenthesizedExpression` represent a parenthesized expression.
  * <pre>
  * parenthesizedExpression ::=
- * '(' {@link Expression expression} ')'
+ * '(' [Expression expression] ')'
  * </pre>
  * @coverage dart.engine.ast
  */
 class ParenthesizedExpression extends Expression {
 
   /**
    * The left parenthesis.
    */
   Token _leftParenthesis;
 
@@ skipping 69 matching lines @@
    * @param parenthesis the right parenthesis
    */
   void set rightParenthesis(Token parenthesis) {
     _rightParenthesis = parenthesis;
   }
   void visitChildren(ASTVisitor<Object> visitor) {
     safelyVisitChild(_expression, visitor);
   }
 }
 /**
- * Instances of the class {@code PartDirective} represent a part directive.
+ * Instances of the class `PartDirective` represent a part directive.
  * <pre>
- * partDirective ::={@link Annotation metadata} 'part' {@link StringLiteral partUri} ';'
+ * partDirective ::=[Annotation metadata] 'part' [StringLiteral partUri] ';'
  * </pre>
  * @coverage dart.engine.ast
  */
 class PartDirective extends UriBasedDirective {
 
   /**
    * The token representing the 'part' token.
    */
   Token _partToken;
 
@@ skipping 52 matching lines @@
   /**
    * Set the semicolon terminating the directive to the given token.
    * @param semicolon the semicolon terminating the directive
    */
   void set semicolon(Token semicolon2) {
     this._semicolon = semicolon2;
   }
   Token get firstTokenAfterCommentAndMetadata => _partToken;
 }
 /**
- * Instances of the class {@code PartOfDirective} represent a part-of directive.
+ * Instances of the class `PartOfDirective` represent a part-of directive.
  * <pre>
- * partOfDirective ::={@link Annotation metadata} 'part' 'of' {@link Identifier libraryName} ';'
+ * partOfDirective ::=[Annotation metadata] 'part' 'of' [Identifier libraryName] ';'
  * </pre>
  * @coverage dart.engine.ast
  */
 class PartOfDirective extends Directive {
 
   /**
    * The token representing the 'part' token.
    */
   Token _partToken;
 
@@ skipping 97 matching lines @@
   void set semicolon(Token semicolon2) {
     this._semicolon = semicolon2;
   }
   void visitChildren(ASTVisitor<Object> visitor) {
     super.visitChildren(visitor);
     safelyVisitChild(_libraryName, visitor);
   }
   Token get firstTokenAfterCommentAndMetadata => _partToken;
 }
 /**
- * Instances of the class {@code PostfixExpression} represent a postfix unary expression.
+ * Instances of the class `PostfixExpression` represent a postfix unary expression.
  * <pre>
- * postfixExpression ::={@link Expression operand} {@link Token operator}</pre>
+ * postfixExpression ::=[Expression operand] [Token operator]</pre>
  * @coverage dart.engine.ast
  */
 class PostfixExpression extends Expression {
 
   /**
    * The expression computing the operand for the operator.
    */
   Expression _operand;
 
   /**
    * The postfix operator being applied to the operand.
    */
   Token _operator;
 
   /**
-   * The element associated with this the operator based on the propagated type of the operand, or{@code null} if the AST structure has not been resolved, if the operator is not user definable,
+   * The element associated with this the operator based on the propagated type of the operand, or`null` if the AST structure has not been resolved, if the operator is not user definable,
    * or if the operator could not be resolved.
    */
   MethodElement _propagatedElement;
 
   /**
-   * The element associated with the operator based on the static type of the operand, or{@code null} if the AST structure has not been resolved, if the operator is not user definable,
+   * The element associated with the operator based on the static type of the operand, or`null` if the AST structure has not been resolved, if the operator is not user definable,
    * or if the operator could not be resolved.
    */
   MethodElement _staticElement;
 
   /**
    * Initialize a newly created postfix expression.
    * @param operand the expression computing the operand for the operator
    * @param operator the postfix operator being applied to the operand
    */
   PostfixExpression.full(Expression operand, Token operator) {
     this._operand = becomeParentOf(operand);
     this._operator = operator;
   }
 
   /**
    * Initialize a newly created postfix expression.
    * @param operand the expression computing the operand for the operator
    * @param operator the postfix operator being applied to the operand
    */
   PostfixExpression({Expression operand, Token operator}) : this.full(operand, operator);
   accept(ASTVisitor visitor) => visitor.visitPostfixExpression(this);
   Token get beginToken => _operand.beginToken;
 
   /**
-   * Return the element associated with the operator based on the propagated type of the operand, or{@code null} if the AST structure has not been resolved, if the operator is not user definable,
+   * Return the element associated with the operator based on the propagated type of the operand, or`null` if the AST structure has not been resolved, if the operator is not user definable,
    * or if the operator could not be resolved. One example of the latter case is an operator that is
    * not defined for the type of the operand.
    * @return the element associated with the operator
    */
   MethodElement get element => _propagatedElement;
   Token get endToken => _operator;
 
   /**
    * Return the expression computing the operand for the operator.
    * @return the expression computing the operand for the operator
    */
   Expression get operand => _operand;
 
   /**
    * Return the postfix operator being applied to the operand.
    * @return the postfix operator being applied to the operand
    */
   Token get operator => _operator;
 
   /**
-   * Return the element associated with the operator based on the static type of the operand, or{@code null} if the AST structure has not been resolved, if the operator is not user definable,
+   * Return the element associated with the operator based on the static type of the operand, or`null` if the AST structure has not been resolved, if the operator is not user definable,
    * or if the operator could not be resolved. One example of the latter case is an operator that is
    * not defined for the type of the operand.
    * @return the element associated with the operator
    */
   MethodElement get staticElement => _staticElement;
 
   /**
    * Set the element associated with the operator based on the propagated type of the operand to the
    * given element.
    * @param element the element to be associated with the operator
@@ skipping 26 matching lines @@
   void set staticElement(MethodElement element) {
     _staticElement = element;
   }
   void visitChildren(ASTVisitor<Object> visitor) {
     safelyVisitChild(_operand, visitor);
   }
 
   /**
    * If the AST structure has been resolved, and the function being invoked is known based on
    * propagated type information, then return the parameter element representing the parameter to
-   * which the value of the operand will be bound. Otherwise, return {@code null}.
-   * <p>
-   * This method is only intended to be used by {@link Expression#getParameterElement()}.
+   * which the value of the operand will be bound. Otherwise, return `null`.
+   *
+   * This method is only intended to be used by [Expression#getParameterElement].
    * @return the parameter element representing the parameter to which the value of the right
    * operand will be bound
    */
   ParameterElement get propagatedParameterElementForOperand {
     if (_propagatedElement == null) {
       return null;
     }
     List<ParameterElement> parameters = _propagatedElement.parameters;
     if (parameters.length < 1) {
       return null;
     }
     return parameters[0];
   }
 
   /**
    * If the AST structure has been resolved, and the function being invoked is known based on static
    * type information, then return the parameter element representing the parameter to which the
-   * value of the operand will be bound. Otherwise, return {@code null}.
-   * <p>
-   * This method is only intended to be used by {@link Expression#getStaticParameterElement()}.
+   * value of the operand will be bound. Otherwise, return `null`.
+   *
+   * This method is only intended to be used by [Expression#getStaticParameterElement].
    * @return the parameter element representing the parameter to which the value of the right
    * operand will be bound
    */
   ParameterElement get staticParameterElementForOperand {
     if (_staticElement == null) {
       return null;
     }
     List<ParameterElement> parameters = _staticElement.parameters;
     if (parameters.length < 1) {
       return null;
     }
     return parameters[0];
   }
 }
 /**
- * Instances of the class {@code PrefixExpression} represent a prefix unary expression.
+ * Instances of the class `PrefixExpression` represent a prefix unary expression.
  * <pre>
- * prefixExpression ::={@link Token operator} {@link Expression operand}</pre>
+ * prefixExpression ::=[Token operator] [Expression operand]</pre>
  * @coverage dart.engine.ast
  */
 class PrefixExpression extends Expression {
 
   /**
    * The prefix operator being applied to the operand.
    */
   Token _operator;
 
   /**
    * The expression computing the operand for the operator.
    */
   Expression _operand;
 
   /**
-   * The element associated with the operator based on the static type of the operand, or{@code null} if the AST structure has not been resolved, if the operator is not user definable,
+   * The element associated with the operator based on the static type of the operand, or`null` if the AST structure has not been resolved, if the operator is not user definable,
    * or if the operator could not be resolved.
    */
   MethodElement _staticElement;
 
   /**
-   * The element associated with the operator based on the propagated type of the operand, or{@code null} if the AST structure has not been resolved, if the operator is not user definable,
+   * The element associated with the operator based on the propagated type of the operand, or`null` if the AST structure has not been resolved, if the operator is not user definable,
    * or if the operator could not be resolved.
    */
   MethodElement _propagatedElement;
 
   /**
    * Initialize a newly created prefix expression.
    * @param operator the prefix operator being applied to the operand
    * @param operand the expression computing the operand for the operator
    */
   PrefixExpression.full(Token operator, Expression operand) {
     this._operator = operator;
     this._operand = becomeParentOf(operand);
   }
 
   /**
    * Initialize a newly created prefix expression.
    * @param operator the prefix operator being applied to the operand
    * @param operand the expression computing the operand for the operator
    */
   PrefixExpression({Token operator, Expression operand}) : this.full(operator, operand);
   accept(ASTVisitor visitor) => visitor.visitPrefixExpression(this);
   Token get beginToken => _operator;
 
   /**
-   * Return the element associated with the operator based on the propagated type of the operand, or{@code null} if the AST structure has not been resolved, if the operator is not user definable,
+   * Return the element associated with the operator based on the propagated type of the operand, or`null` if the AST structure has not been resolved, if the operator is not user definable,
    * or if the operator could not be resolved. One example of the latter case is an operator that is
    * not defined for the type of the operand.
    * @return the element associated with the operator
    */
   MethodElement get element => _propagatedElement;
   Token get endToken => _operand.endToken;
 
   /**
    * Return the expression computing the operand for the operator.
    * @return the expression computing the operand for the operator
    */
   Expression get operand => _operand;
 
   /**
    * Return the prefix operator being applied to the operand.
    * @return the prefix operator being applied to the operand
    */
   Token get operator => _operator;
 
   /**
-   * Return the element associated with the operator based on the static type of the operand, or{@code null} if the AST structure has not been resolved, if the operator is not user definable,
+   * Return the element associated with the operator based on the static type of the operand, or`null` if the AST structure has not been resolved, if the operator is not user definable,
    * or if the operator could not be resolved. One example of the latter case is an operator that is
    * not defined for the type of the operand.
    * @return the element associated with the operator
    */
   MethodElement get staticElement => _staticElement;
 
   /**
    * Set the element associated with the operator based on the propagated type of the operand to the
    * given element.
    * @param element the element to be associated with the operator
@@ skipping 26 matching lines @@
   void set staticElement(MethodElement element) {
     _staticElement = element;
   }
   void visitChildren(ASTVisitor<Object> visitor) {
     safelyVisitChild(_operand, visitor);
   }
 
   /**
    * If the AST structure has been resolved, and the function being invoked is known based on
    * propagated type information, then return the parameter element representing the parameter to
-   * which the value of the operand will be bound. Otherwise, return {@code null}.
-   * <p>
-   * This method is only intended to be used by {@link Expression#getParameterElement()}.
+   * which the value of the operand will be bound. Otherwise, return `null`.
+   *
+   * This method is only intended to be used by [Expression#getParameterElement].
    * @return the parameter element representing the parameter to which the value of the right
    * operand will be bound
    */
   ParameterElement get propagatedParameterElementForOperand {
     if (_propagatedElement == null) {
       return null;
     }
     List<ParameterElement> parameters = _propagatedElement.parameters;
     if (parameters.length < 1) {
       return null;
     }
     return parameters[0];
   }
 
   /**
    * If the AST structure has been resolved, and the function being invoked is known based on static
    * type information, then return the parameter element representing the parameter to which the
-   * value of the operand will be bound. Otherwise, return {@code null}.
-   * <p>
-   * This method is only intended to be used by {@link Expression#getStaticParameterElement()}.
+   * value of the operand will be bound. Otherwise, return `null`.
+   *
+   * This method is only intended to be used by [Expression#getStaticParameterElement].
    * @return the parameter element representing the parameter to which the value of the right
    * operand will be bound
    */
   ParameterElement get staticParameterElementForOperand {
     if (_staticElement == null) {
       return null;
     }
     List<ParameterElement> parameters = _staticElement.parameters;
     if (parameters.length < 1) {
       return null;
     }
     return parameters[0];
   }
 }
 /**
- * Instances of the class {@code PrefixedIdentifier} represent either an identifier that is prefixed
+ * Instances of the class `PrefixedIdentifier` represent either an identifier that is prefixed
  * or an access to an object property where the target of the property access is a simple
  * identifier.
  * <pre>
- * prefixedIdentifier ::={@link SimpleIdentifier prefix} '.' {@link SimpleIdentifier identifier}</pre>
+ * prefixedIdentifier ::=[SimpleIdentifier prefix] '.' [SimpleIdentifier identifier]</pre>
  * @coverage dart.engine.ast
  */
 class PrefixedIdentifier extends Identifier {
 
   /**
    * The prefix associated with the library in which the identifier is defined.
    */
   SimpleIdentifier _prefix;
 
   /**
@@ skipping 83 matching lines @@
    */
   void set prefix(SimpleIdentifier identifier) {
     _prefix = becomeParentOf(identifier);
   }
   void visitChildren(ASTVisitor<Object> visitor) {
     safelyVisitChild(_prefix, visitor);
     safelyVisitChild(_identifier, visitor);
   }
 }
 /**
- * Instances of the class {@code PropertyAccess} represent the access of a property of an object.
- * <p>
- * Note, however, that accesses to properties of objects can also be represented as{@link PrefixedIdentifier prefixed identifier} nodes in cases where the target is also a simple
+ * Instances of the class `PropertyAccess` represent the access of a property of an object.
+ *
+ * Note, however, that accesses to properties of objects can also be represented as[PrefixedIdentifier prefixed identifier] nodes in cases where the target is also a simple
  * identifier.
  * <pre>
- * propertyAccess ::={@link Expression target} '.' {@link SimpleIdentifier propertyName}</pre>
+ * propertyAccess ::=[Expression target] '.' [SimpleIdentifier propertyName]</pre>
  * @coverage dart.engine.ast
  */
 class PropertyAccess extends Expression {
 
   /**
    * The expression computing the object defining the property being accessed.
    */
   Expression _target;
 
   /**
@@ skipping 41 matching lines @@
   Token get operator => _operator;
 
   /**
    * Return the name of the property being accessed.
    * @return the name of the property being accessed
    */
   SimpleIdentifier get propertyName => _propertyName;
 
   /**
    * Return the expression used to compute the receiver of the invocation. If this invocation is not
-   * part of a cascade expression, then this is the same as {@link #getTarget()}. If this invocation
+   * part of a cascade expression, then this is the same as [getTarget]. If this invocation
    * is part of a cascade expression, then the target stored with the cascade expression is
    * returned.
    * @return the expression used to compute the receiver of the invocation
    * @see #getTarget()
    */
   Expression get realTarget {
     if (isCascaded()) {
       ASTNode ancestor = parent;
       while (ancestor is! CascadeExpression) {
         if (ancestor == null) {
           return _target;
         }
         ancestor = ancestor.parent;
       }
       return ((ancestor as CascadeExpression)).target;
     }
     return _target;
   }
 
   /**
-   * Return the expression computing the object defining the property being accessed, or{@code null} if this property access is part of a cascade expression.
+   * Return the expression computing the object defining the property being accessed, or`null` if this property access is part of a cascade expression.
    * @return the expression computing the object defining the property being accessed
    * @see #getRealTarget()
    */
   Expression get target => _target;
   bool isAssignable() => true;
 
   /**
-   * Return {@code true} if this expression is cascaded. If it is, then the target of this
-   * expression is not stored locally but is stored in the nearest ancestor that is a{@link CascadeExpression}.
-   * @return {@code true} if this expression is cascaded
+   * Return `true` if this expression is cascaded. If it is, then the target of this
+   * expression is not stored locally but is stored in the nearest ancestor that is a[CascadeExpression].
+   * @return `true` if this expression is cascaded
    */
   bool isCascaded() => _operator != null && identical(_operator.type, TokenType.PERIOD_PERIOD);
 
   /**
    * Set the property access operator to the given token.
    * @param operator the property access operator
    */
   void set operator(Token operator2) {
     this._operator = operator2;
   }
@@ skipping 13 matching lines @@
    */
   void set target(Expression expression) {
     _target = becomeParentOf(expression);
   }
   void visitChildren(ASTVisitor<Object> visitor) {
     safelyVisitChild(_target, visitor);
     safelyVisitChild(_propertyName, visitor);
   }
 }
 /**
- * Instances of the class {@code RedirectingConstructorInvocation} represent the invocation of a
+ * Instances of the class `RedirectingConstructorInvocation` represent the invocation of a
  * another constructor in the same class from within a constructor's initialization list.
  * <pre>
  * redirectingConstructorInvocation ::=
  * 'this' ('.' identifier)? arguments
  * </pre>
  * @coverage dart.engine.ast
  */
 class RedirectingConstructorInvocation extends ConstructorInitializer {
 
   /**
    * The token for the 'this' keyword.
    */
   Token _keyword;
 
   /**
-   * The token for the period before the name of the constructor that is being invoked, or{@code null} if the unnamed constructor is being invoked.
+   * The token for the period before the name of the constructor that is being invoked, or`null` if the unnamed constructor is being invoked.
    */
   Token _period;
 
   /**
-   * The name of the constructor that is being invoked, or {@code null} if the unnamed constructor
+   * The name of the constructor that is being invoked, or `null` if the unnamed constructor
    * is being invoked.
    */
   SimpleIdentifier _constructorName;
 
   /**
    * The list of arguments to the constructor.
    */
   ArgumentList _argumentList;
 
   /**
-   * The element associated with the constructor based on static type information, or {@code null}if the AST structure has not been resolved or if the constructor could not be resolved.
+   * The element associated with the constructor based on static type information, or `null`if the AST structure has not been resolved or if the constructor could not be resolved.
    */
   ConstructorElement _staticElement;
 
   /**
-   * The element associated with the constructor based on propagated type information, or{@code null} if the AST structure has not been resolved or if the constructor could not be
+   * The element associated with the constructor based on propagated type information, or`null` if the AST structure has not been resolved or if the constructor could not be
    * resolved.
    */
   ConstructorElement _propagatedElement;
 
   /**
    * Initialize a newly created redirecting invocation to invoke the constructor with the given name
    * with the given arguments.
    * @param keyword the token for the 'this' keyword
    * @param period the token for the period before the name of the constructor that is being invoked
    * @param constructorName the name of the constructor that is being invoked
@@ skipping 18 matching lines @@
   accept(ASTVisitor visitor) => visitor.visitRedirectingConstructorInvocation(this);
 
   /**
    * Return the list of arguments to the constructor.
    * @return the list of arguments to the constructor
    */
   ArgumentList get argumentList => _argumentList;
   Token get beginToken => _keyword;
 
   /**
-   * Return the name of the constructor that is being invoked, or {@code null} if the unnamed
+   * Return the name of the constructor that is being invoked, or `null` if the unnamed
    * constructor is being invoked.
    * @return the name of the constructor that is being invoked
    */
   SimpleIdentifier get constructorName => _constructorName;
 
   /**
-   * Return the element associated with the constructor based on propagated type information, or{@code null} if the AST structure has not been resolved or if the constructor could not be
+   * Return the element associated with the constructor based on propagated type information, or`null` if the AST structure has not been resolved or if the constructor could not be
    * resolved.
    * @return the element associated with the super constructor
    */
   ConstructorElement get element => _propagatedElement;
   Token get endToken => _argumentList.endToken;
 
   /**
    * Return the token for the 'this' keyword.
    * @return the token for the 'this' keyword
    */
   Token get keyword => _keyword;
 
   /**
-   * Return the token for the period before the name of the constructor that is being invoked, or{@code null} if the unnamed constructor is being invoked.
+   * Return the token for the period before the name of the constructor that is being invoked, or`null` if the unnamed constructor is being invoked.
    * @return the token for the period before the name of the constructor that is being invoked
    */
   Token get period => _period;
 
   /**
-   * Return the element associated with the constructor based on static type information, or{@code null} if the AST structure has not been resolved or if the constructor could not be
+   * Return the element associated with the constructor based on static type information, or`null` if the AST structure has not been resolved or if the constructor could not be
    * resolved.
    * @return the element associated with the constructor
    */
   ConstructorElement get staticElement => _staticElement;
 
   /**
    * Set the list of arguments to the constructor to the given list.
    * @param argumentList the list of arguments to the constructor
    */
   void set argumentList(ArgumentList argumentList2) {
@@ skipping 41 matching lines @@
    */
   void set staticElement(ConstructorElement element) {
     this._staticElement = element;
   }
   void visitChildren(ASTVisitor<Object> visitor) {
     safelyVisitChild(_constructorName, visitor);
     safelyVisitChild(_argumentList, visitor);
   }
 }
 /**
- * Instances of the class {@code RethrowExpression} represent a rethrow expression.
+ * Instances of the class `RethrowExpression` represent a rethrow expression.
  * <pre>
  * rethrowExpression ::=
  * 'rethrow'
  * </pre>
  * @coverage dart.engine.ast
  */
 class RethrowExpression extends Expression {
 
   /**
    * The token representing the 'rethrow' keyword.
@@ skipping 27 matching lines @@
    * Set the token representing the 'rethrow' keyword to the given token.
    * @param keyword the token representing the 'rethrow' keyword
    */
   void set keyword(Token keyword2) {
     this._keyword = keyword2;
   }
   void visitChildren(ASTVisitor<Object> visitor) {
   }
 }
 /**
- * Instances of the class {@code ReturnStatement} represent a return statement.
+ * Instances of the class `ReturnStatement` represent a return statement.
  * <pre>
  * returnStatement ::=
- * 'return' {@link Expression expression}? ';'
+ * 'return' [Expression expression]? ';'
  * </pre>
  * @coverage dart.engine.ast
  */
 class ReturnStatement extends Statement {
 
   /**
    * The token representing the 'return' keyword.
    */
   Token _keyword;
 
   /**
-   * The expression computing the value to be returned, or {@code null} if no explicit value was
+   * The expression computing the value to be returned, or `null` if no explicit value was
    * provided.
    */
   Expression _expression;
 
   /**
    * The semicolon terminating the statement.
    */
   Token _semicolon;
 
   /**
@@ skipping 13 matching lines @@
    * @param keyword the token representing the 'return' keyword
    * @param expression the expression computing the value to be returned
    * @param semicolon the semicolon terminating the statement
    */
   ReturnStatement({Token keyword, Expression expression, Token semicolon}) : this.full(keyword, expression, semicolon);
   accept(ASTVisitor visitor) => visitor.visitReturnStatement(this);
   Token get beginToken => _keyword;
   Token get endToken => _semicolon;
 
   /**
-   * Return the expression computing the value to be returned, or {@code null} if no explicit value
+   * Return the expression computing the value to be returned, or `null` if no explicit value
    * was provided.
    * @return the expression computing the value to be returned
    */
   Expression get expression => _expression;
 
   /**
    * Return the token representing the 'return' keyword.
    * @return the token representing the 'return' keyword
    */
   Token get keyword => _keyword;
@@ skipping 25 matching lines @@
    * @param semicolon the semicolon terminating the statement
    */
   void set semicolon(Token semicolon2) {
     this._semicolon = semicolon2;
   }
   void visitChildren(ASTVisitor<Object> visitor) {
     safelyVisitChild(_expression, visitor);
   }
 }
 /**
- * Instances of the class {@code ScriptTag} represent the script tag that can optionally occur at
+ * Instances of the class `ScriptTag` represent the script tag that can optionally occur at
  * the beginning of a compilation unit.
  * <pre>
  * scriptTag ::=
  * '#!' (~NEWLINE)* NEWLINE
  * </pre>
  * @coverage dart.engine.ast
  */
 class ScriptTag extends ASTNode {
 
   /**
@@ skipping 28 matching lines @@
    * Set the token representing this script tag to the given script tag.
    * @param scriptTag the token representing this script tag
    */
   void set scriptTag(Token scriptTag2) {
     this._scriptTag = scriptTag2;
   }
   void visitChildren(ASTVisitor<Object> visitor) {
   }
 }
 /**
- * Instances of the class {@code ShowCombinator} represent a combinator that restricts the names
+ * Instances of the class `ShowCombinator` represent a combinator that restricts the names
  * being imported to those in a given list.
  * <pre>
  * showCombinator ::=
- * 'show' {@link SimpleIdentifier identifier} (',' {@link SimpleIdentifier identifier})
+ * 'show' [SimpleIdentifier identifier] (',' [SimpleIdentifier identifier])
  * </pre>
  * @coverage dart.engine.ast
  */
 class ShowCombinator extends Combinator {
 
   /**
    * The list of names from the library that are made visible by this combinator.
    */
   NodeList<SimpleIdentifier> _shownNames;
 
@@ skipping 19 matching lines @@
   /**
    * Return the list of names from the library that are made visible by this combinator.
    * @return the list of names from the library that are made visible by this combinator
    */
   NodeList<SimpleIdentifier> get shownNames => _shownNames;
   void visitChildren(ASTVisitor<Object> visitor) {
     _shownNames.accept(visitor);
   }
 }
 /**
- * Instances of the class {@code SimpleFormalParameter} represent a simple formal parameter.
+ * Instances of the class `SimpleFormalParameter` represent a simple formal parameter.
  * <pre>
  * simpleFormalParameter ::=
- * ('final' {@link TypeName type} | 'var' | {@link TypeName type})? {@link SimpleIdentifier identifier}</pre>
+ * ('final' [TypeName type] | 'var' | [TypeName type])? [SimpleIdentifier identifier]</pre>
  * @coverage dart.engine.ast
  */
 class SimpleFormalParameter extends NormalFormalParameter {
 
   /**
-   * The token representing either the 'final', 'const' or 'var' keyword, or {@code null} if no
+   * The token representing either the 'final', 'const' or 'var' keyword, or `null` if no
    * keyword was used.
    */
   Token _keyword;
 
   /**
-   * The name of the declared type of the parameter, or {@code null} if the parameter does not have
+   * The name of the declared type of the parameter, or `null` if the parameter does not have
    * a declared type.
    */
   TypeName _type;
 
   /**
    * Initialize a newly created formal parameter.
    * @param comment the documentation comment associated with this parameter
    * @param metadata the annotations associated with this parameter
    * @param keyword the token representing either the 'final', 'const' or 'var' keyword
    * @param type the name of the declared type of the parameter
@@ skipping 24 matching lines @@
   }
   Token get endToken => identifier.endToken;
 
   /**
    * Return the token representing either the 'final', 'const' or 'var' keyword.
    * @return the token representing either the 'final', 'const' or 'var' keyword
    */
   Token get keyword => _keyword;
 
   /**
-   * Return the name of the declared type of the parameter, or {@code null} if the parameter does
+   * Return the name of the declared type of the parameter, or `null` if the parameter does
    * not have a declared type.
    * @return the name of the declared type of the parameter
    */
   TypeName get type => _type;
   bool isConst() => (_keyword is KeywordToken) && identical(((_keyword as KeywordToken)).keyword, Keyword.CONST);
   bool isFinal() => (_keyword is KeywordToken) && identical(((_keyword as KeywordToken)).keyword, Keyword.FINAL);
 
   /**
    * Set the token representing either the 'final', 'const' or 'var' keyword to the given token.
    * @param keyword the token representing either the 'final', 'const' or 'var' keyword
    */
   void set keyword(Token keyword2) {
     this._keyword = keyword2;
   }
 
   /**
    * Set the name of the declared type of the parameter to the given type name.
    * @param typeName the name of the declared type of the parameter
    */
   void set type(TypeName typeName) {
     _type = becomeParentOf(typeName);
   }
   void visitChildren(ASTVisitor<Object> visitor) {
     super.visitChildren(visitor);
     safelyVisitChild(_type, visitor);
     safelyVisitChild(identifier, visitor);
   }
 }
 /**
- * Instances of the class {@code SimpleIdentifier} represent a simple identifier.
+ * Instances of the class `SimpleIdentifier` represent a simple identifier.
  * <pre>
  * simpleIdentifier ::=
  * initialCharacter internalCharacter
  * initialCharacter ::= '_' | '$' | letter
  * internalCharacter ::= '_' | '$' | letter | digit
  * </pre>
  * @coverage dart.engine.ast
  */
 class SimpleIdentifier extends Identifier {
 
   /**
    * The token representing the identifier.
    */
   Token _token;
 
   /**
-   * The element associated with this identifier based on static type information, or {@code null}if the AST structure has not been resolved or if this identifier could not be resolved.
+   * The element associated with this identifier based on static type information, or `null`if the AST structure has not been resolved or if this identifier could not be resolved.
    */
   Element _staticElement;
 
   /**
-   * The element associated with this identifier based on propagated type information, or{@code null} if the AST structure has not been resolved or if this identifier could not be
+   * The element associated with this identifier based on propagated type information, or`null` if the AST structure has not been resolved or if this identifier could not be
    * resolved.
    */
   Element _propagatedElement;
 
   /**
    * Initialize a newly created identifier.
    * @param token the token representing the identifier
    */
   SimpleIdentifier.full(Token token) {
     this._token = token;
@@ skipping 11 matching lines @@
   String get name => _token.lexeme;
   Element get staticElement => _staticElement;
 
   /**
    * Return the token representing the identifier.
    * @return the token representing the identifier
    */
   Token get token => _token;
 
   /**
-   * Return {@code true} if this identifier is the name being declared in a declaration.
-   * @return {@code true} if this identifier is the name being declared in a declaration
+   * Return `true` if this identifier is the name being declared in a declaration.
+   * @return `true` if this identifier is the name being declared in a declaration
    */
   bool inDeclarationContext() {
     ASTNode parent = this.parent;
     if (parent is CatchClause) {
       CatchClause clause = parent as CatchClause;
       return identical(this, clause.exceptionParameter) || identical(this, clause.stackTraceParameter);
     } else if (parent is ClassDeclaration) {
       return identical(this, ((parent as ClassDeclaration)).name);
     } else if (parent is ClassTypeAlias) {
       return identical(this, ((parent as ClassTypeAlias)).name);
@@ skipping 11 matching lines @@
       return identical(this, ((parent as NormalFormalParameter)).identifier);
     } else if (parent is TypeParameter) {
       return identical(this, ((parent as TypeParameter)).name);
     } else if (parent is VariableDeclaration) {
       return identical(this, ((parent as VariableDeclaration)).name);
     }
     return false;
   }
 
   /**
-   * Return {@code true} if this expression is computing a right-hand value.
-   * <p>
-   * Note that {@link #inGetterContext()} and {@link #inSetterContext()} are not opposites, nor are
-   * they mutually exclusive. In other words, it is possible for both methods to return {@code true}when invoked on the same node.
-   * @return {@code true} if this expression is in a context where a getter will be invoked
+   * Return `true` if this expression is computing a right-hand value.
+   *
+   * Note that [inGetterContext] and [inSetterContext] are not opposites, nor are
+   * they mutually exclusive. In other words, it is possible for both methods to return `true`when invoked on the same node.
+   * @return `true` if this expression is in a context where a getter will be invoked
    */
   bool inGetterContext() {
     ASTNode parent = this.parent;
     ASTNode target = this;
     if (parent is PrefixedIdentifier) {
       PrefixedIdentifier prefixed = parent as PrefixedIdentifier;
       if (identical(prefixed.prefix, this)) {
         return true;
       }
       parent = prefixed.parent;
@@ skipping 12 matching lines @@
     if (parent is AssignmentExpression) {
       AssignmentExpression expr = parent as AssignmentExpression;
       if (identical(expr.leftHandSide, target) && identical(expr.operator.type, TokenType.EQ)) {
         return false;
       }
     }
     return true;
   }
 
   /**
-   * Return {@code true} if this expression is computing a left-hand value.
-   * <p>
-   * Note that {@link #inGetterContext()} and {@link #inSetterContext()} are not opposites, nor are
-   * they mutually exclusive. In other words, it is possible for both methods to return {@code true}when invoked on the same node.
-   * @return {@code true} if this expression is in a context where a setter will be invoked
+   * Return `true` if this expression is computing a left-hand value.
+   *
+   * Note that [inGetterContext] and [inSetterContext] are not opposites, nor are
+   * they mutually exclusive. In other words, it is possible for both methods to return `true`when invoked on the same node.
+   * @return `true` if this expression is in a context where a setter will be invoked
    */
   bool inSetterContext() {
     ASTNode parent = this.parent;
     ASTNode target = this;
     if (parent is PrefixedIdentifier) {
       PrefixedIdentifier prefixed = parent as PrefixedIdentifier;
       if (identical(prefixed.prefix, this)) {
         return false;
       }
       parent = prefixed.parent;
@@ skipping 39 matching lines @@
    * Set the token representing the identifier to the given token.
    * @param token the token representing the literal
    */
   void set token(Token token2) {
     this._token = token2;
   }
   void visitChildren(ASTVisitor<Object> visitor) {
   }
 }
 /**
- * Instances of the class {@code SimpleStringLiteral} represent a string literal expression that
+ * Instances of the class `SimpleStringLiteral` represent a string literal expression that
  * does not contain any interpolations.
  * <pre>
  * simpleStringLiteral ::=
  * rawStringLiteral
  * | basicStringLiteral
  * rawStringLiteral ::=
  * '@' basicStringLiteral
  * simpleStringLiteral ::=
  * multiLineStringLiteral
  * | singleLineStringLiteral
@@ skipping 44 matching lines @@
    */
   Token get literal => _literal;
 
   /**
    * Return the value of the literal.
    * @return the value of the literal
    */
   String get value => _value;
 
   /**
-   * Return {@code true} if this string literal is a multi-line string.
-   * @return {@code true} if this string literal is a multi-line string
+   * Return `true` if this string literal is a multi-line string.
+   * @return `true` if this string literal is a multi-line string
    */
   bool isMultiline() {
     if (_value.length < 6) {
       return false;
     }
     return _value.endsWith("\"\"\"") || _value.endsWith("'''");
   }
 
   /**
-   * Return {@code true} if this string literal is a raw string.
-   * @return {@code true} if this string literal is a raw string
+   * Return `true` if this string literal is a raw string.
+   * @return `true` if this string literal is a raw string
    */
   bool isRaw() => _value.codeUnitAt(0) == 0x40;
   bool isSynthetic() => _literal.isSynthetic();
 
   /**
    * Set the token representing the literal to the given token.
    * @param literal the token representing the literal
    */
   void set literal(Token literal2) {
     this._literal = literal2;
   }
 
   /**
    * Set the value of the literal to the given string.
    * @param string the value of the literal
    */
   void set value(String string) {
     _value = StringUtilities.intern(_value);
   }
   void visitChildren(ASTVisitor<Object> visitor) {
   }
   void appendStringValue(JavaStringBuilder builder) {
     builder.append(value);
   }
 }
 /**
- * Instances of the class {@code Statement} defines the behavior common to nodes that represent a
+ * Instances of the class `Statement` defines the behavior common to nodes that represent a
  * statement.
  * <pre>
- * statement ::={@link Block block}| {@link VariableDeclarationStatement initializedVariableDeclaration ';'}| {@link ForStatement forStatement}| {@link ForEachStatement forEachStatement}| {@link WhileStatement whileStatement}| {@link DoStatement doStatement}| {@link SwitchStatement switchStatement}| {@link IfStatement ifStatement}| {@link TryStatement tryStatement}| {@link BreakStatement breakStatement}| {@link ContinueStatement continueStatement}| {@link ReturnStatement returnStatement}| {@link ExpressionStatement expressionStatement}| {@link FunctionDeclarationStatement functionSignature functionBody}</pre>
+ * statement ::=[Block block]| [VariableDeclarationStatement initializedVariableDeclaration ';']| [ForStatement forStatement]| [ForEachStatement forEachStatement]| [WhileStatement whileStatement]| [DoStatement doStatement]| [SwitchStatement switchStatement]| [IfStatement ifStatement]| [TryStatement tryStatement]| [BreakStatement breakStatement]| [ContinueStatement continueStatement]| [ReturnStatement returnStatement]| [ExpressionStatement expressionStatement]| [FunctionDeclarationStatement functionSignature functionBody]</pre>
  * @coverage dart.engine.ast
  */
 abstract class Statement extends ASTNode {
 }
 /**
- * Instances of the class {@code StringInterpolation} represent a string interpolation literal.
+ * Instances of the class `StringInterpolation` represent a string interpolation literal.
  * <pre>
  * stringInterpolation ::=
- * ''' {@link InterpolationElement interpolationElement}* '''
- * | '"' {@link InterpolationElement interpolationElement}* '"'
+ * ''' [InterpolationElement interpolationElement]* '''
+ * | '"' [InterpolationElement interpolationElement]* '"'
  * </pre>
  * @coverage dart.engine.ast
  */
 class StringInterpolation extends StringLiteral {
 
   /**
    * The elements that will be composed to produce the resulting string.
    */
   NodeList<InterpolationElement> _elements;
 
@@ skipping 21 matching lines @@
   NodeList<InterpolationElement> get elements => _elements;
   Token get endToken => _elements.endToken;
   void visitChildren(ASTVisitor<Object> visitor) {
     _elements.accept(visitor);
   }
   void appendStringValue(JavaStringBuilder builder) {
     throw new IllegalArgumentException();
   }
 }
 /**
- * Instances of the class {@code StringLiteral} represent a string literal expression.
+ * Instances of the class `StringLiteral` represent a string literal expression.
  * <pre>
- * stringLiteral ::={@link SimpleStringLiteral simpleStringLiteral}| {@link AdjacentStrings adjacentStrings}| {@link StringInterpolation stringInterpolation}</pre>
+ * stringLiteral ::=[SimpleStringLiteral simpleStringLiteral]| [AdjacentStrings adjacentStrings]| [StringInterpolation stringInterpolation]</pre>
  * @coverage dart.engine.ast
  */
 abstract class StringLiteral extends Literal {
 
   /**
-   * Return the value of the string literal, or {@code null} if the string is not a constant string
+   * Return the value of the string literal, or `null` if the string is not a constant string
    * without any string interpolation.
    * @return the value of the string literal
    */
   String get stringValue {
     JavaStringBuilder builder = new JavaStringBuilder();
     try {
       appendStringValue(builder);
     } on IllegalArgumentException catch (exception) {
       return null;
     }
     return builder.toString();
   }
 
   /**
    * Append the value of the given string literal to the given string builder.
    * @param builder the builder to which the string's value is to be appended
    * @throws IllegalArgumentException if the string is not a constant string without any string
    * interpolation
    */
   void appendStringValue(JavaStringBuilder builder);
 }
 /**
- * Instances of the class {@code SuperConstructorInvocation} represent the invocation of a
+ * Instances of the class `SuperConstructorInvocation` represent the invocation of a
  * superclass' constructor from within a constructor's initialization list.
  * <pre>
  * superInvocation ::=
- * 'super' ('.' {@link SimpleIdentifier name})? {@link ArgumentList argumentList}</pre>
+ * 'super' ('.' [SimpleIdentifier name])? [ArgumentList argumentList]</pre>
  * @coverage dart.engine.ast
  */
 class SuperConstructorInvocation extends ConstructorInitializer {
 
   /**
    * The token for the 'super' keyword.
    */
   Token _keyword;
 
   /**
-   * The token for the period before the name of the constructor that is being invoked, or{@code null} if the unnamed constructor is being invoked.
+   * The token for the period before the name of the constructor that is being invoked, or`null` if the unnamed constructor is being invoked.
    */
   Token _period;
 
   /**
-   * The name of the constructor that is being invoked, or {@code null} if the unnamed constructor
+   * The name of the constructor that is being invoked, or `null` if the unnamed constructor
    * is being invoked.
    */
   SimpleIdentifier _constructorName;
 
   /**
    * The list of arguments to the constructor.
    */
   ArgumentList _argumentList;
 
   /**
-   * The element associated with the constructor based on static type information, or {@code null}if the AST structure has not been resolved or if the constructor could not be resolved.
+   * The element associated with the constructor based on static type information, or `null`if the AST structure has not been resolved or if the constructor could not be resolved.
    */
   ConstructorElement _staticElement;
 
   /**
-   * The element associated with the constructor based on propagated type information, or {@code null} if the AST structure has not been
+   * The element associated with the constructor based on propagated type information, or `null` if the AST structure has not been
    * resolved or if the constructor could not be resolved.
    */
   ConstructorElement _propagatedElement;
 
   /**
    * Initialize a newly created super invocation to invoke the inherited constructor with the given
    * name with the given arguments.
    * @param keyword the token for the 'super' keyword
    * @param period the token for the period before the name of the constructor that is being invoked
    * @param constructorName the name of the constructor that is being invoked
@@ skipping 18 matching lines @@
   accept(ASTVisitor visitor) => visitor.visitSuperConstructorInvocation(this);
 
   /**
    * Return the list of arguments to the constructor.
    * @return the list of arguments to the constructor
    */
   ArgumentList get argumentList => _argumentList;
   Token get beginToken => _keyword;
 
   /**
-   * Return the name of the constructor that is being invoked, or {@code null} if the unnamed
+   * Return the name of the constructor that is being invoked, or `null` if the unnamed
    * constructor is being invoked.
    * @return the name of the constructor that is being invoked
    */
   SimpleIdentifier get constructorName => _constructorName;
 
   /**
-   * Return the element associated with the constructor based on propagated type information, or{@code null} if the AST structure has not been resolved or if the constructor could not be
+   * Return the element associated with the constructor based on propagated type information, or`null` if the AST structure has not been resolved or if the constructor could not be
    * resolved.
    * @return the element associated with the super constructor
    */
   ConstructorElement get element => _propagatedElement;
   Token get endToken => _argumentList.endToken;
 
   /**
    * Return the token for the 'super' keyword.
    * @return the token for the 'super' keyword
    */
   Token get keyword => _keyword;
 
   /**
-   * Return the token for the period before the name of the constructor that is being invoked, or{@code null} if the unnamed constructor is being invoked.
+   * Return the token for the period before the name of the constructor that is being invoked, or`null` if the unnamed constructor is being invoked.
    * @return the token for the period before the name of the constructor that is being invoked
    */
   Token get period => _period;
 
   /**
-   * Return the element associated with the constructor based on static type information, or{@code null} if the AST structure has not been resolved or if the constructor could not be
+   * Return the element associated with the constructor based on static type information, or`null` if the AST structure has not been resolved or if the constructor could not be
    * resolved.
    * @return the element associated with the constructor
    */
   ConstructorElement get staticElement => _staticElement;
 
   /**
    * Set the list of arguments to the constructor to the given list.
    * @param argumentList the list of arguments to the constructor
    */
   void set argumentList(ArgumentList argumentList2) {
@@ skipping 41 matching lines @@
    */
   void set staticElement(ConstructorElement element) {
     this._staticElement = element;
   }
   void visitChildren(ASTVisitor<Object> visitor) {
     safelyVisitChild(_constructorName, visitor);
     safelyVisitChild(_argumentList, visitor);
   }
 }
 /**
- * Instances of the class {@code SuperExpression} represent a super expression.
+ * Instances of the class `SuperExpression` represent a super expression.
  * <pre>
  * superExpression ::=
  * 'super'
  * </pre>
  * @coverage dart.engine.ast
  */
 class SuperExpression extends Expression {
 
   /**
    * The token representing the keyword.
@@ skipping 27 matching lines @@
    * Set the token representing the keyword to the given token.
    * @param keyword the token representing the keyword
    */
   void set keyword(Token keyword2) {
     this._keyword = keyword2;
   }
   void visitChildren(ASTVisitor<Object> visitor) {
   }
 }
 /**
- * Instances of the class {@code SwitchCase} represent the case in a switch statement.
+ * Instances of the class `SwitchCase` represent the case in a switch statement.
  * <pre>
- * switchCase ::={@link SimpleIdentifier label}* 'case' {@link Expression expression} ':' {@link Statement statement}</pre>
+ * switchCase ::=[SimpleIdentifier label]* 'case' [Expression expression] ':' [Statement statement]</pre>
  * @coverage dart.engine.ast
  */
 class SwitchCase extends SwitchMember {
 
   /**
    * The expression controlling whether the statements will be executed.
    */
   Expression _expression;
 
   /**
@@ skipping 32 matching lines @@
   void set expression(Expression expression2) {
     this._expression = becomeParentOf(expression2);
   }
   void visitChildren(ASTVisitor<Object> visitor) {
     labels.accept(visitor);
     safelyVisitChild(_expression, visitor);
     statements.accept(visitor);
   }
 }
 /**
- * Instances of the class {@code SwitchDefault} represent the default case in a switch statement.
+ * Instances of the class `SwitchDefault` represent the default case in a switch statement.
  * <pre>
- * switchDefault ::={@link SimpleIdentifier label}* 'default' ':' {@link Statement statement}</pre>
+ * switchDefault ::=[SimpleIdentifier label]* 'default' ':' [Statement statement]</pre>
  * @coverage dart.engine.ast
  */
 class SwitchDefault extends SwitchMember {
 
   /**
    * Initialize a newly created switch default.
    * @param labels the labels associated with the switch member
    * @param keyword the token representing the 'case' or 'default' keyword
    * @param colon the colon separating the keyword or the expression from the statements
    * @param statements the statements that will be executed if this switch member is selected
    */
   SwitchDefault.full(List<Label> labels, Token keyword, Token colon, List<Statement> statements) : super.full(labels, keyword, colon, statements) {
   }
 
   /**
    * Initialize a newly created switch default.
    * @param labels the labels associated with the switch member
    * @param keyword the token representing the 'case' or 'default' keyword
    * @param colon the colon separating the keyword or the expression from the statements
    * @param statements the statements that will be executed if this switch member is selected
    */
   SwitchDefault({List<Label> labels, Token keyword, Token colon, List<Statement> statements}) : this.full(labels, keyword, colon, statements);
   accept(ASTVisitor visitor) => visitor.visitSwitchDefault(this);
   void visitChildren(ASTVisitor<Object> visitor) {
     labels.accept(visitor);
     statements.accept(visitor);
   }
 }
 /**
- * The abstract class {@code SwitchMember} defines the behavior common to objects representing
+ * The abstract class `SwitchMember` defines the behavior common to objects representing
  * elements within a switch statement.
  * <pre>
  * switchMember ::=
  * switchCase
  * | switchDefault
  * </pre>
  * @coverage dart.engine.ast
  */
 abstract class SwitchMember extends ASTNode {
 
@@ skipping 88 matching lines @@
 
   /**
    * Set the token representing the 'case' or 'default' keyword to the given token.
    * @param keyword the token representing the 'case' or 'default' keyword
    */
   void set keyword(Token keyword2) {
     this._keyword = keyword2;
   }
 }
 /**
- * Instances of the class {@code SwitchStatement} represent a switch statement.
+ * Instances of the class `SwitchStatement` represent a switch statement.
  * <pre>
  * switchStatement ::=
- * 'switch' '(' {@link Expression expression} ')' '{' {@link SwitchCase switchCase}* {@link SwitchDefault defaultCase}? '}'
+ * 'switch' '(' [Expression expression] ')' '{' [SwitchCase switchCase]* [SwitchDefault defaultCase]? '}'
  * </pre>
  * @coverage dart.engine.ast
  */
 class SwitchStatement extends Statement {
 
   /**
    * The token representing the 'switch' keyword.
    */
   Token _keyword;
 
@@ skipping 152 matching lines @@
    */
   void set rightParenthesis(Token rightParenthesis2) {
     this._rightParenthesis = rightParenthesis2;
   }
   void visitChildren(ASTVisitor<Object> visitor) {
     safelyVisitChild(_expression, visitor);
     _members.accept(visitor);
   }
 }
 /**
- * Instances of the class {@code ThisExpression} represent a this expression.
+ * Instances of the class `ThisExpression` represent a this expression.
  * <pre>
  * thisExpression ::=
  * 'this'
  * </pre>
  * @coverage dart.engine.ast
  */
 class ThisExpression extends Expression {
 
   /**
    * The token representing the keyword.
@@ skipping 27 matching lines @@
    * Set the token representing the keyword to the given token.
    * @param keyword the token representing the keyword
    */
   void set keyword(Token keyword2) {
     this._keyword = keyword2;
   }
   void visitChildren(ASTVisitor<Object> visitor) {
   }
 }
 /**
- * Instances of the class {@code ThrowExpression} represent a throw expression.
+ * Instances of the class `ThrowExpression` represent a throw expression.
  * <pre>
  * throwExpression ::=
- * 'throw' {@link Expression expression}</pre>
+ * 'throw' [Expression expression]</pre>
  * @coverage dart.engine.ast
  */
 class ThrowExpression extends Expression {
 
   /**
    * The token representing the 'throw' keyword.
    */
   Token _keyword;
 
   /**
@@ skipping 51 matching lines @@
    * @param keyword the token representing the 'throw' keyword
    */
   void set keyword(Token keyword2) {
     this._keyword = keyword2;
   }
   void visitChildren(ASTVisitor<Object> visitor) {
     safelyVisitChild(_expression, visitor);
   }
 }
 /**
- * Instances of the class {@code TopLevelVariableDeclaration} represent the declaration of one or
+ * Instances of the class `TopLevelVariableDeclaration` represent the declaration of one or
  * more top-level variables of the same type.
  * <pre>
  * topLevelVariableDeclaration ::=
  * ('final' | 'const') type? staticFinalDeclarationList ';'
  * | variableDeclaration ';'
  * </pre>
  * @coverage dart.engine.ast
  */
 class TopLevelVariableDeclaration extends CompilationUnitMember {
 
@@ skipping 58 matching lines @@
   void set variables(VariableDeclarationList variableList) {
     variableList = becomeParentOf(variableList);
   }
   void visitChildren(ASTVisitor<Object> visitor) {
     super.visitChildren(visitor);
     safelyVisitChild(_variableList, visitor);
   }
   Token get firstTokenAfterCommentAndMetadata => _variableList.beginToken;
 }
 /**
- * Instances of the class {@code TryStatement} represent a try statement.
+ * Instances of the class `TryStatement` represent a try statement.
  * <pre>
  * tryStatement ::=
- * 'try' {@link Block block} ({@link CatchClause catchClause}+ finallyClause? | finallyClause)
+ * 'try' [Block block] ([CatchClause catchClause]+ finallyClause? | finallyClause)
  * finallyClause ::=
- * 'finally' {@link Block block}</pre>
+ * 'finally' [Block block]</pre>
  * @coverage dart.engine.ast
  */
 class TryStatement extends Statement {
 
   /**
    * The token representing the 'try' keyword.
    */
   Token _tryKeyword;
 
   /**
    * The body of the statement.
    */
   Block _body;
 
   /**
    * The catch clauses contained in the try statement.
    */
   NodeList<CatchClause> _catchClauses;
 
   /**
-   * The token representing the 'finally' keyword, or {@code null} if the statement does not contain
+   * The token representing the 'finally' keyword, or `null` if the statement does not contain
    * a finally clause.
    */
   Token _finallyKeyword;
 
   /**
-   * The finally clause contained in the try statement, or {@code null} if the statement does not
+   * The finally clause contained in the try statement, or `null` if the statement does not
    * contain a finally clause.
    */
   Block _finallyClause;
 
   /**
    * Initialize a newly created try statement.
    * @param tryKeyword the token representing the 'try' keyword
    * @param body the body of the statement
    * @param catchClauses the catch clauses contained in the try statement
    * @param finallyKeyword the token representing the 'finally' keyword
@@ skipping 36 matching lines @@
       return _finallyClause.endToken;
     } else if (_finallyKeyword != null) {
       return _finallyKeyword;
     } else if (!_catchClauses.isEmpty) {
       return _catchClauses.endToken;
     }
     return _body.endToken;
   }
 
   /**
-   * Return the finally clause contained in the try statement, or {@code null} if the statement does
+   * Return the finally clause contained in the try statement, or `null` if the statement does
    * not contain a finally clause.
    * @return the finally clause contained in the try statement
    */
   Block get finallyClause => _finallyClause;
 
   /**
-   * Return the token representing the 'finally' keyword, or {@code null} if the statement does not
+   * Return the token representing the 'finally' keyword, or `null` if the statement does not
    * contain a finally clause.
    * @return the token representing the 'finally' keyword
    */
   Token get finallyKeyword => _finallyKeyword;
 
   /**
    * Return the token representing the 'try' keyword.
    * @return the token representing the 'try' keyword
    */
   Token get tryKeyword => _tryKeyword;
@@ skipping 29 matching lines @@
   void set tryKeyword(Token tryKeyword2) {
     this._tryKeyword = tryKeyword2;
   }
   void visitChildren(ASTVisitor<Object> visitor) {
     safelyVisitChild(_body, visitor);
     _catchClauses.accept(visitor);
     safelyVisitChild(_finallyClause, visitor);
   }
 }
 /**
- * The abstract class {@code TypeAlias} defines the behavior common to declarations of type aliases.
+ * The abstract class `TypeAlias` defines the behavior common to declarations of type aliases.
  * <pre>
  * typeAlias ::=
  * 'typedef' typeAliasBody
  * typeAliasBody ::=
  * classTypeAlias
  * | functionTypeAlias
  * </pre>
  * @coverage dart.engine.ast
  */
 abstract class TypeAlias extends CompilationUnitMember {
@@ skipping 53 matching lines @@
   /**
    * Set the semicolon terminating the declaration to the given token.
    * @param semicolon the semicolon terminating the declaration
    */
   void set semicolon(Token semicolon2) {
     this._semicolon = semicolon2;
   }
   Token get firstTokenAfterCommentAndMetadata => _keyword;
 }
 /**
- * Instances of the class {@code TypeArgumentList} represent a list of type arguments.
+ * Instances of the class `TypeArgumentList` represent a list of type arguments.
  * <pre>
  * typeArguments ::=
  * '<' typeName (',' typeName)* '>'
  * </pre>
  * @coverage dart.engine.ast
  */
 class TypeArgumentList extends ASTNode {
 
   /**
    * The left bracket.
@@ skipping 65 matching lines @@
    * @param rightBracket the right bracket
    */
   void set rightBracket(Token rightBracket2) {
     this._rightBracket = rightBracket2;
   }
   void visitChildren(ASTVisitor<Object> visitor) {
     _arguments.accept(visitor);
   }
 }
 /**
- * Instances of the class {@code TypeName} represent the name of a type, which can optionally
+ * Instances of the class `TypeName` represent the name of a type, which can optionally
  * include type arguments.
  * <pre>
- * typeName ::={@link Identifier identifier} typeArguments?
+ * typeName ::=[Identifier identifier] typeArguments?
  * </pre>
  * @coverage dart.engine.ast
  */
 class TypeName extends ASTNode {
 
   /**
    * The name of the type.
    */
   Identifier _name;
 
   /**
-   * The type arguments associated with the type, or {@code null} if there are no type arguments.
+   * The type arguments associated with the type, or `null` if there are no type arguments.
    */
   TypeArgumentList _typeArguments;
 
   /**
-   * The type being named, or {@code null} if the AST structure has not been resolved.
+   * The type being named, or `null` if the AST structure has not been resolved.
    */
   Type2 _type;
 
   /**
    * Initialize a newly created type name.
    * @param name the name of the type
-   * @param typeArguments the type arguments associated with the type, or {@code null} if there are
+   * @param typeArguments the type arguments associated with the type, or `null` if there are
    * no type arguments
    */
   TypeName.full(Identifier name, TypeArgumentList typeArguments) {
     this._name = becomeParentOf(name);
     this._typeArguments = becomeParentOf(typeArguments);
   }
 
   /**
    * Initialize a newly created type name.
    * @param name the name of the type
-   * @param typeArguments the type arguments associated with the type, or {@code null} if there are
+   * @param typeArguments the type arguments associated with the type, or `null` if there are
    * no type arguments
    */
   TypeName({Identifier name, TypeArgumentList typeArguments}) : this.full(name, typeArguments);
   accept(ASTVisitor visitor) => visitor.visitTypeName(this);
   Token get beginToken => _name.beginToken;
   Token get endToken {
     if (_typeArguments != null) {
       return _typeArguments.endToken;
     }
     return _name.endToken;
   }
 
   /**
    * Return the name of the type.
    * @return the name of the type
    */
   Identifier get name => _name;
 
   /**
-   * Return the type being named, or {@code null} if the AST structure has not been resolved.
+   * Return the type being named, or `null` if the AST structure has not been resolved.
    * @return the type being named
    */
   Type2 get type => _type;
 
   /**
-   * Return the type arguments associated with the type, or {@code null} if there are no type
+   * Return the type arguments associated with the type, or `null` if there are no type
    * arguments.
    * @return the type arguments associated with the type
    */
   TypeArgumentList get typeArguments => _typeArguments;
   bool isSynthetic() => _name.isSynthetic() && _typeArguments == null;
 
   /**
    * Set the name of the type to the given identifier.
    * @param identifier the name of the type
    */
@@ skipping 15 matching lines @@
    */
   void set typeArguments(TypeArgumentList typeArguments2) {
     this._typeArguments = becomeParentOf(typeArguments2);
   }
   void visitChildren(ASTVisitor<Object> visitor) {
     safelyVisitChild(_name, visitor);
     safelyVisitChild(_typeArguments, visitor);
   }
 }
 /**
- * Instances of the class {@code TypeParameter} represent a type parameter.
+ * Instances of the class `TypeParameter` represent a type parameter.
  * <pre>
- * typeParameter ::={@link SimpleIdentifier name} ('extends' {@link TypeName bound})?
+ * typeParameter ::=[SimpleIdentifier name] ('extends' [TypeName bound])?
  * </pre>
  * @coverage dart.engine.ast
  */
 class TypeParameter extends Declaration {
 
   /**
    * The name of the type parameter.
    */
   SimpleIdentifier _name;
 
   /**
-   * The token representing the 'extends' keyword, or {@code null} if there was no explicit upper
+   * The token representing the 'extends' keyword, or `null` if there was no explicit upper
    * bound.
    */
   Token _keyword;
 
   /**
-   * The name of the upper bound for legal arguments, or {@code null} if there was no explicit upper
+   * The name of the upper bound for legal arguments, or `null` if there was no explicit upper
    * bound.
    */
   TypeName _bound;
 
   /**
    * Initialize a newly created type parameter.
    * @param comment the documentation comment associated with the type parameter
    * @param metadata the annotations associated with the type parameter
    * @param name the name of the type parameter
    * @param keyword the token representing the 'extends' keyword
@@ skipping 10 matching lines @@
    * @param comment the documentation comment associated with the type parameter
    * @param metadata the annotations associated with the type parameter
    * @param name the name of the type parameter
    * @param keyword the token representing the 'extends' keyword
    * @param bound the name of the upper bound for legal arguments
    */
   TypeParameter({Comment comment, List<Annotation> metadata, SimpleIdentifier name, Token keyword, TypeName bound}) : this.full(comment, metadata, name, keyword, bound);
   accept(ASTVisitor visitor) => visitor.visitTypeParameter(this);
 
   /**
-   * Return the name of the upper bound for legal arguments, or {@code null} if there was no
+   * Return the name of the upper bound for legal arguments, or `null` if there was no
    * explicit upper bound.
    * @return the name of the upper bound for legal arguments
    */
   TypeName get bound => _bound;
   TypeVariableElement get element => _name != null ? (_name.element as TypeVariableElement) : null;
   Token get endToken {
     if (_bound == null) {
       return _name.endToken;
     }
     return _bound.endToken;
@@ skipping 35 matching lines @@
     _name = becomeParentOf(identifier);
   }
   void visitChildren(ASTVisitor<Object> visitor) {
     super.visitChildren(visitor);
     safelyVisitChild(_name, visitor);
     safelyVisitChild(_bound, visitor);
   }
   Token get firstTokenAfterCommentAndMetadata => _name.beginToken;
 }
 /**
- * Instances of the class {@code TypeParameterList} represent type parameters within a declaration.
+ * Instances of the class `TypeParameterList` represent type parameters within a declaration.
  * <pre>
  * typeParameterList ::=
- * '<' {@link TypeParameter typeParameter} (',' {@link TypeParameter typeParameter})* '>'
+ * '<' [TypeParameter typeParameter] (',' [TypeParameter typeParameter])* '>'
  * </pre>
  * @coverage dart.engine.ast
  */
 class TypeParameterList extends ASTNode {
 
   /**
    * The left angle bracket.
    */
   Token _leftBracket;
 
@@ skipping 46 matching lines @@
   /**
    * Return the type parameters for the type.
    * @return the type parameters for the type
    */
   NodeList<TypeParameter> get typeParameters => _typeParameters;
   void visitChildren(ASTVisitor<Object> visitor) {
     _typeParameters.accept(visitor);
   }
 }
 /**
- * The abstract class {@code TypedLiteral} defines the behavior common to literals that have a type
+ * The abstract class `TypedLiteral` defines the behavior common to literals that have a type
  * associated with them.
  * <pre>
- * listLiteral ::={@link ListLiteral listLiteral}| {@link MapLiteral mapLiteral}</pre>
+ * listLiteral ::=[ListLiteral listLiteral]| [MapLiteral mapLiteral]</pre>
  * @coverage dart.engine.ast
  */
 abstract class TypedLiteral extends Literal {
 
   /**
-   * The const modifier associated with this literal, or {@code null} if the literal is not a
+   * The const modifier associated with this literal, or `null` if the literal is not a
    * constant.
    */
   Token _modifier;
 
   /**
-   * The type argument associated with this literal, or {@code null} if no type arguments were
+   * The type argument associated with this literal, or `null` if no type arguments were
    * declared.
    */
   TypeArgumentList _typeArguments;
 
   /**
    * Initialize a newly created typed literal.
    * @param modifier the const modifier associated with this literal
-   * @param typeArguments the type argument associated with this literal, or {@code null} if no type
+   * @param typeArguments the type argument associated with this literal, or `null` if no type
    * arguments were declared
    */
   TypedLiteral.full(Token modifier, TypeArgumentList typeArguments) {
     this._modifier = modifier;
     this._typeArguments = becomeParentOf(typeArguments);
   }
 
   /**
    * Initialize a newly created typed literal.
    * @param modifier the const modifier associated with this literal
-   * @param typeArguments the type argument associated with this literal, or {@code null} if no type
+   * @param typeArguments the type argument associated with this literal, or `null` if no type
    * arguments were declared
    */
   TypedLiteral({Token modifier, TypeArgumentList typeArguments}) : this.full(modifier, typeArguments);
 
   /**
    * Return the const modifier associated with this literal.
    * @return the const modifier associated with this literal
    */
   Token get modifier => _modifier;
 
   /**
-   * Return the type argument associated with this literal, or {@code null} if no type arguments
+   * Return the type argument associated with this literal, or `null` if no type arguments
    * were declared.
    * @return the type argument associated with this literal
    */
   TypeArgumentList get typeArguments => _typeArguments;
 
   /**
    * Set the modifiers associated with this literal to the given modifiers.
    * @param modifiers the modifiers associated with this literal
    */
   void set modifier(Token modifier2) {
     this._modifier = modifier2;
   }
 
   /**
    * Set the type argument associated with this literal to the given arguments.
    * @param typeArguments the type argument associated with this literal
    */
   void set typeArguments(TypeArgumentList typeArguments2) {
     this._typeArguments = typeArguments2;
   }
   void visitChildren(ASTVisitor<Object> visitor) {
     safelyVisitChild(_typeArguments, visitor);
   }
 }
 /**
- * The abstract class {@code UriBasedDirective} defines the behavior common to nodes that represent
+ * The abstract class `UriBasedDirective` defines the behavior common to nodes that represent
  * a directive that references a URI.
  * <pre>
- * uriBasedDirective ::={@link ExportDirective exportDirective}| {@link ImportDirective importDirective}| {@link PartDirective partDirective}</pre>
+ * uriBasedDirective ::=[ExportDirective exportDirective]| [ImportDirective importDirective]| [PartDirective partDirective]</pre>
  * @coverage dart.engine.ast
  */
 abstract class UriBasedDirective extends Directive {
 
   /**
    * The URI referenced by this directive.
    */
   StringLiteral _uri;
 
   /**
@@ skipping 14 matching lines @@
    */
   UriBasedDirective({Comment comment, List<Annotation> metadata, StringLiteral uri}) : this.full(comment, metadata, uri);
 
   /**
    * Return the URI referenced by this directive.
    * @return the URI referenced by this directive
    */
   StringLiteral get uri => _uri;
 
   /**
-   * Return the element associated with the URI of this directive, or {@code null} if the AST
+   * Return the element associated with the URI of this directive, or `null` if the AST
    * structure has not been resolved or if this URI could not be resolved. Examples of the latter
    * case include a directive that contains an invalid URL or a URL that does not exist.
    * @return the element associated with this directive
    */
   Element get uriElement;
 
   /**
    * Set the URI referenced by this directive to the given URI.
    * @param uri the URI referenced by this directive
    */
   void set uri(StringLiteral uri2) {
     this._uri = becomeParentOf(uri2);
   }
   void visitChildren(ASTVisitor<Object> visitor) {
     super.visitChildren(visitor);
     safelyVisitChild(_uri, visitor);
   }
 }
 /**
- * Instances of the class {@code VariableDeclaration} represent an identifier that has an initial
- * value associated with it. Instances of this class are always children of the class{@link VariableDeclarationList}.
+ * Instances of the class `VariableDeclaration` represent an identifier that has an initial
+ * value associated with it. Instances of this class are always children of the class[VariableDeclarationList].
  * <pre>
- * variableDeclaration ::={@link SimpleIdentifier identifier} ('=' {@link Expression initialValue})?
+ * variableDeclaration ::=[SimpleIdentifier identifier] ('=' [Expression initialValue])?
  * </pre>
  * @coverage dart.engine.ast
  */
 class VariableDeclaration extends Declaration {
 
   /**
    * The name of the variable being declared.
    */
   SimpleIdentifier _name;
 
   /**
-   * The equal sign separating the variable name from the initial value, or {@code null} if the
+   * The equal sign separating the variable name from the initial value, or `null` if the
    * initial value was not specified.
    */
   Token _equals;
 
   /**
-   * The expression used to compute the initial value for the variable, or {@code null} if the
+   * The expression used to compute the initial value for the variable, or `null` if the
    * initial value was not specified.
    */
   Expression _initializer;
 
   /**
    * Initialize a newly created variable declaration.
    * @param comment the documentation comment associated with this declaration
    * @param metadata the annotations associated with this member
    * @param name the name of the variable being declared
    * @param equals the equal sign separating the variable name from the initial value
@@ skipping 34 matching lines @@
   }
   VariableElement get element => _name != null ? (_name.element as VariableElement) : null;
   Token get endToken {
     if (_initializer != null) {
       return _initializer.endToken;
     }
     return _name.endToken;
   }
 
   /**
-   * Return the equal sign separating the variable name from the initial value, or {@code null} if
+   * Return the equal sign separating the variable name from the initial value, or `null` if
    * the initial value was not specified.
    * @return the equal sign separating the variable name from the initial value
    */
   Token get equals => _equals;
 
   /**
-   * Return the expression used to compute the initial value for the variable, or {@code null} if
+   * Return the expression used to compute the initial value for the variable, or `null` if
    * the initial value was not specified.
    * @return the expression used to compute the initial value for the variable
    */
   Expression get initializer => _initializer;
 
   /**
    * Return the name of the variable being declared.
    * @return the name of the variable being declared
    */
   SimpleIdentifier get name => _name;
 
   /**
-   * Return {@code true} if this variable was declared with the 'const' modifier.
-   * @return {@code true} if this variable was declared with the 'const' modifier
+   * Return `true` if this variable was declared with the 'const' modifier.
+   * @return `true` if this variable was declared with the 'const' modifier
    */
   bool isConst() {
     ASTNode parent = this.parent;
     return parent is VariableDeclarationList && ((parent as VariableDeclarationList)).isConst();
   }
 
   /**
-   * Return {@code true} if this variable was declared with the 'final' modifier. Variables that are
-   * declared with the 'const' modifier will return {@code false} even though they are implicitly
+   * Return `true` if this variable was declared with the 'final' modifier. Variables that are
+   * declared with the 'const' modifier will return `false` even though they are implicitly
    * final.
-   * @return {@code true} if this variable was declared with the 'final' modifier
+   * @return `true` if this variable was declared with the 'final' modifier
    */
   bool isFinal() {
     ASTNode parent = this.parent;
     return parent is VariableDeclarationList && ((parent as VariableDeclarationList)).isFinal();
   }
 
   /**
    * Set the equal sign separating the variable name from the initial value to the given token.
    * @param equals the equal sign separating the variable name from the initial value
    */
@@ skipping 17 matching lines @@
     this._name = becomeParentOf(name2);
   }
   void visitChildren(ASTVisitor<Object> visitor) {
     super.visitChildren(visitor);
     safelyVisitChild(_name, visitor);
     safelyVisitChild(_initializer, visitor);
   }
   Token get firstTokenAfterCommentAndMetadata => _name.beginToken;
 }
 /**
- * Instances of the class {@code VariableDeclarationList} represent the declaration of one or more
+ * Instances of the class `VariableDeclarationList` represent the declaration of one or more
  * variables of the same type.
  * <pre>
  * variableDeclarationList ::=
- * finalConstVarOrType {@link VariableDeclaration variableDeclaration} (',' {@link VariableDeclaration variableDeclaration})
+ * finalConstVarOrType [VariableDeclaration variableDeclaration] (',' [VariableDeclaration variableDeclaration])
  * finalConstVarOrType ::=
- * | 'final' {@link TypeName type}?
- * | 'const' {@link TypeName type}?
+ * | 'final' [TypeName type]?
+ * | 'const' [TypeName type]?
  * | 'var'
- * | {@link TypeName type}</pre>
+ * | [TypeName type]</pre>
  * @coverage dart.engine.ast
  */
 class VariableDeclarationList extends AnnotatedNode {
 
   /**
-   * The token representing the 'final', 'const' or 'var' keyword, or {@code null} if no keyword was
+   * The token representing the 'final', 'const' or 'var' keyword, or `null` if no keyword was
    * included.
    */
   Token _keyword;
 
   /**
-   * The type of the variables being declared, or {@code null} if no type was provided.
+   * The type of the variables being declared, or `null` if no type was provided.
    */
   TypeName _type;
 
   /**
    * A list containing the individual variables being declared.
    */
   NodeList<VariableDeclaration> _variables;
 
   /**
    * Initialize a newly created variable declaration list.
@@ skipping 16 matching lines @@
    * @param metadata the annotations associated with this declaration list
    * @param keyword the token representing the 'final', 'const' or 'var' keyword
    * @param type the type of the variables being declared
    * @param variables a list containing the individual variables being declared
    */
   VariableDeclarationList({Comment comment, List<Annotation> metadata, Token keyword, TypeName type, List<VariableDeclaration> variables}) : this.full(comment, metadata, keyword, type, variables);
   accept(ASTVisitor visitor) => visitor.visitVariableDeclarationList(this);
   Token get endToken => _variables.endToken;
 
   /**
-   * Return the token representing the 'final', 'const' or 'var' keyword, or {@code null} if no
+   * Return the token representing the 'final', 'const' or 'var' keyword, or `null` if no
    * keyword was included.
    * @return the token representing the 'final', 'const' or 'var' keyword
    */
   Token get keyword => _keyword;
 
   /**
-   * Return the type of the variables being declared, or {@code null} if no type was provided.
+   * Return the type of the variables being declared, or `null` if no type was provided.
    * @return the type of the variables being declared
    */
   TypeName get type => _type;
 
   /**
    * Return a list containing the individual variables being declared.
    * @return a list containing the individual variables being declared
    */
   NodeList<VariableDeclaration> get variables => _variables;
 
   /**
-   * Return {@code true} if the variables in this list were declared with the 'const' modifier.
-   * @return {@code true} if the variables in this list were declared with the 'const' modifier
+   * Return `true` if the variables in this list were declared with the 'const' modifier.
+   * @return `true` if the variables in this list were declared with the 'const' modifier
    */
   bool isConst() => _keyword is KeywordToken && identical(((_keyword as KeywordToken)).keyword, Keyword.CONST);
 
   /**
-   * Return {@code true} if the variables in this list were declared with the 'final' modifier.
-   * Variables that are declared with the 'const' modifier will return {@code false} even though
+   * Return `true` if the variables in this list were declared with the 'final' modifier.
+   * Variables that are declared with the 'const' modifier will return `false` even though
    * they are implicitly final.
-   * @return {@code true} if the variables in this list were declared with the 'final' modifier
+   * @return `true` if the variables in this list were declared with the 'final' modifier
    */
   bool isFinal() => _keyword is KeywordToken && identical(((_keyword as KeywordToken)).keyword, Keyword.FINAL);
 
   /**
    * Set the token representing the 'final', 'const' or 'var' keyword to the given token.
    * @param keyword the token representing the 'final', 'const' or 'var' keyword
    */
   void set keyword(Token keyword2) {
     this._keyword = keyword2;
   }
@@ skipping 12 matching lines @@
   Token get firstTokenAfterCommentAndMetadata {
     if (_keyword != null) {
       return _keyword;
     } else if (_type != null) {
       return _type.beginToken;
     }
     return _variables.beginToken;
   }
 }
 /**
- * Instances of the class {@code VariableDeclarationStatement} represent a list of variables that
+ * Instances of the class `VariableDeclarationStatement` represent a list of variables that
  * are being declared in a context where a statement is required.
  * <pre>
- * variableDeclarationStatement ::={@link VariableDeclarationList variableList} ';'
+ * variableDeclarationStatement ::=[VariableDeclarationList variableList] ';'
  * </pre>
  * @coverage dart.engine.ast
  */
 class VariableDeclarationStatement extends Statement {
 
   /**
    * The variables being declared.
    */
   VariableDeclarationList _variableList;
 
@@ skipping 47 matching lines @@
    * @param variableList the variables being declared
    */
   void set variables(VariableDeclarationList variableList2) {
     this._variableList = becomeParentOf(variableList2);
   }
   void visitChildren(ASTVisitor<Object> visitor) {
     safelyVisitChild(_variableList, visitor);
   }
 }
 /**
- * Instances of the class {@code WhileStatement} represent a while statement.
+ * Instances of the class `WhileStatement` represent a while statement.
  * <pre>
  * whileStatement ::=
- * 'while' '(' {@link Expression condition} ')' {@link Statement body}</pre>
+ * 'while' '(' [Expression condition] ')' [Statement body]</pre>
  * @coverage dart.engine.ast
  */
 class WhileStatement extends Statement {
 
   /**
    * The token representing the 'while' keyword.
    */
   Token _keyword;
 
   /**
@@ skipping 114 matching lines @@
    */
   void set rightParenthesis(Token rightParenthesis2) {
     this._rightParenthesis = rightParenthesis2;
   }
   void visitChildren(ASTVisitor<Object> visitor) {
     safelyVisitChild(_condition, visitor);
     safelyVisitChild(_body, visitor);
   }
 }
 /**
- * Instances of the class {@code WithClause} represent the with clause in a class declaration.
+ * Instances of the class `WithClause` represent the with clause in a class declaration.
  * <pre>
  * withClause ::=
- * 'with' {@link TypeName mixin} (',' {@link TypeName mixin})
+ * 'with' [TypeName mixin] (',' [TypeName mixin])
  * </pre>
  * @coverage dart.engine.ast
  */
 class WithClause extends ASTNode {
 
   /**
    * The token representing the 'with' keyword.
    */
   Token _withKeyword;
 
@@ skipping 40 matching lines @@
    * @param withKeyword the token representing the 'with' keyword
    */
   void set mixinKeyword(Token withKeyword2) {
     this._withKeyword = withKeyword2;
   }
   void visitChildren(ASTVisitor<Object> visitor) {
     _mixinTypes.accept(visitor);
   }
 }
 /**
- * Instances of the class {@code BreadthFirstVisitor} implement an AST visitor that will recursively
- * visit all of the nodes in an AST structure, similar to {@link GeneralizingASTVisitor}. This
- * visitor uses a breadth-first ordering rather than the depth-first ordering of{@link GeneralizingASTVisitor}.
+ * Instances of the class `BreadthFirstVisitor` implement an AST visitor that will recursively
+ * visit all of the nodes in an AST structure, similar to [GeneralizingASTVisitor]. This
+ * visitor uses a breadth-first ordering rather than the depth-first ordering of[GeneralizingASTVisitor].
  * @coverage dart.engine.ast
  */
 class BreadthFirstVisitor<R> extends GeneralizingASTVisitor<R> {
   Queue<ASTNode> _queue = new Queue<ASTNode>();
   GeneralizingASTVisitor<Object> _childVisitor;
 
   /**
-   * Visit all nodes in the tree starting at the given {@code root} node, in depth-first order.
+   * Visit all nodes in the tree starting at the given `root` node, in depth-first order.
    * @param root the root of the ASTNode tree
    */
   void visitAllNodes(ASTNode root) {
     _queue.add(root);
     while (!_queue.isEmpty) {
       ASTNode next = _queue.removeFirst();
       next.accept(this);
     }
   }
   R visitNode(ASTNode node) {
     node.visitChildren(_childVisitor);
     return null;
   }
   BreadthFirstVisitor() {
     this._childVisitor = new GeneralizingASTVisitor_1(this);
   }
 }
 class GeneralizingASTVisitor_1 extends GeneralizingASTVisitor<Object> {
   final BreadthFirstVisitor BreadthFirstVisitor_this;
   GeneralizingASTVisitor_1(this.BreadthFirstVisitor_this) : super();
   Object visitNode(ASTNode node) {
     BreadthFirstVisitor_this._queue.add(node);
     return null;
   }
 }
 /**
- * Instances of the class {@code ConstantEvaluator} evaluate constant expressions to produce their
+ * Instances of the class `ConstantEvaluator` evaluate constant expressions to produce their
  * compile-time value. According to the Dart Language Specification: <blockquote> A constant
  * expression is one of the following:
- * <ul>
- * <li>A literal number.</li>
- * <li>A literal boolean.</li>
- * <li>A literal string where any interpolated expression is a compile-time constant that evaluates
- * to a numeric, string or boolean value or to {@code null}.</li>
- * <li>{@code null}.</li>
- * <li>A reference to a static constant variable.</li>
- * <li>An identifier expression that denotes a constant variable, a class or a type variable.</li>
- * <li>A constant constructor invocation.</li>
- * <li>A constant list literal.</li>
- * <li>A constant map literal.</li>
- * <li>A simple or qualified identifier denoting a top-level function or a static method.</li>
- * <li>A parenthesized expression {@code (e)} where {@code e} is a constant expression.</li>
- * <li>An expression of one of the forms {@code identical(e1, e2)}, {@code e1 == e2},{@code e1 != e2} where {@code e1} and {@code e2} are constant expressions that evaluate to a
- * numeric, string or boolean value or to {@code null}.</li>
- * <li>An expression of one of the forms {@code !e}, {@code e1 && e2} or {@code e1 || e2}, where{@code e}, {@code e1} and {@code e2} are constant expressions that evaluate to a boolean value or
- * to {@code null}.</li>
- * <li>An expression of one of the forms {@code ~e}, {@code e1 ^ e2}, {@code e1 & e2},{@code e1 | e2}, {@code e1 >> e2} or {@code e1 << e2}, where {@code e}, {@code e1} and {@code e2}are constant expressions that evaluate to an integer value or to {@code null}.</li>
- * <li>An expression of one of the forms {@code -e}, {@code e1 + e2}, {@code e1 - e2},{@code e1 * e2}, {@code e1 / e2}, {@code e1 ~/ e2}, {@code e1 > e2}, {@code e1 < e2},{@code e1 >= e2}, {@code e1 <= e2} or {@code e1 % e2}, where {@code e}, {@code e1} and {@code e2}are constant expressions that evaluate to a numeric value or to {@code null}.</li>
- * </ul>
- * </blockquote> The values returned by instances of this class are therefore {@code null} and
- * instances of the classes {@code Boolean}, {@code BigInteger}, {@code Double}, {@code String}, and{@code DartObject}.
- * <p>
+ *
+ * * A literal number.
+ * * A literal boolean.
+ * * A literal string where any interpolated expression is a compile-time constant that evaluates
+ * to a numeric, string or boolean value or to `null`.
+ * * `null`.
+ * * A reference to a static constant variable.
+ * * An identifier expression that denotes a constant variable, a class or a type variable.
+ * * A constant constructor invocation.
+ * * A constant list literal.
+ * * A constant map literal.
+ * * A simple or qualified identifier denoting a top-level function or a static method.
+ * * A parenthesized expression `(e)` where `e` is a constant expression.
+ * * An expression of one of the forms `identical(e1, e2)`, `e1 == e2`,`e1 != e2` where `e1` and `e2` are constant expressions that evaluate to a
+ * numeric, string or boolean value or to `null`.
+ * * An expression of one of the forms `!e`, `e1 && e2` or `e1 || e2`, where`e`, `e1` and `e2` are constant expressions that evaluate to a boolean value or
+ * to `null`.
+ * * An expression of one of the forms `~e`, `e1 ^ e2`, `e1 & e2`,`e1 | e2`, `e1 >> e2` or `e1 << e2`, where `e`, `e1` and `e2`are constant expressions that evaluate to an integer value or to `null`.
+ * * An expression of one of the forms `-e`, `e1 + e2`, `e1 - e2`,`e1 * e2`, `e1 / e2`, `e1 ~/ e2`, `e1 > e2`, `e1 < e2`,`e1 >= e2`, `e1 <= e2` or `e1 % e2`, where `e`, `e1` and `e2`are constant expressions that evaluate to a numeric value or to `null`.
+ *
+ * </blockquote> The values returned by instances of this class are therefore `null` and
+ * instances of the classes `Boolean`, `BigInteger`, `Double`, `String`, and`DartObject`.
+ *
  * In addition, this class defines several values that can be returned to indicate various
  * conditions encountered during evaluation. These are documented with the static field that define
  * those values.
  * @coverage dart.engine.ast
  */
 class ConstantEvaluator extends GeneralizingASTVisitor<Object> {
 
   /**
    * The value returned for expressions (or non-expression nodes) that are not compile-time constant
    * expressions.
@@ skipping 232 matching lines @@
   Object getConstantValue(Element element) {
     if (element is FieldElement) {
       FieldElement field = element as FieldElement;
       if (field.isStatic() && field.isConst()) {
       }
     }
     return NOT_A_CONSTANT;
   }
 }
 /**
- * Instances of the class {@code ElementLocator} locate the {@link Element Dart model element}associated with a given {@link ASTNode AST node}.
+ * Instances of the class `ElementLocator` locate the [Element Dart model element]associated with a given [ASTNode AST node].
  * @coverage dart.engine.ast
  */
 class ElementLocator {
 
   /**
-   * Locate the {@link Element Dart model element} associated with the given {@link ASTNode AST
-   * node}.
-   * @param node the node (not {@code null})
-   * @return the associated element, or {@code null} if none is found
+   * Locate the [Element Dart model element] associated with the given [ASTNode AST
+   * node].
+   * @param node the node (not `null`)
+   * @return the associated element, or `null` if none is found
    */
   static Element locate(ASTNode node) {
     ElementLocator_ElementMapper mapper = new ElementLocator_ElementMapper();
     return node.accept(mapper);
   }
 }
 /**
  * Visitor that maps nodes to elements.
  */
 class ElementLocator_ElementMapper extends GeneralizingASTVisitor<Element> {
@@ skipping 41 matching lines @@
   Element visitStringLiteral(StringLiteral node) {
     ASTNode parent = node.parent;
     if (parent is UriBasedDirective) {
       return ((parent as UriBasedDirective)).uriElement;
     }
     return null;
   }
   Element visitVariableDeclaration(VariableDeclaration node) => node.element;
 }
 /**
- * Instances of the class {@code GeneralizingASTVisitor} implement an AST visitor that will
- * recursively visit all of the nodes in an AST structure (like instances of the class{@link RecursiveASTVisitor}). In addition, when a node of a specific type is visited not only
+ * Instances of the class `GeneralizingASTVisitor` implement an AST visitor that will
+ * recursively visit all of the nodes in an AST structure (like instances of the class[RecursiveASTVisitor]). In addition, when a node of a specific type is visited not only
  * will the visit method for that specific type of node be invoked, but additional methods for the
  * superclasses of that node will also be invoked. For example, using an instance of this class to
- * visit a {@link Block} will cause the method {@link #visitBlock(Block)} to be invoked but will
- * also cause the methods {@link #visitStatement(Statement)} and {@link #visitNode(ASTNode)} to be
+ * visit a [Block] will cause the method [visitBlock] to be invoked but will
+ * also cause the methods [visitStatement] and [visitNode] to be
  * subsequently invoked. This allows visitors to be written that visit all statements without
- * needing to override the visit method for each of the specific subclasses of {@link Statement}.
- * <p>
+ * needing to override the visit method for each of the specific subclasses of [Statement].
+ *
  * Subclasses that override a visit method must either invoke the overridden visit method or
  * explicitly invoke the more general visit method. Failure to do so will cause the visit methods
  * for superclasses of the node to not be invoked and will cause the children of the visited node to
  * not be visited.
  * @coverage dart.engine.ast
  */
 class GeneralizingASTVisitor<R> implements ASTVisitor<R> {
   R visitAdjacentStrings(AdjacentStrings node) => visitStringLiteral(node);
   R visitAnnotatedNode(AnnotatedNode node) => visitNode(node);
   R visitAnnotation(Annotation node) => visitNode(node);
@@ skipping 115 matching lines @@
   R visitTypeParameter(TypeParameter node) => visitNode(node);
   R visitTypeParameterList(TypeParameterList node) => visitNode(node);
   R visitUriBasedDirective(UriBasedDirective node) => visitDirective(node);
   R visitVariableDeclaration(VariableDeclaration node) => visitDeclaration(node);
   R visitVariableDeclarationList(VariableDeclarationList node) => visitNode(node);
   R visitVariableDeclarationStatement(VariableDeclarationStatement node) => visitStatement(node);
   R visitWhileStatement(WhileStatement node) => visitStatement(node);
   R visitWithClause(WithClause node) => visitNode(node);
 }
 /**
- * Instances of the class {@code NodeLocator} locate the {@link ASTNode AST node} associated with a
+ * Instances of the class `NodeLocator` locate the [ASTNode AST node] associated with a
  * source range, given the AST structure built from the source. More specifically, they will return
- * the {@link ASTNode AST node} with the shortest length whose source range completely encompasses
+ * the [ASTNode AST node] with the shortest length whose source range completely encompasses
  * the specified range.
  * @coverage dart.engine.ast
  */
 class NodeLocator extends GeneralizingASTVisitor<Object> {
 
   /**
    * The start offset of the range used to identify the node.
    */
   int _startOffset = 0;
 
   /**
    * The end offset of the range used to identify the node.
    */
   int _endOffset = 0;
 
   /**
-   * The element that was found that corresponds to the given source range, or {@code null} if there
+   * The element that was found that corresponds to the given source range, or `null` if there
    * is no such element.
    */
   ASTNode _foundNode;
 
   /**
-   * Initialize a newly created locator to locate one or more {@link ASTNode AST nodes} by locating
+   * Initialize a newly created locator to locate one or more [ASTNode AST nodes] by locating
    * the node within an AST structure that corresponds to the given offset in the source.
    * @param offset the offset used to identify the node
    */
   NodeLocator.con1(int offset) {
     _jtd_constructor_120_impl(offset);
   }
   _jtd_constructor_120_impl(int offset) {
     _jtd_constructor_121_impl(offset, offset);
   }
 
   /**
-   * Initialize a newly created locator to locate one or more {@link ASTNode AST nodes} by locating
+   * Initialize a newly created locator to locate one or more [ASTNode AST nodes] by locating
    * the node within an AST structure that corresponds to the given range of characters in the
    * source.
    * @param start the start offset of the range used to identify the node
    * @param end the end offset of the range used to identify the node
    */
   NodeLocator.con2(int start, int end) {
     _jtd_constructor_121_impl(start, end);
   }
   _jtd_constructor_121_impl(int start, int end) {
     this._startOffset = start;
     this._endOffset = end;
   }
 
   /**
-   * Return the node that was found that corresponds to the given source range, or {@code null} if
+   * Return the node that was found that corresponds to the given source range, or `null` if
    * there is no such node.
    * @return the node that was found
    */
   ASTNode get foundNode => _foundNode;
 
   /**
-   * Search within the given AST node for an identifier representing a {@link DartElement Dart
-   * element} in the specified source range. Return the element that was found, or {@code null} if
+   * Search within the given AST node for an identifier representing a [DartElement Dart
+   * element] in the specified source range. Return the element that was found, or `null` if
    * no element was found.
    * @param node the AST node within which to search
    * @return the element that was found
    */
   ASTNode searchWithin(ASTNode node) {
     try {
       node.accept(this);
     } on NodeLocator_NodeFoundException catch (exception) {
     } catch (exception) {
       AnalysisEngine.instance.logger.logInformation2("Unable to locate element at offset (${_startOffset} - ${_endOffset})", exception);
@@ skipping 18 matching lines @@
       AnalysisEngine.instance.logger.logInformation2("Exception caught while traversing an AST structure.", exception);
     }
     if (start <= _startOffset && _endOffset <= end) {
       _foundNode = node;
       throw new NodeLocator_NodeFoundException();
     }
     return null;
   }
 }
 /**
- * Instances of the class {@code NodeFoundException} are used to cancel visiting after a node has
+ * Instances of the class `NodeFoundException` are used to cancel visiting after a node has
  * been found.
  */
 class NodeLocator_NodeFoundException extends RuntimeException {
   static int _serialVersionUID = 1;
 }
 /**
- * Instances of the class {@code RecursiveASTVisitor} implement an AST visitor that will recursively
+ * Instances of the class `RecursiveASTVisitor` implement an AST visitor that will recursively
  * visit all of the nodes in an AST structure. For example, using an instance of this class to visit
- * a {@link Block} will also cause all of the statements in the block to be visited.
- * <p>
+ * a [Block] will also cause all of the statements in the block to be visited.
+ *
  * Subclasses that override a visit method must either invoke the overridden visit method or must
  * explicitly ask the visited node to visit its children. Failure to do so will cause the children
  * of the visited node to not be visited.
  * @coverage dart.engine.ast
  */
 class RecursiveASTVisitor<R> implements ASTVisitor<R> {
   R visitAdjacentStrings(AdjacentStrings node) {
     node.visitChildren(this);
     return null;
   }
@@ skipping 392 matching lines @@
   R visitWhileStatement(WhileStatement node) {
     node.visitChildren(this);
     return null;
   }
   R visitWithClause(WithClause node) {
     node.visitChildren(this);
     return null;
   }
 }
 /**
- * Instances of the class {@code SimpleASTVisitor} implement an AST visitor that will do nothing
+ * Instances of the class `SimpleASTVisitor` implement an AST visitor that will do nothing
  * when visiting an AST node. It is intended to be a superclass for classes that use the visitor
  * pattern primarily as a dispatch mechanism (and hence don't need to recursively visit a whole
  * structure) and that only need to visit a small number of node types.
  * @coverage dart.engine.ast
  */
 class SimpleASTVisitor<R> implements ASTVisitor<R> {
   R visitAdjacentStrings(AdjacentStrings node) => null;
   R visitAnnotation(Annotation node) => null;
   R visitArgumentDefinitionTest(ArgumentDefinitionTest node) => null;
   R visitArgumentList(ArgumentList node) => null;
@@ skipping 89 matching lines @@
   R visitTypeName(TypeName node) => null;
   R visitTypeParameter(TypeParameter node) => null;
   R visitTypeParameterList(TypeParameterList node) => null;
   R visitVariableDeclaration(VariableDeclaration node) => null;
   R visitVariableDeclarationList(VariableDeclarationList node) => null;
   R visitVariableDeclarationStatement(VariableDeclarationStatement node) => null;
   R visitWhileStatement(WhileStatement node) => null;
   R visitWithClause(WithClause node) => null;
 }
 /**
- * Instances of the class {@code ToSourceVisitor} write a source representation of a visited AST
+ * Instances of the class `ToSourceVisitor` write a source representation of a visited AST
  * node (and all of it's children) to a writer.
  * @coverage dart.engine.ast
  */
 class ToSourceVisitor implements ASTVisitor<Object> {
 
   /**
    * The writer to which the source is to be written.
    */
   PrintWriter _writer;
 
@@ skipping 693 matching lines @@
    * Safely visit the given node.
    * @param node the node to be visited
    */
   void visit(ASTNode node) {
     if (node != null) {
       node.accept(this);
     }
   }
 
   /**
-   * Safely visit the given node, printing the suffix after the node if it is non-{@code null}.
+   * Safely visit the given node, printing the suffix after the node if it is non-`null`.
    * @param suffix the suffix to be printed if there is a node to visit
    * @param node the node to be visited
    */
   void visit2(ASTNode node, String suffix) {
     if (node != null) {
       node.accept(this);
       _writer.print(suffix);
     }
   }
 
   /**
-   * Safely visit the given node, printing the prefix before the node if it is non-{@code null}.
+   * Safely visit the given node, printing the prefix before the node if it is non-`null`.
    * @param prefix the prefix to be printed if there is a node to visit
    * @param node the node to be visited
    */
   void visit3(String prefix, ASTNode node) {
     if (node != null) {
       _writer.print(prefix);
       node.accept(this);
     }
   }
 
   /**
    * Visit the given function body, printing the prefix before if given body is not empty.
    * @param prefix the prefix to be printed if there is a node to visit
    * @param body the function body to be visited
    */
   void visit4(String prefix, FunctionBody body) {
     if (body is! EmptyFunctionBody) {
       _writer.print(prefix);
     }
     visit(body);
   }
 
   /**
-   * Safely visit the given node, printing the suffix after the node if it is non-{@code null}.
+   * Safely visit the given node, printing the suffix after the node if it is non-`null`.
    * @param suffix the suffix to be printed if there is a node to visit
    * @param node the node to be visited
    */
   void visit5(Token token, String suffix) {
     if (token != null) {
       _writer.print(token.lexeme);
       _writer.print(suffix);
     }
   }
 
@@ skipping 59 matching lines @@
           if (i > 0) {
             _writer.print(separator);
           }
           nodes[i].accept(this);
         }
       }
     }
   }
 }
 /**
- * Instances of the class {@code ASTCloner} implement an object that will clone any AST structure
+ * Instances of the class `ASTCloner` implement an object that will clone any AST structure
  * that it visits. The cloner will only clone the structure, it will not preserve any resolution
  * results or properties associated with the nodes.
  */
 class ASTCloner implements ASTVisitor<ASTNode> {
   AdjacentStrings visitAdjacentStrings(AdjacentStrings node) => new AdjacentStrings.full(clone3(node.strings));
   Annotation visitAnnotation(Annotation node) => new Annotation.full(node.atSign, clone2(node.name), node.period, clone2(node.constructorName), clone2(node.arguments));
   ArgumentDefinitionTest visitArgumentDefinitionTest(ArgumentDefinitionTest node) => new ArgumentDefinitionTest.full(node.question, clone2(node.identifier));
   ArgumentList visitArgumentList(ArgumentList node) => new ArgumentList.full(node.leftParenthesis, clone3(node.arguments), node.rightParenthesis);
   AsExpression visitAsExpression(AsExpression node) => new AsExpression.full(clone2(node.expression), node.asOperator, clone2(node.type));
   ASTNode visitAssertStatement(AssertStatement node) => new AssertStatement.full(node.keyword, node.leftParenthesis, clone2(node.condition), node.rightParenthesis, node.semicolon);
@@ skipping 123 matching lines @@
     for (ASTNode node in nodes) {
       clonedNodes.add((node.accept(this) as ASTNode));
     }
     return clonedNodes;
   }
 }
 /**
  * Traverse the AST from initial child node to successive parents, building a collection of local
  * variable and parameter names visible to the initial child node. In case of name shadowing, the
  * first name seen is the most specific one so names are not redefined.
- * <p>
+ *
  * Completion test code coverage is 95%. The two basic blocks that are not executed cannot be
  * executed. They are included for future reference.
  * @coverage com.google.dart.engine.services.completion
  */
 class ScopedNameFinder extends GeneralizingASTVisitor<Object> {
   Declaration _declarationNode;
   ASTNode _immediateChild;
   Map<String, SimpleIdentifier> _locals = new Map<String, SimpleIdentifier>();
   int _position = 0;
   bool _referenceIsWithinLocalFunction = false;
@@ skipping 181 matching lines @@
     return elements[elements.length - 1].endToken;
   }
   /**
    * Return the node that is the parent of each of the elements in the list.
    * @return the node that is the parent of each of the elements in the list
    */
   ASTNode getOwner() {
     return owner;
   }
 }