New analyzer_experimental snapshot.

pkg/analyzer_experimental/lib/src/generated/parser.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.parser;
 import 'dart:collection';
 import 'java_core.dart';
 import 'java_engine.dart';
 import 'instrumentation.dart';
 import 'error.dart';
 import 'source.dart';
 import 'scanner.dart';
 import 'ast.dart';
 import 'utilities_dart.dart';
 /**
- * Instances of the class {@code CommentAndMetadata} implement a simple data-holder for a method
+ * Instances of the class `CommentAndMetadata` implement a simple data-holder for a method
  * that needs to return multiple values.
  * @coverage dart.engine.parser
  */
 class CommentAndMetadata {
 
   /**
-   * The documentation comment that was parsed, or {@code null} if none was given.
+   * The documentation comment that was parsed, or `null` if none was given.
    */
   Comment _comment;
 
   /**
    * The metadata that was parsed.
    */
   List<Annotation> _metadata;
 
   /**
    * Initialize a newly created holder with the given data.
    * @param comment the documentation comment that was parsed
    * @param metadata the metadata that was parsed
    */
   CommentAndMetadata(Comment comment, List<Annotation> metadata) {
     this._comment = comment;
     this._metadata = metadata;
   }
 
   /**
-   * Return the documentation comment that was parsed, or {@code null} if none was given.
+   * Return the documentation comment that was parsed, or `null` if none was given.
    * @return the documentation comment that was parsed
    */
   Comment get comment => _comment;
 
   /**
    * Return the metadata that was parsed. If there was no metadata, then the list will be empty.
    * @return the metadata that was parsed
    */
   List<Annotation> get metadata => _metadata;
 }
 /**
- * Instances of the class {@code FinalConstVarOrType} implement a simple data-holder for a method
+ * Instances of the class `FinalConstVarOrType` implement a simple data-holder for a method
  * that needs to return multiple values.
  * @coverage dart.engine.parser
  */
 class FinalConstVarOrType {
 
   /**
-   * The 'final', 'const' or 'var' keyword, or {@code null} if none was given.
+   * The 'final', 'const' or 'var' keyword, or `null` if none was given.
    */
   Token _keyword;
 
   /**
-   * The type, of {@code null} if no type was specified.
+   * The type, of `null` if no type was specified.
    */
   TypeName _type;
 
   /**
    * Initialize a newly created holder with the given data.
    * @param keyword the 'final', 'const' or 'var' keyword
    * @param type the type
    */
   FinalConstVarOrType(Token keyword, TypeName type) {
     this._keyword = keyword;
     this._type = type;
   }
 
   /**
-   * Return the 'final', 'const' or 'var' keyword, or {@code null} if none was given.
+   * Return the 'final', 'const' or 'var' keyword, or `null` if none was given.
    * @return the 'final', 'const' or 'var' keyword
    */
   Token get keyword => _keyword;
 
   /**
-   * Return the type, of {@code null} if no type was specified.
+   * Return the type, of `null` if no type was specified.
    * @return the type
    */
   TypeName get type => _type;
 }
 /**
- * Instances of the class {@code Modifiers} implement a simple data-holder for a method that needs
+ * Instances of the class `Modifiers` implement a simple data-holder for a method that needs
  * to return multiple values.
  * @coverage dart.engine.parser
  */
 class Modifiers {
 
   /**
-   * The token representing the keyword 'abstract', or {@code null} if the keyword was not found.
+   * The token representing the keyword 'abstract', or `null` if the keyword was not found.
    */
   Token _abstractKeyword;
 
   /**
-   * The token representing the keyword 'const', or {@code null} if the keyword was not found.
+   * The token representing the keyword 'const', or `null` if the keyword was not found.
    */
   Token _constKeyword;
 
   /**
-   * The token representing the keyword 'external', or {@code null} if the keyword was not found.
+   * The token representing the keyword 'external', or `null` if the keyword was not found.
    */
   Token _externalKeyword;
 
   /**
-   * The token representing the keyword 'factory', or {@code null} if the keyword was not found.
+   * The token representing the keyword 'factory', or `null` if the keyword was not found.
    */
   Token _factoryKeyword;
 
   /**
-   * The token representing the keyword 'final', or {@code null} if the keyword was not found.
+   * The token representing the keyword 'final', or `null` if the keyword was not found.
    */
   Token _finalKeyword;
 
   /**
-   * The token representing the keyword 'static', or {@code null} if the keyword was not found.
+   * The token representing the keyword 'static', or `null` if the keyword was not found.
    */
   Token _staticKeyword;
 
   /**
-   * The token representing the keyword 'var', or {@code null} if the keyword was not found.
+   * The token representing the keyword 'var', or `null` if the keyword was not found.
    */
   Token _varKeyword;
 
   /**
-   * Return the token representing the keyword 'abstract', or {@code null} if the keyword was not
+   * Return the token representing the keyword 'abstract', or `null` if the keyword was not
    * found.
    * @return the token representing the keyword 'abstract'
    */
   Token get abstractKeyword => _abstractKeyword;
 
   /**
-   * Return the token representing the keyword 'const', or {@code null} if the keyword was not
+   * Return the token representing the keyword 'const', or `null` if the keyword was not
    * found.
    * @return the token representing the keyword 'const'
    */
   Token get constKeyword => _constKeyword;
 
   /**
-   * Return the token representing the keyword 'external', or {@code null} if the keyword was not
+   * Return the token representing the keyword 'external', or `null` if the keyword was not
    * found.
    * @return the token representing the keyword 'external'
    */
   Token get externalKeyword => _externalKeyword;
 
   /**
-   * Return the token representing the keyword 'factory', or {@code null} if the keyword was not
+   * Return the token representing the keyword 'factory', or `null` if the keyword was not
    * found.
    * @return the token representing the keyword 'factory'
    */
   Token get factoryKeyword => _factoryKeyword;
 
   /**
-   * Return the token representing the keyword 'final', or {@code null} if the keyword was not
+   * Return the token representing the keyword 'final', or `null` if the keyword was not
    * found.
    * @return the token representing the keyword 'final'
    */
   Token get finalKeyword => _finalKeyword;
 
   /**
-   * Return the token representing the keyword 'static', or {@code null} if the keyword was not
+   * Return the token representing the keyword 'static', or `null` if the keyword was not
    * found.
    * @return the token representing the keyword 'static'
    */
   Token get staticKeyword => _staticKeyword;
 
   /**
-   * Return the token representing the keyword 'var', or {@code null} if the keyword was not found.
+   * Return the token representing the keyword 'var', or `null` if the keyword was not found.
    * @return the token representing the keyword 'var'
    */
   Token get varKeyword => _varKeyword;
 
   /**
    * Set the token representing the keyword 'abstract' to the given token.
    * @param abstractKeyword the token representing the keyword 'abstract'
    */
   void set abstractKeyword(Token abstractKeyword2) {
     this._abstractKeyword = abstractKeyword2;
@@ skipping 52 matching lines @@
     needsSpace = appendKeyword(builder, needsSpace, _constKeyword);
     needsSpace = appendKeyword(builder, needsSpace, _externalKeyword);
     needsSpace = appendKeyword(builder, needsSpace, _factoryKeyword);
     needsSpace = appendKeyword(builder, needsSpace, _finalKeyword);
     needsSpace = appendKeyword(builder, needsSpace, _staticKeyword);
     appendKeyword(builder, needsSpace, _varKeyword);
     return builder.toString();
   }
 
   /**
-   * If the given keyword is not {@code null}, append it to the given builder, prefixing it with a
+   * If the given keyword is not `null`, append it to the given builder, prefixing it with a
    * space if needed.
    * @param builder the builder to which the keyword will be appended
-   * @param needsSpace {@code true} if the keyword needs to be prefixed with a space
+   * @param needsSpace `true` if the keyword needs to be prefixed with a space
    * @param keyword the keyword to be appended
-   * @return {@code true} if subsequent keywords need to be prefixed with a space
+   * @return `true` if subsequent keywords need to be prefixed with a space
    */
   bool appendKeyword(JavaStringBuilder builder, bool needsSpace, Token keyword) {
     if (keyword != null) {
       if (needsSpace) {
         builder.appendChar(0x20);
       }
       builder.append(keyword.lexeme);
       return true;
     }
     return needsSpace;
   }
 }
 /**
- * Instances of the class {@code Parser} are used to parse tokens into an AST structure.
+ * Instances of the class `Parser` are used to parse tokens into an AST structure.
  * @coverage dart.engine.parser
  */
 class Parser {
 
   /**
    * The source being parsed.
    */
   Source _source;
 
   /**
@@ skipping 43 matching lines @@
       _currentToken = token;
       return parseCompilationUnit2();
     } finally {
       instrumentation.log();
     }
   }
 
   /**
    * Parse an expression, starting with the given token.
    * @param token the first token of the expression
-   * @return the expression that was parsed, or {@code null} if the tokens do not represent a
+   * @return the expression that was parsed, or `null` if the tokens do not represent a
    * recognizable expression
    */
   Expression parseExpression(Token token) {
     InstrumentationBuilder instrumentation = Instrumentation.builder2("dart.engine.Parser.parseExpression");
     try {
       _currentToken = token;
       return parseExpression2();
     } finally {
       instrumentation.log();
     }
   }
 
   /**
    * Parse a statement, starting with the given token.
    * @param token the first token of the statement
-   * @return the statement that was parsed, or {@code null} if the tokens do not represent a
+   * @return the statement that was parsed, or `null` if the tokens do not represent a
    * recognizable statement
    */
   Statement parseStatement(Token token) {
     InstrumentationBuilder instrumentation = Instrumentation.builder2("dart.engine.Parser.parseStatement");
     try {
       _currentToken = token;
       return parseStatement2();
     } finally {
       instrumentation.log();
     }
   }
 
   /**
    * Parse a sequence of statements, starting with the given token.
    * @param token the first token of the sequence of statement
-   * @return the statements that were parsed, or {@code null} if the tokens do not represent a
+   * @return the statements that were parsed, or `null` if the tokens do not represent a
    * recognizable sequence of statements
    */
   List<Statement> parseStatements(Token token) {
     InstrumentationBuilder instrumentation = Instrumentation.builder2("dart.engine.Parser.parseStatements");
     try {
       _currentToken = token;
       return parseStatements2();
     } finally {
       instrumentation.log();
     }
@@ skipping 68 matching lines @@
 
   /**
    * Convert the given method declaration into the nearest valid top-level function declaration.
    * @param method the method to be converted
    * @return the function declaration that most closely captures the components of the given method
    * declaration
    */
   FunctionDeclaration convertToFunctionDeclaration(MethodDeclaration method) => new FunctionDeclaration.full(method.documentationComment, method.metadata, method.externalKeyword, method.returnType, method.propertyKeyword, method.name, new FunctionExpression.full(method.parameters, method.body));
 
   /**
-   * Return {@code true} if the current token could be the start of a compilation unit member. This
+   * Return `true` if the current token could be the start of a compilation unit member. This
    * method is used for recovery purposes to decide when to stop skipping tokens after finding an
    * error while parsing a compilation unit member.
-   * @return {@code true} if the current token could be the start of a compilation unit member
+   * @return `true` if the current token could be the start of a compilation unit member
    */
   bool couldBeStartOfCompilationUnitMember() {
     if ((matches(Keyword.IMPORT) || matches(Keyword.EXPORT) || matches(Keyword.LIBRARY) || matches(Keyword.PART)) && !matches4(peek(), TokenType.PERIOD) && !matches4(peek(), TokenType.LT)) {
       return true;
     } else if (matches(Keyword.CLASS)) {
       return true;
     } else if (matches(Keyword.TYPEDEF) && !matches4(peek(), TokenType.PERIOD) && !matches4(peek(), TokenType.LT)) {
       return true;
     } else if (matches(Keyword.VOID) || ((matches(Keyword.GET) || matches(Keyword.SET)) && matchesIdentifier2(peek())) || (matches(Keyword.OPERATOR) && isOperator(peek()))) {
       return true;
@@ skipping 82 matching lines @@
     if (identical(type, TokenType.SEMICOLON)) {
       reportError8(ParserErrorCode.EXPECTED_TOKEN, _currentToken.previous, [type.lexeme]);
     } else {
       reportError7(ParserErrorCode.EXPECTED_TOKEN, [type.lexeme]);
     }
     return _currentToken;
   }
 
   /**
    * Search the given list of ranges for a range that contains the given index. Return the range
-   * that was found, or {@code null} if none of the ranges contain the index.
+   * that was found, or `null` if none of the ranges contain the index.
    * @param ranges the ranges to be searched
    * @param index the index contained in the returned range
    * @return the range that was found
    */
   List<int> findRange(List<List<int>> ranges, int index) {
     for (List<int> range in ranges) {
       if (range[0] <= index && index <= range[1]) {
         return range;
       } else if (index < range[0]) {
         return null;
@@ skipping 48 matching lines @@
         ranges.add(<int> [index, end]);
         index = end + 1;
       } else {
         index = index + 1;
       }
     }
     return ranges;
   }
 
   /**
-   * Return the end token associated with the given begin token, or {@code null} if either the given
+   * Return the end token associated with the given begin token, or `null` if either the given
    * token is not a begin token or it does not have an end token associated with it.
    * @param beginToken the token that is expected to have an end token associated with it
    * @return the end token associated with the begin token
    */
   Token getEndToken(Token beginToken) {
     if (beginToken is BeginToken) {
       return ((beginToken as BeginToken)).endToken;
     }
     return null;
   }
 
   /**
-   * Return {@code true} if the current token is the first token of a return type that is followed
+   * Return `true` if the current token is the first token of a return type that is followed
    * by an identifier, possibly followed by a list of type parameters, followed by a
    * left-parenthesis. This is used by parseTypeAlias to determine whether or not to parse a return
    * type.
-   * @return {@code true} if we can successfully parse the rest of a type alias if we first parse a
+   * @return `true` if we can successfully parse the rest of a type alias if we first parse a
    * return type.
    */
   bool hasReturnTypeInTypeAlias() {
     Token next = skipReturnType(_currentToken);
     if (next == null) {
       return false;
     }
     return matchesIdentifier2(next);
   }
 
   /**
-   * Return {@code true} if the current token appears to be the beginning of a function declaration.
-   * @return {@code true} if the current token appears to be the beginning of a function declaration
+   * Return `true` if the current token appears to be the beginning of a function declaration.
+   * @return `true` if the current token appears to be the beginning of a function declaration
    */
   bool isFunctionDeclaration() {
     if (matches(Keyword.VOID)) {
       return true;
     }
     Token afterReturnType = skipTypeName(_currentToken);
     if (afterReturnType == null) {
       afterReturnType = _currentToken;
     }
     Token afterIdentifier = skipSimpleIdentifier(afterReturnType);
     if (afterIdentifier == null) {
       afterIdentifier = skipSimpleIdentifier(_currentToken);
     }
     if (afterIdentifier == null) {
       return false;
     }
     return isFunctionExpression(afterIdentifier);
   }
 
   /**
-   * Return {@code true} if the given token appears to be the beginning of a function expression.
+   * Return `true` if the given token appears to be the beginning of a function expression.
    * @param startToken the token that might be the start of a function expression
-   * @return {@code true} if the given token appears to be the beginning of a function expression
+   * @return `true` if the given token appears to be the beginning of a function expression
    */
   bool isFunctionExpression(Token startToken) {
     Token afterParameters = skipFormalParameterList(startToken);
     if (afterParameters == null) {
       return false;
     }
     return matchesAny(afterParameters, [TokenType.OPEN_CURLY_BRACKET, TokenType.FUNCTION]);
   }
 
   /**
-   * Return {@code true} if the given character is a valid hexadecimal digit.
+   * Return `true` if the given character is a valid hexadecimal digit.
    * @param character the character being tested
-   * @return {@code true} if the character is a valid hexadecimal digit
+   * @return `true` if the character is a valid hexadecimal digit
    */
   bool isHexDigit(int character) => (0x30 <= character && character <= 0x39) || (0x41 <= character && character <= 0x46) || (0x61 <= character && character <= 0x66);
 
   /**
-   * Return {@code true} if the current token is the first token in an initialized variable
+   * Return `true` if the current token is the first token in an initialized variable
    * declaration rather than an expression. This method assumes that we have already skipped past
    * any metadata that might be associated with the declaration.
    * <pre>
    * initializedVariableDeclaration ::=
    * declaredIdentifier ('=' expression)? (',' initializedIdentifier)
    * declaredIdentifier ::=
    * metadata finalConstVarOrType identifier
    * finalConstVarOrType ::=
    * 'final' type?
    * | 'const' type?
    * | 'var'
    * | type
    * type ::=
    * qualified typeArguments?
    * initializedIdentifier ::=
    * identifier ('=' expression)?
    * </pre>
-   * @return {@code true} if the current token is the first token in an initialized variable
+   * @return `true` if the current token is the first token in an initialized variable
    * declaration
    */
   bool isInitializedVariableDeclaration() {
     if (matches(Keyword.FINAL) || matches(Keyword.VAR)) {
       return true;
     }
     if (matches(Keyword.CONST)) {
       return !matchesAny(peek(), [TokenType.LT, TokenType.OPEN_CURLY_BRACKET, TokenType.OPEN_SQUARE_BRACKET, TokenType.INDEX]);
     }
     Token token = skipTypeName(_currentToken);
     if (token == null) {
       return false;
     }
     token = skipSimpleIdentifier(token);
     if (token == null) {
       return false;
     }
     TokenType type = token.type;
     return identical(type, TokenType.EQ) || identical(type, TokenType.COMMA) || identical(type, TokenType.SEMICOLON) || matches3(token, Keyword.IN);
   }
 
   /**
    * Given that we have just found bracketed text within a comment, look to see whether that text is
    * (a) followed by a parenthesized link address, (b) followed by a colon, or (c) followed by
    * optional whitespace and another square bracket.
-   * <p>
+   *
    * This method uses the syntax described by the <a
    * href="http://daringfireball.net/projects/markdown/syntax">markdown</a> project.
    * @param comment the comment text in which the bracketed text was found
    * @param rightIndex the index of the right bracket
-   * @return {@code true} if the bracketed text is followed by a link address
+   * @return `true` if the bracketed text is followed by a link address
    */
   bool isLinkText(String comment, int rightIndex) {
     int length = comment.length;
     int index = rightIndex + 1;
     if (index >= length) {
       return false;
     }
     int nextChar = comment.codeUnitAt(index);
     if (nextChar == 0x28 || nextChar == 0x3A) {
       return true;
     }
     while (Character.isWhitespace(nextChar)) {
       index = index + 1;
       if (index >= length) {
         return false;
       }
       nextChar = comment.codeUnitAt(index);
     }
     return nextChar == 0x5B;
   }
 
   /**
-   * Return {@code true} if the given token appears to be the beginning of an operator declaration.
+   * Return `true` if the given token appears to be the beginning of an operator declaration.
    * @param startToken the token that might be the start of an operator declaration
-   * @return {@code true} if the given token appears to be the beginning of an operator declaration
+   * @return `true` if the given token appears to be the beginning of an operator declaration
    */
   bool isOperator(Token startToken) {
     if (startToken.isOperator()) {
       Token token = startToken.next;
       while (token.isOperator()) {
         token = token.next;
       }
       return matches4(token, TokenType.OPEN_PAREN);
     }
     return false;
   }
 
   /**
-   * Return {@code true} if the current token appears to be the beginning of a switch member.
-   * @return {@code true} if the current token appears to be the beginning of a switch member
+   * Return `true` if the current token appears to be the beginning of a switch member.
+   * @return `true` if the current token appears to be the beginning of a switch member
    */
   bool isSwitchMember() {
     Token token = _currentToken;
     while (matches4(token, TokenType.IDENTIFIER) && matches4(token.next, TokenType.COLON)) {
       token = token.next.next;
     }
     if (identical(token.type, TokenType.KEYWORD)) {
       Keyword keyword = ((token as KeywordToken)).keyword;
       return identical(keyword, Keyword.CASE) || identical(keyword, Keyword.DEFAULT);
     }
     return false;
   }
 
   /**
    * Compare the given tokens to find the token that appears first in the source being parsed. That
-   * is, return the left-most of all of the tokens. The arguments are allowed to be {@code null}.
-   * Return the token with the smallest offset, or {@code null} if there are no arguments or if all
-   * of the arguments are {@code null}.
+   * is, return the left-most of all of the tokens. The arguments are allowed to be `null`.
+   * Return the token with the smallest offset, or `null` if there are no arguments or if all
+   * of the arguments are `null`.
    * @param tokens the tokens being compared
    * @return the token with the smallest offset
    */
   Token lexicallyFirst(List<Token> tokens) {
     Token first = null;
     int firstOffset = 2147483647;
     for (Token token in tokens) {
       if (token != null) {
         int offset = token.offset;
         if (offset < firstOffset) {
           first = token;
           firstOffset = offset;
         }
       }
     }
     return first;
   }
 
   /**
-   * Return {@code true} if the current token matches the given keyword.
+   * Return `true` if the current token matches the given keyword.
    * @param keyword the keyword that can optionally appear in the current location
-   * @return {@code true} if the current token matches the given keyword
+   * @return `true` if the current token matches the given keyword
    */
   bool matches(Keyword keyword) => matches3(_currentToken, keyword);
 
   /**
-   * Return {@code true} if the current token matches the given identifier.
+   * Return `true` if the current token matches the given identifier.
    * @param identifier the identifier that can optionally appear in the current location
-   * @return {@code true} if the current token matches the given identifier
+   * @return `true` if the current token matches the given identifier
    */
   bool matches2(String identifier) => identical(_currentToken.type, TokenType.IDENTIFIER) && _currentToken.lexeme == identifier;
 
   /**
-   * Return {@code true} if the given token matches the given keyword.
+   * Return `true` if the given token matches the given keyword.
    * @param token the token being tested
    * @param keyword the keyword that is being tested for
-   * @return {@code true} if the given token matches the given keyword
+   * @return `true` if the given token matches the given keyword
    */
   bool matches3(Token token, Keyword keyword2) => identical(token.type, TokenType.KEYWORD) && identical(((token as KeywordToken)).keyword, keyword2);
 
   /**
-   * Return {@code true} if the given token has the given type.
+   * Return `true` if the given token has the given type.
    * @param token the token being tested
    * @param type the type of token that is being tested for
-   * @return {@code true} if the given token has the given type
+   * @return `true` if the given token has the given type
    */
   bool matches4(Token token, TokenType type2) => identical(token.type, type2);
 
   /**
-   * Return {@code true} if the current token has the given type. Note that this method, unlike
+   * Return `true` if the current token has the given type. Note that this method, unlike
    * other variants, will modify the token stream if possible to match a wider range of tokens. In
    * particular, if we are attempting to match a '>' and the next token is either a '>>' or '>>>',
-   * the token stream will be re-written and {@code true} will be returned.
+   * the token stream will be re-written and `true` will be returned.
    * @param type the type of token that can optionally appear in the current location
-   * @return {@code true} if the current token has the given type
+   * @return `true` if the current token has the given type
    */
   bool matches5(TokenType type2) {
     TokenType currentType = _currentToken.type;
     if (currentType != type2) {
       if (identical(type2, TokenType.GT)) {
         if (identical(currentType, TokenType.GT_GT)) {
           int offset = _currentToken.offset;
           Token first = new Token(TokenType.GT, offset);
           Token second = new Token(TokenType.GT, offset + 1);
           second.setNext(_currentToken.next);
@@ skipping 22 matching lines @@
           _currentToken = first;
           return true;
         }
       }
       return false;
     }
     return true;
   }
 
   /**
-   * Return {@code true} if the given token has any one of the given types.
+   * Return `true` if the given token has any one of the given types.
    * @param token the token being tested
    * @param types the types of token that are being tested for
-   * @return {@code true} if the given token has any of the given types
+   * @return `true` if the given token has any of the given types
    */
   bool matchesAny(Token token, List<TokenType> types) {
     TokenType actualType = token.type;
     for (TokenType type in types) {
       if (identical(actualType, type)) {
         return true;
       }
     }
     return false;
   }
 
   /**
-   * Return {@code true} if the current token is a valid identifier. Valid identifiers include
+   * Return `true` if the current token is a valid identifier. Valid identifiers include
    * built-in identifiers (pseudo-keywords).
-   * @return {@code true} if the current token is a valid identifier
+   * @return `true` if the current token is a valid identifier
    */
   bool matchesIdentifier() => matchesIdentifier2(_currentToken);
 
   /**
-   * Return {@code true} if the given token is a valid identifier. Valid identifiers include
+   * Return `true` if the given token is a valid identifier. Valid identifiers include
    * built-in identifiers (pseudo-keywords).
-   * @return {@code true} if the given token is a valid identifier
+   * @return `true` if the given token is a valid identifier
    */
   bool matchesIdentifier2(Token token) => matches4(token, TokenType.IDENTIFIER) || (matches4(token, TokenType.KEYWORD) && ((token as KeywordToken)).keyword.isPseudoKeyword());
 
   /**
-   * If the current token has the given type, then advance to the next token and return {@code true}. Otherwise, return {@code false} without advancing.
+   * If the current token has the given type, then advance to the next token and return `true`. Otherwise, return `false` without advancing.
    * @param type the type of token that can optionally appear in the current location
-   * @return {@code true} if the current token has the given type
+   * @return `true` if the current token has the given type
    */
   bool optional(TokenType type) {
     if (matches5(type)) {
       advance();
       return true;
     }
     return false;
   }
 
   /**
@@ skipping 133 matching lines @@
   }
 
   /**
    * Parse an assignable expression.
    * <pre>
    * assignableExpression ::=
    * primary (arguments* assignableSelector)+
    * | 'super' assignableSelector
    * | identifier
    * </pre>
-   * @param primaryAllowed {@code true} if the expression is allowed to be a primary without any
+   * @param primaryAllowed `true` if the expression is allowed to be a primary without any
    * assignable selector
    * @return the assignable expression that was parsed
    */
   Expression parseAssignableExpression(bool primaryAllowed) {
     if (matches(Keyword.SUPER)) {
       return parseAssignableSelector(new SuperExpression.full(andAdvance), false);
     }
     Expression expression = parsePrimaryExpression();
     bool isOptional = primaryAllowed || expression is SimpleIdentifier;
     while (true) {
@@ skipping 28 matching lines @@
   }
 
   /**
    * Parse an assignable selector.
    * <pre>
    * assignableSelector ::=
    * '\[' expression '\]'
    * | '.' identifier
    * </pre>
    * @param prefix the expression preceding the selector
-   * @param optional {@code true} if the selector is optional
+   * @param optional `true` if the selector is optional
    * @return the assignable selector that was parsed
    */
   Expression parseAssignableSelector(Expression prefix, bool optional) {
     if (matches5(TokenType.OPEN_SQUARE_BRACKET)) {
       Token leftBracket = andAdvance;
       Expression index = parseExpression2();
       Token rightBracket = expect2(TokenType.CLOSE_SQUARE_BRACKET);
       return new IndexExpression.forTarget_full(prefix, leftBracket, index, rightBracket);
     } else if (matches5(TokenType.PERIOD)) {
       Token period = andAdvance;
@@ skipping 188 matching lines @@
     return expression;
   }
 
   /**
    * Parse a class declaration.
    * <pre>
    * classDeclaration ::=
    * metadata 'abstract'? 'class' name typeParameterList? (extendsClause withClause?)? implementsClause? '{' classMembers '}'
    * </pre>
    * @param commentAndMetadata the metadata to be associated with the member
-   * @param abstractKeyword the token for the keyword 'abstract', or {@code null} if the keyword was
+   * @param abstractKeyword the token for the keyword 'abstract', or `null` if the keyword was
    * not given
    * @return the class declaration that was parsed
    */
   ClassDeclaration parseClassDeclaration(CommentAndMetadata commentAndMetadata, Token abstractKeyword) {
     Token keyword = expect(Keyword.CLASS);
     SimpleIdentifier name = parseSimpleIdentifier();
     String className = name.name;
     TypeParameterList typeParameters = null;
     if (matches5(TokenType.LT)) {
       typeParameters = parseTypeParameterList();
@@ skipping 59 matching lines @@
   }
 
   /**
    * Parse a class member.
    * <pre>
    * classMemberDefinition ::=
    * declaration ';'
    * | methodSignature functionBody
    * </pre>
    * @param className the name of the class containing the member being parsed
-   * @return the class member that was parsed, or {@code null} if what was found was not a valid
+   * @return the class member that was parsed, or `null` if what was found was not a valid
    * class member
    */
   ClassMember parseClassMember(String className) {
     CommentAndMetadata commentAndMetadata = parseCommentAndMetadata();
     Modifiers modifiers = parseModifiers();
     if (matches(Keyword.VOID)) {
       TypeName returnType = parseReturnType();
       if (matches(Keyword.GET) && matchesIdentifier2(peek())) {
         validateModifiersForGetterOrSetterOrMethod(modifiers);
         return parseGetter(commentAndMetadata, modifiers.externalKeyword, modifiers.staticKeyword, returnType);
@@ skipping 87 matching lines @@
     return parseInitializedIdentifierList(commentAndMetadata, modifiers.staticKeyword, validateModifiersForField(modifiers), type);
   }
 
   /**
    * Parse a list of class members.
    * <pre>
    * classMembers ::=
    * (metadata memberDefinition)
    * </pre>
    * @param className the name of the class whose members are being parsed
-   * @param closingBracket the closing bracket for the class, or {@code null} if the closing bracket
+   * @param closingBracket the closing bracket for the class, or `null` if the closing bracket
    * is missing
    * @return the list of class members that were parsed
    */
   List<ClassMember> parseClassMembers(String className, Token closingBracket) {
     List<ClassMember> members = new List<ClassMember>();
     Token memberStart = _currentToken;
     while (!matches5(TokenType.EOF) && !matches5(TokenType.CLOSE_CURLY_BRACKET) && (closingBracket != null || (!matches(Keyword.CLASS) && !matches(Keyword.TYPEDEF)))) {
       if (matches5(TokenType.SEMICOLON)) {
         reportError8(ParserErrorCode.UNEXPECTED_TOKEN, _currentToken, [_currentToken.lexeme]);
         advance();
@@ skipping 110 matching lines @@
 
   /**
    * Parse a comment reference from the source between square brackets.
    * <pre>
    * commentReference ::=
    * 'new'? prefixedIdentifier
    * </pre>
    * @param referenceSource the source occurring between the square brackets within a documentation
    * comment
    * @param sourceOffset the offset of the first character of the reference source
-   * @return the comment reference that was parsed, or {@code null} if no reference could be found
+   * @return the comment reference that was parsed, or `null` if no reference could be found
    */
   CommentReference parseCommentReference(String referenceSource, int sourceOffset) {
     if (referenceSource.length == 0) {
       return null;
     }
     try {
       List<bool> errorFound = [false];
       AnalysisErrorListener listener = new AnalysisErrorListener_11(errorFound);
       StringScanner scanner = new StringScanner(null, referenceSource, listener);
       scanner.setSourceStart(1, 1, sourceOffset);
@@ skipping 70 matching lines @@
         } else {
           leftIndex = comment.indexOf('[', range[1] + 1);
         }
       }
     }
     return references;
   }
 
   /**
    * Parse a compilation unit.
-   * <p>
+   *
    * Specified:
    * <pre>
    * compilationUnit ::=
    * scriptTag? directive* topLevelDeclaration
    * </pre>
    * Actual:
    * <pre>
    * compilationUnit ::=
    * scriptTag? topLevelElement
    * topLevelElement ::=
@@ skipping 85 matching lines @@
    * | functionTypeAlias
    * | external functionSignature
    * | external getterSignature
    * | external setterSignature
    * | functionSignature functionBody
    * | returnType? getOrSet identifier formalParameterList functionBody
    * | (final | const) type? staticFinalDeclarationList ';'
    * | variableDeclaration ';'
    * </pre>
    * @param commentAndMetadata the metadata to be associated with the member
-   * @return the compilation unit member that was parsed, or {@code null} if what was parsed could
+   * @return the compilation unit member that was parsed, or `null` if what was parsed could
    * not be represented as a compilation unit member
    */
   CompilationUnitMember parseCompilationUnitMember(CommentAndMetadata commentAndMetadata) {
     Modifiers modifiers = parseModifiers();
     if (matches(Keyword.CLASS)) {
       return parseClassDeclaration(commentAndMetadata, validateModifiersForClass(modifiers));
     } else if (matches(Keyword.TYPEDEF) && !matches4(peek(), TokenType.PERIOD) && !matches4(peek(), TokenType.LT)) {
       validateModifiersForTypedef(modifiers);
       return parseTypeAlias(commentAndMetadata);
     }
@@ skipping 247 matching lines @@
     }
   }
 
   /**
    * Parse a documentation comment.
    * <pre>
    * documentationComment ::=
    * multiLineComment?
    * | singleLineComment
    * </pre>
-   * @return the documentation comment that was parsed, or {@code null} if there was no comment
+   * @return the documentation comment that was parsed, or `null` if there was no comment
    */
   Comment parseDocumentationComment() {
     List<Token> commentTokens = new List<Token>();
     Token commentToken = _currentToken.precedingComments;
     while (commentToken != null) {
       if (identical(commentToken.type, TokenType.SINGLE_LINE_COMMENT)) {
         if (commentToken.lexeme.startsWith("///")) {
           if (commentTokens.length == 1 && commentTokens[0].lexeme.startsWith("/**")) {
             commentTokens.clear();
           }
@@ skipping 184 matching lines @@
 
   /**
    * Parse the 'final', 'const', 'var' or type preceding a variable declaration.
    * <pre>
    * finalConstVarOrType ::=
    * | 'final' type?
    * | 'const' type?
    * | 'var'
    * | type
    * </pre>
-   * @param optional {@code true} if the keyword and type are optional
+   * @param optional `true` if the keyword and type are optional
    * @return the 'final', 'const', 'var' or type that was parsed
    */
   FinalConstVarOrType parseFinalConstVarOrType(bool optional) {
     Token keyword = null;
     TypeName type = null;
     if (matches(Keyword.FINAL) || matches(Keyword.CONST)) {
       keyword = andAdvance;
       if (matchesIdentifier2(peek()) || matches4(peek(), TokenType.LT) || matches3(peek(), Keyword.THIS) || (matches4(peek(), TokenType.PERIOD) && matchesIdentifier2(peek2(2)) && (matchesIdentifier2(peek2(3)) || matches4(peek2(3), TokenType.LT) || matches3(peek2(3), Keyword.THIS)))) {
         type = parseTypeName();
       }
     } else if (matches(Keyword.VAR)) {
       keyword = andAdvance;
     } else {
       if (matchesIdentifier2(peek()) || matches4(peek(), TokenType.LT) || matches3(peek(), Keyword.THIS) || (matches4(peek(), TokenType.PERIOD) && matchesIdentifier2(peek2(2)) && (matchesIdentifier2(peek2(3)) || matches4(peek2(3), TokenType.LT) || matches3(peek2(3), Keyword.THIS)))) {
         type = parseReturnType();
       } else if (!optional) {
         reportError7(ParserErrorCode.MISSING_CONST_FINAL_VAR_OR_TYPE, []);
       }
     }
     return new FinalConstVarOrType(keyword, type);
   }
 
   /**
-   * Parse a formal parameter. At most one of {@code isOptional} and {@code isNamed} can be{@code true}.
+   * Parse a formal parameter. At most one of `isOptional` and `isNamed` can be`true`.
    * <pre>
    * defaultFormalParameter ::=
    * normalFormalParameter ('=' expression)?
    * defaultNamedParameter ::=
    * normalFormalParameter (':' expression)?
    * </pre>
    * @param kind the kind of parameter being expected based on the presence or absence of group
    * delimiters
    * @return the formal parameter that was parsed
    */
@@ skipping 224 matching lines @@
   /**
    * Parse a function body.
    * <pre>
    * functionBody ::=
    * '=>' expression ';'
    * | block
    * functionExpressionBody ::=
    * '=>' expression
    * | block
    * </pre>
-   * @param mayBeEmpty {@code true} if the function body is allowed to be empty
+   * @param mayBeEmpty `true` if the function body is allowed to be empty
    * @param emptyErrorCode the error code to report if function body expecte, but not found
-   * @param inExpression {@code true} if the function body is being parsed as part of an expression
+   * @param inExpression `true` if the function body is being parsed as part of an expression
    * and therefore does not have a terminating semicolon
    * @return the function body that was parsed
    */
   FunctionBody parseFunctionBody(bool mayBeEmpty, ParserErrorCode emptyErrorCode, bool inExpression) {
     bool wasInLoop = _inLoop;
     bool wasInSwitch = _inSwitch;
     _inLoop = false;
     _inSwitch = false;
     try {
       if (matches5(TokenType.SEMICOLON)) {
@@ skipping 30 matching lines @@
 
   /**
    * Parse a function declaration.
    * <pre>
    * functionDeclaration ::=
    * functionSignature functionBody
    * | returnType? getOrSet identifier formalParameterList functionBody
    * </pre>
    * @param commentAndMetadata the documentation comment and metadata to be associated with the
    * declaration
-   * @param externalKeyword the 'external' keyword, or {@code null} if the function is not external
-   * @param returnType the return type, or {@code null} if there is no return type
-   * @param isStatement {@code true} if the function declaration is being parsed as a statement
+   * @param externalKeyword the 'external' keyword, or `null` if the function is not external
+   * @param returnType the return type, or `null` if there is no return type
+   * @param isStatement `true` if the function declaration is being parsed as a statement
    * @return the function declaration that was parsed
    */
   FunctionDeclaration parseFunctionDeclaration(CommentAndMetadata commentAndMetadata, Token externalKeyword, TypeName returnType) {
     Token keyword = null;
     bool isGetter = false;
     if (matches(Keyword.GET) && !matches4(peek(), TokenType.OPEN_PAREN)) {
       keyword = andAdvance;
       isGetter = true;
     } else if (matches(Keyword.SET) && !matches4(peek(), TokenType.OPEN_PAREN)) {
       keyword = andAdvance;
@@ skipping 31 matching lines @@
   Statement parseFunctionDeclarationStatement() => parseFunctionDeclarationStatement2(parseCommentAndMetadata(), parseOptionalReturnType());
 
   /**
    * Parse a function declaration statement.
    * <pre>
    * functionDeclarationStatement ::=
    * functionSignature functionBody
    * </pre>
    * @param commentAndMetadata the documentation comment and metadata to be associated with the
    * declaration
-   * @param returnType the return type, or {@code null} if there is no return type
+   * @param returnType the return type, or `null` if there is no return type
    * @return the function declaration statement that was parsed
    */
   Statement parseFunctionDeclarationStatement2(CommentAndMetadata commentAndMetadata, TypeName returnType) => new FunctionDeclarationStatement.full(parseFunctionDeclaration(commentAndMetadata, null, returnType));
 
   /**
    * Parse a function expression.
    * <pre>
    * functionExpression ::=
    * formalParameterList functionExpressionBody
    * </pre>
@@ skipping 47 matching lines @@
    * Parse a getter.
    * <pre>
    * getter ::=
    * getterSignature functionBody?
    * getterSignature ::=
    * 'external'? 'static'? returnType? 'get' identifier
    * </pre>
    * @param commentAndMetadata the documentation comment and metadata to be associated with the
    * declaration
    * @param externalKeyword the 'external' token
-   * @param staticKeyword the static keyword, or {@code null} if the getter is not static
-   * @param the return type that has already been parsed, or {@code null} if there was no return
+   * @param staticKeyword the static keyword, or `null` if the getter is not static
+   * @param the return type that has already been parsed, or `null` if there was no return
    * type
    * @return the getter that was parsed
    */
   MethodDeclaration parseGetter(CommentAndMetadata commentAndMetadata, Token externalKeyword, Token staticKeyword, TypeName returnType) {
     Token propertyKeyword = expect(Keyword.GET);
     SimpleIdentifier name = parseSimpleIdentifier();
     if (matches5(TokenType.OPEN_PAREN) && matches4(peek(), TokenType.CLOSE_PAREN)) {
       reportError7(ParserErrorCode.GETTER_WITH_PARAMETERS, []);
       advance();
       advance();
@@ skipping 93 matching lines @@
    * ?? ::=
    * 'static'? ('var' | type) initializedIdentifierList ';'
    * | 'final' type? initializedIdentifierList ';'
    * initializedIdentifierList ::=
    * initializedIdentifier (',' initializedIdentifier)
    * initializedIdentifier ::=
    * identifier ('=' expression)?
    * </pre>
    * @param commentAndMetadata the documentation comment and metadata to be associated with the
    * declaration
-   * @param staticKeyword the static keyword, or {@code null} if the getter is not static
-   * @param keyword the token representing the 'final', 'const' or 'var' keyword, or {@code null} if
+   * @param staticKeyword the static keyword, or `null` if the getter is not static
+   * @param keyword the token representing the 'final', 'const' or 'var' keyword, or `null` if
    * there is no keyword
-   * @param type the type that has already been parsed, or {@code null} if 'var' was provided
+   * @param type the type that has already been parsed, or `null` if 'var' was provided
    * @return the getter that was parsed
    */
   FieldDeclaration parseInitializedIdentifierList(CommentAndMetadata commentAndMetadata, Token staticKeyword, Token keyword, TypeName type) {
     VariableDeclarationList fieldList = parseVariableDeclarationList2(null, keyword, type);
     return new FieldDeclaration.full(commentAndMetadata.comment, commentAndMetadata.metadata, staticKeyword, fieldList, expect2(TokenType.SEMICOLON));
   }
 
   /**
    * Parse an instance creation expression.
    * <pre>
@@ skipping 67 matching lines @@
     components.add(createSyntheticIdentifier());
     return new LibraryIdentifier.full(components);
   }
 
   /**
    * Parse a list literal.
    * <pre>
    * listLiteral ::=
    * 'const'? typeArguments? '\[' (expressionList ','?)? '\]'
    * </pre>
-   * @param modifier the 'const' modifier appearing before the literal, or {@code null} if there is
+   * @param modifier the 'const' modifier appearing before the literal, or `null` if there is
    * no modifier
-   * @param typeArguments the type arguments appearing before the literal, or {@code null} if there
+   * @param typeArguments the type arguments appearing before the literal, or `null` if there
    * are no type arguments
    * @return the list literal that was parsed
    */
   ListLiteral parseListLiteral(Token modifier, TypeArgumentList typeArguments) {
     if (matches5(TokenType.INDEX)) {
       BeginToken leftBracket = new BeginToken(TokenType.OPEN_SQUARE_BRACKET, _currentToken.offset);
       Token rightBracket = new Token(TokenType.CLOSE_SQUARE_BRACKET, _currentToken.offset + 1);
       leftBracket.endToken = rightBracket;
       rightBracket.setNext(_currentToken.next);
       leftBracket.setNext(rightBracket);
@@ skipping 17 matching lines @@
     return new ListLiteral.full(modifier, typeArguments, leftBracket, elements, rightBracket);
   }
 
   /**
    * Parse a list or map literal.
    * <pre>
    * listOrMapLiteral ::=
    * listLiteral
    * | mapLiteral
    * </pre>
-   * @param modifier the 'const' modifier appearing before the literal, or {@code null} if there is
+   * @param modifier the 'const' modifier appearing before the literal, or `null` if there is
    * no modifier
    * @return the list or map literal that was parsed
    */
   TypedLiteral parseListOrMapLiteral(Token modifier) {
     TypeArgumentList typeArguments = null;
     if (matches5(TokenType.LT)) {
       typeArguments = parseTypeArgumentList();
     }
     if (matches5(TokenType.OPEN_CURLY_BRACKET)) {
       return parseMapLiteral(modifier, typeArguments);
@@ skipping 37 matching lines @@
     }
     return expression;
   }
 
   /**
    * Parse a map literal.
    * <pre>
    * mapLiteral ::=
    * 'const'? typeArguments? '{' (mapLiteralEntry (',' mapLiteralEntry)* ','?)? '}'
    * </pre>
-   * @param modifier the 'const' modifier appearing before the literal, or {@code null} if there is
+   * @param modifier the 'const' modifier appearing before the literal, or `null` if there is
    * no modifier
-   * @param typeArguments the type arguments that were declared, or {@code null} if there are no
+   * @param typeArguments the type arguments that were declared, or `null` if there are no
    * type arguments
    * @return the map literal that was parsed
    */
   MapLiteral parseMapLiteral(Token modifier, TypeArgumentList typeArguments) {
     if (typeArguments != null) {
       int num = typeArguments.arguments.length;
       if (num != 2) {
         reportError(ParserErrorCode.EXPECTED_TWO_MAP_TYPE_ARGUMENTS, typeArguments, [num]);
       }
     }
@@ skipping 31 matching lines @@
   /**
    * Parse a method declaration.
    * <pre>
    * functionDeclaration ::=
    * 'external'? 'static'? functionSignature functionBody
    * | 'external'? functionSignature ';'
    * </pre>
    * @param commentAndMetadata the documentation comment and metadata to be associated with the
    * declaration
    * @param externalKeyword the 'external' token
-   * @param staticKeyword the static keyword, or {@code null} if the getter is not static
+   * @param staticKeyword the static keyword, or `null` if the getter is not static
    * @param returnType the return type of the method
    * @return the method declaration that was parsed
    */
   MethodDeclaration parseMethodDeclaration(CommentAndMetadata commentAndMetadata, Token externalKeyword, Token staticKeyword, TypeName returnType) {
     SimpleIdentifier methodName = parseSimpleIdentifier();
     FormalParameterList parameters = parseFormalParameterList();
     validateFormalParameterList(parameters);
     return parseMethodDeclaration2(commentAndMetadata, externalKeyword, staticKeyword, returnType, methodName, parameters);
   }
 
   /**
    * Parse a method declaration.
    * <pre>
    * functionDeclaration ::=
    * ('external' 'static'?)? functionSignature functionBody
    * | 'external'? functionSignature ';'
    * </pre>
    * @param commentAndMetadata the documentation comment and metadata to be associated with the
    * declaration
    * @param externalKeyword the 'external' token
-   * @param staticKeyword the static keyword, or {@code null} if the getter is not static
+   * @param staticKeyword the static keyword, or `null` if the getter is not static
    * @param returnType the return type of the method
    * @param name the name of the method
    * @param parameters the parameters to the method
    * @return the method declaration that was parsed
    */
   MethodDeclaration parseMethodDeclaration2(CommentAndMetadata commentAndMetadata, Token externalKeyword, Token staticKeyword, TypeName returnType, SimpleIdentifier name, FormalParameterList parameters) {
     FunctionBody body = parseFunctionBody(externalKeyword != null || staticKeyword == null, ParserErrorCode.MISSING_FUNCTION_BODY, false);
     if (externalKeyword != null) {
       if (body is! EmptyFunctionBody) {
         reportError(ParserErrorCode.EXTERNAL_METHOD_WITH_BODY, body, []);
       }
     } else if (staticKeyword != null) {
       if (body is EmptyFunctionBody) {
         reportError(ParserErrorCode.ABSTRACT_STATIC_METHOD, body, []);
       }
     }
     return new MethodDeclaration.full(commentAndMetadata.comment, commentAndMetadata.metadata, externalKeyword, staticKeyword, returnType, null, null, name, parameters, body);
   }
 
   /**
    * Parse the modifiers preceding a declaration. This method allows the modifiers to appear in any
    * order but does generate errors for duplicated modifiers. Checks for other problems, such as
    * having the modifiers appear in the wrong order or specifying both 'const' and 'final', are
-   * reported in one of the methods whose name is prefixed with {@code validateModifiersFor}.
+   * reported in one of the methods whose name is prefixed with `validateModifiersFor`.
    * <pre>
    * modifiers ::=
    * ('abstract' | 'const' | 'external' | 'factory' | 'final' | 'static' | 'var')
    * </pre>
    * @return the modifiers that were parsed
    */
   Modifiers parseModifiers() {
     Modifiers modifiers = new Modifiers();
     bool progress = true;
     while (progress) {
@@ skipping 240 matching lines @@
    * Parse an operator declaration.
    * <pre>
    * operatorDeclaration ::=
    * operatorSignature (';' | functionBody)
    * operatorSignature ::=
    * 'external'? returnType? 'operator' operator formalParameterList
    * </pre>
    * @param commentAndMetadata the documentation comment and metadata to be associated with the
    * declaration
    * @param externalKeyword the 'external' token
-   * @param the return type that has already been parsed, or {@code null} if there was no return
+   * @param the return type that has already been parsed, or `null` if there was no return
    * type
    * @return the operator declaration that was parsed
    */
   MethodDeclaration parseOperator(CommentAndMetadata commentAndMetadata, Token externalKeyword, TypeName returnType) {
     Token operatorKeyword;
     if (matches(Keyword.OPERATOR)) {
       operatorKeyword = andAdvance;
     } else {
       reportError8(ParserErrorCode.MISSING_KEYWORD_OPERATOR, _currentToken, []);
       operatorKeyword = createSyntheticToken(Keyword.OPERATOR);
@@ skipping 12 matching lines @@
     FormalParameterList parameters = parseFormalParameterList();
     validateFormalParameterList(parameters);
     FunctionBody body = parseFunctionBody(true, ParserErrorCode.MISSING_FUNCTION_BODY, false);
     if (externalKeyword != null && body is! EmptyFunctionBody) {
       reportError7(ParserErrorCode.EXTERNAL_OPERATOR_WITH_BODY, []);
     }
     return new MethodDeclaration.full(commentAndMetadata.comment, commentAndMetadata.metadata, externalKeyword, null, returnType, null, operatorKeyword, name, parameters, body);
   }
 
   /**
-   * Parse a return type if one is given, otherwise return {@code null} without advancing.
+   * Parse a return type if one is given, otherwise return `null` without advancing.
    * @return the return type that was parsed
    */
   TypeName parseOptionalReturnType() {
     if (matches(Keyword.VOID)) {
       return parseReturnType();
     } else if (matchesIdentifier() && !matches(Keyword.GET) && !matches(Keyword.SET) && !matches(Keyword.OPERATOR) && (matchesIdentifier2(peek()) || matches4(peek(), TokenType.LT))) {
       return parseReturnType();
     } else if (matchesIdentifier() && matches4(peek(), TokenType.PERIOD) && matchesIdentifier2(peek2(2)) && (matchesIdentifier2(peek2(3)) || matches4(peek2(3), TokenType.LT))) {
       return parseReturnType();
     }
@@ skipping 277 matching lines @@
    * Parse a setter.
    * <pre>
    * setter ::=
    * setterSignature functionBody?
    * setterSignature ::=
    * 'external'? 'static'? returnType? 'set' identifier formalParameterList
    * </pre>
    * @param commentAndMetadata the documentation comment and metadata to be associated with the
    * declaration
    * @param externalKeyword the 'external' token
-   * @param staticKeyword the static keyword, or {@code null} if the setter is not static
-   * @param the return type that has already been parsed, or {@code null} if there was no return
+   * @param staticKeyword the static keyword, or `null` if the setter is not static
+   * @param the return type that has already been parsed, or `null` if there was no return
    * type
    * @return the setter that was parsed
    */
   MethodDeclaration parseSetter(CommentAndMetadata commentAndMetadata, Token externalKeyword, Token staticKeyword, TypeName returnType) {
     Token propertyKeyword = expect(Keyword.SET);
     SimpleIdentifier name = parseSimpleIdentifier();
     FormalParameterList parameters = parseFormalParameterList();
     validateFormalParameterList(parameters);
     FunctionBody body = parseFunctionBody(externalKeyword != null || staticKeyword == null, ParserErrorCode.STATIC_SETTER_WITHOUT_BODY, false);
     if (externalKeyword != null && body is! EmptyFunctionBody) {
@@ skipping 528 matching lines @@
     FinalConstVarOrType holder = parseFinalConstVarOrType(false);
     return parseVariableDeclarationList2(commentAndMetadata, holder.keyword, holder.type);
   }
 
   /**
    * Parse a variable declaration list.
    * <pre>
    * variableDeclarationList ::=
    * finalConstVarOrType variableDeclaration (',' variableDeclaration)
    * </pre>
-   * @param commentAndMetadata the metadata to be associated with the variable declaration list, or{@code null} if there is no attempt at parsing the comment and metadata
-   * @param keyword the token representing the 'final', 'const' or 'var' keyword, or {@code null} if
+   * @param commentAndMetadata the metadata to be associated with the variable declaration list, or`null` if there is no attempt at parsing the comment and metadata
+   * @param keyword the token representing the 'final', 'const' or 'var' keyword, or `null` if
    * there is no keyword
    * @param type the type of the variables in the list
    * @return the variable declaration list that was parsed
    */
   VariableDeclarationList parseVariableDeclarationList2(CommentAndMetadata commentAndMetadata, Token keyword, TypeName type) {
     List<VariableDeclaration> variables = new List<VariableDeclaration>();
     variables.add(parseVariableDeclaration());
     while (matches5(TokenType.COMMA)) {
       advance();
       variables.add(parseVariableDeclaration());
     }
     return new VariableDeclarationList.full(commentAndMetadata != null ? commentAndMetadata.comment : null, commentAndMetadata != null ? commentAndMetadata.metadata : null, keyword, type, variables);
   }
 
   /**
    * Parse a variable declaration statement.
    * <pre>
    * variableDeclarationStatement ::=
    * variableDeclarationList ';'
    * </pre>
    * @param commentAndMetadata the metadata to be associated with the variable declaration
-   * statement, or {@code null} if there is no attempt at parsing the comment and metadata
+   * statement, or `null` if there is no attempt at parsing the comment and metadata
    * @return the variable declaration statement that was parsed
    */
   VariableDeclarationStatement parseVariableDeclarationStatement(CommentAndMetadata commentAndMetadata) {
     VariableDeclarationList variableList = parseVariableDeclarationList(commentAndMetadata);
     Token semicolon = expect2(TokenType.SEMICOLON);
     return new VariableDeclarationStatement.full(variableList, semicolon);
   }
 
   /**
    * Parse a variable declaration statement.
    * <pre>
    * variableDeclarationStatement ::=
    * variableDeclarationList ';'
    * </pre>
    * @param commentAndMetadata the metadata to be associated with the variable declaration
-   * statement, or {@code null} if there is no attempt at parsing the comment and metadata
-   * @param keyword the token representing the 'final', 'const' or 'var' keyword, or {@code null} if
+   * statement, or `null` if there is no attempt at parsing the comment and metadata
+   * @param keyword the token representing the 'final', 'const' or 'var' keyword, or `null` if
    * there is no keyword
    * @param type the type of the variables in the list
    * @return the variable declaration statement that was parsed
    */
   VariableDeclarationStatement parseVariableDeclarationStatement2(CommentAndMetadata commentAndMetadata, Token keyword, TypeName type) {
     VariableDeclarationList variableList = parseVariableDeclarationList2(commentAndMetadata, keyword, type);
     Token semicolon = expect2(TokenType.SEMICOLON);
     return new VariableDeclarationStatement.full(variableList, semicolon);
   }
 
@@ skipping 32 matching lines @@
     Token with2 = expect(Keyword.WITH);
     List<TypeName> types = new List<TypeName>();
     types.add(parseTypeName());
     while (optional(TokenType.COMMA)) {
       types.add(parseTypeName());
     }
     return new WithClause.full(with2, types);
   }
 
   /**
-   * Return the token that is immediately after the current token. This is equivalent to{@link #peek(int) peek(1)}.
+   * Return the token that is immediately after the current token. This is equivalent to[peek].
    * @return the token that is immediately after the current token
    */
   Token peek() => _currentToken.next;
 
   /**
    * Return the token that is the given distance after the current token.
-   * @param distance the number of tokens to look ahead, where {@code 0} is the current token,{@code 1} is the next token, etc.
+   * @param distance the number of tokens to look ahead, where `0` is the current token,`1` is the next token, etc.
    * @return the token that is the given distance after the current token
    */
   Token peek2(int distance) {
     Token token = _currentToken;
     for (int i = 0; i < distance; i++) {
       token = token.next;
     }
     return token;
   }
 
@@ skipping 22 matching lines @@
    * @param token the token specifying the location of the error
    * @param arguments the arguments to the error, used to compose the error message
    */
   void reportError8(ParserErrorCode errorCode, Token token, List<Object> arguments) {
     _errorListener.onError(new AnalysisError.con2(_source, token.offset, token.length, errorCode, arguments));
   }
 
   /**
    * Parse the 'final', 'const', 'var' or type preceding a variable declaration, starting at the
    * given token, without actually creating a type or changing the current token. Return the token
-   * following the type that was parsed, or {@code null} if the given token is not the first token
+   * following the type that was parsed, or `null` if the given token is not the first token
    * in a valid type.
    * <pre>
    * finalConstVarOrType ::=
    * | 'final' type?
    * | 'const' type?
    * | 'var'
    * | type
    * </pre>
    * @param startToken the token at which parsing is to begin
    * @return the token following the type that was parsed
@@ skipping 11 matching lines @@
       if (matchesIdentifier2(next) || matches4(next, TokenType.LT) || matches3(next, Keyword.THIS) || (matches4(next, TokenType.PERIOD) && matchesIdentifier2(next.next) && (matchesIdentifier2(next.next.next) || matches4(next.next.next, TokenType.LT) || matches3(next.next.next, Keyword.THIS)))) {
         return skipReturnType(startToken);
       }
     }
     return null;
   }
 
   /**
    * Parse a list of formal parameters, starting at the given token, without actually creating a
    * formal parameter list or changing the current token. Return the token following the formal
-   * parameter list that was parsed, or {@code null} if the given token is not the first token in a
+   * parameter list that was parsed, or `null` if the given token is not the first token in a
    * valid list of formal parameter.
-   * <p>
+   *
    * Note that unlike other skip methods, this method uses a heuristic. In the worst case, the
    * parameters could be prefixed by metadata, which would require us to be able to skip arbitrary
    * expressions. Rather than duplicate the logic of most of the parse methods we simply look for
    * something that is likely to be a list of parameters and then skip to returning the token after
    * the closing parenthesis.
-   * <p>
-   * This method must be kept in sync with {@link #parseFormalParameterList()}.
+   *
+   * This method must be kept in sync with [parseFormalParameterList].
    * <pre>
    * formalParameterList ::=
    * '(' ')'
    * | '(' normalFormalParameters (',' optionalFormalParameters)? ')'
    * | '(' optionalFormalParameters ')'
    * normalFormalParameters ::=
    * normalFormalParameter (',' normalFormalParameter)
    * optionalFormalParameters ::=
    * optionalPositionalFormalParameters
    * | namedFormalParameters
@@ skipping 27 matching lines @@
       return null;
     }
     if (skipSimpleIdentifier(afterType) == null) {
       return null;
     }
     return skipPastMatchingToken(startToken);
   }
 
   /**
    * If the given token is a begin token with an associated end token, then return the token
-   * following the end token. Otherwise, return {@code null}.
+   * following the end token. Otherwise, return `null`.
    * @param startToken the token that is assumed to be a being token
    * @return the token following the matching end token
    */
   Token skipPastMatchingToken(Token startToken) {
     if (startToken is! BeginToken) {
       return null;
     }
     Token closeParen = ((startToken as BeginToken)).endToken;
     if (closeParen == null) {
       return null;
     }
     return closeParen.next;
   }
 
   /**
    * Parse a prefixed identifier, starting at the given token, without actually creating a prefixed
    * identifier or changing the current token. Return the token following the prefixed identifier
-   * that was parsed, or {@code null} if the given token is not the first token in a valid prefixed
+   * that was parsed, or `null` if the given token is not the first token in a valid prefixed
    * identifier.
-   * <p>
-   * This method must be kept in sync with {@link #parsePrefixedIdentifier()}.
+   *
+   * This method must be kept in sync with [parsePrefixedIdentifier].
    * <pre>
    * prefixedIdentifier ::=
    * identifier ('.' identifier)?
    * </pre>
    * @param startToken the token at which parsing is to begin
    * @return the token following the prefixed identifier that was parsed
    */
   Token skipPrefixedIdentifier(Token startToken) {
     Token token = skipSimpleIdentifier(startToken);
     if (token == null) {
       return null;
     } else if (!matches4(token, TokenType.PERIOD)) {
       return token;
     }
     return skipSimpleIdentifier(token.next);
   }
 
   /**
    * Parse a return type, starting at the given token, without actually creating a return type or
-   * changing the current token. Return the token following the return type that was parsed, or{@code null} if the given token is not the first token in a valid return type.
-   * <p>
-   * This method must be kept in sync with {@link #parseReturnType()}.
+   * changing the current token. Return the token following the return type that was parsed, or`null` if the given token is not the first token in a valid return type.
+   *
+   * This method must be kept in sync with [parseReturnType].
    * <pre>
    * returnType ::=
    * 'void'
    * | type
    * </pre>
    * @param startToken the token at which parsing is to begin
    * @return the token following the return type that was parsed
    */
   Token skipReturnType(Token startToken) {
     if (matches3(startToken, Keyword.VOID)) {
       return startToken.next;
     } else {
       return skipTypeName(startToken);
     }
   }
 
   /**
    * Parse a simple identifier, starting at the given token, without actually creating a simple
    * identifier or changing the current token. Return the token following the simple identifier that
-   * was parsed, or {@code null} if the given token is not the first token in a valid simple
+   * was parsed, or `null` if the given token is not the first token in a valid simple
    * identifier.
-   * <p>
-   * This method must be kept in sync with {@link #parseSimpleIdentifier()}.
+   *
+   * This method must be kept in sync with [parseSimpleIdentifier].
    * <pre>
    * identifier ::=
    * IDENTIFIER
    * </pre>
    * @param startToken the token at which parsing is to begin
    * @return the token following the simple identifier that was parsed
    */
   Token skipSimpleIdentifier(Token startToken) {
     if (matches4(startToken, TokenType.IDENTIFIER) || (matches4(startToken, TokenType.KEYWORD) && ((startToken as KeywordToken)).keyword.isPseudoKeyword())) {
       return startToken.next;
     }
     return null;
   }
 
   /**
    * Parse a string literal that contains interpolations, starting at the given token, without
    * actually creating a string literal or changing the current token. Return the token following
-   * the string literal that was parsed, or {@code null} if the given token is not the first token
+   * the string literal that was parsed, or `null` if the given token is not the first token
    * in a valid string literal.
-   * <p>
-   * This method must be kept in sync with {@link #parseStringInterpolation(Token)}.
+   *
+   * This method must be kept in sync with [parseStringInterpolation].
    * @param startToken the token at which parsing is to begin
    * @return the string literal that was parsed
    */
   Token skipStringInterpolation(Token startToken) {
     Token token = startToken;
     TokenType type = token.type;
     while (identical(type, TokenType.STRING_INTERPOLATION_EXPRESSION) || identical(type, TokenType.STRING_INTERPOLATION_IDENTIFIER)) {
       if (identical(type, TokenType.STRING_INTERPOLATION_EXPRESSION)) {
         token = token.next;
         type = token.type;
@@ skipping 29 matching lines @@
         token = token.next;
         type = token.type;
       }
     }
     return token;
   }
 
   /**
    * Parse a string literal, starting at the given token, without actually creating a string literal
    * or changing the current token. Return the token following the string literal that was parsed,
-   * or {@code null} if the given token is not the first token in a valid string literal.
-   * <p>
-   * This method must be kept in sync with {@link #parseStringLiteral()}.
+   * or `null` if the given token is not the first token in a valid string literal.
+   *
+   * This method must be kept in sync with [parseStringLiteral].
    * <pre>
    * stringLiteral ::=
    * MULTI_LINE_STRING+
    * | SINGLE_LINE_STRING+
    * </pre>
    * @param startToken the token at which parsing is to begin
    * @return the token following the string literal that was parsed
    */
   Token skipStringLiteral(Token startToken) {
     Token token = startToken;
     while (token != null && matches4(token, TokenType.STRING)) {
       token = token.next;
       TokenType type = token.type;
       if (identical(type, TokenType.STRING_INTERPOLATION_EXPRESSION) || identical(type, TokenType.STRING_INTERPOLATION_IDENTIFIER)) {
         token = skipStringInterpolation(token);
       }
     }
     if (identical(token, startToken)) {
       return null;
     }
     return token;
   }
 
   /**
    * Parse a list of type arguments, starting at the given token, without actually creating a type argument list
    * or changing the current token. Return the token following the type argument list that was parsed,
-   * or {@code null} if the given token is not the first token in a valid type argument list.
-   * <p>
-   * This method must be kept in sync with {@link #parseTypeArgumentList()}.
+   * or `null` if the given token is not the first token in a valid type argument list.
+   *
+   * This method must be kept in sync with [parseTypeArgumentList].
    * <pre>
    * typeArguments ::=
    * '<' typeList '>'
    * typeList ::=
    * type (',' type)
    * </pre>
    * @param startToken the token at which parsing is to begin
    * @return the token following the type argument list that was parsed
    */
   Token skipTypeArgumentList(Token startToken) {
@@ skipping 16 matching lines @@
     } else if (identical(token.type, TokenType.GT_GT)) {
       Token second = new Token(TokenType.GT, token.offset + 1);
       second.setNextWithoutSettingPrevious(token.next);
       return second;
     }
     return null;
   }
 
   /**
    * Parse a type name, starting at the given token, without actually creating a type name or
-   * changing the current token. Return the token following the type name that was parsed, or{@code null} if the given token is not the first token in a valid type name.
-   * <p>
-   * This method must be kept in sync with {@link #parseTypeName()}.
+   * changing the current token. Return the token following the type name that was parsed, or`null` if the given token is not the first token in a valid type name.
+   *
+   * This method must be kept in sync with [parseTypeName].
    * <pre>
    * type ::=
    * qualified typeArguments?
    * </pre>
    * @param startToken the token at which parsing is to begin
    * @return the token following the type name that was parsed
    */
   Token skipTypeName(Token startToken) {
     Token token = skipPrefixedIdentifier(startToken);
     if (token == null) {
       return null;
     }
     if (matches4(token, TokenType.LT)) {
       token = skipTypeArgumentList(token);
     }
     return token;
   }
 
   /**
    * Parse a list of type parameters, starting at the given token, without actually creating a type
    * parameter list or changing the current token. Return the token following the type parameter
-   * list that was parsed, or {@code null} if the given token is not the first token in a valid type
+   * list that was parsed, or `null` if the given token is not the first token in a valid type
    * parameter list.
-   * <p>
-   * This method must be kept in sync with {@link #parseTypeParameterList()}.
+   *
+   * This method must be kept in sync with [parseTypeParameterList].
    * <pre>
    * typeParameterList ::=
    * '<' typeParameter (',' typeParameter)* '>'
    * </pre>
    * @param startToken the token at which parsing is to begin
    * @return the token following the type parameter list that was parsed
    */
   Token skipTypeParameterList(Token startToken) {
     if (!matches4(startToken, TokenType.LT)) {
       return null;
@@ skipping 391 matching lines @@
   int get length => 0;
 }
 class AnalysisErrorListener_11 implements AnalysisErrorListener {
   List<bool> errorFound;
   AnalysisErrorListener_11(this.errorFound);
   void onError(AnalysisError error) {
     errorFound[0] = true;
   }
 }
 /**
- * The enumeration {@code ParserErrorCode} defines the error codes used for errors detected by the
+ * The enumeration `ParserErrorCode` defines the error codes used for errors detected by the
  * parser. The convention for this class is for the name of the error code to indicate the problem
  * that caused the error to be generated and for the error message to explain what is wrong and,
  * when appropriate, how the problem can be corrected.
  * @coverage dart.engine.parser
  */
 class ParserErrorCode implements Comparable<ParserErrorCode>, ErrorCode {
   static final ParserErrorCode ABSTRACT_CLASS_MEMBER = new ParserErrorCode.con2('ABSTRACT_CLASS_MEMBER', 0, "Members of classes cannot be declared to be 'abstract'");
   static final ParserErrorCode ABSTRACT_STATIC_METHOD = new ParserErrorCode.con2('ABSTRACT_STATIC_METHOD', 1, "Static methods cannot be declared to be 'abstract'");
   static final ParserErrorCode ABSTRACT_TOP_LEVEL_FUNCTION = new ParserErrorCode.con2('ABSTRACT_TOP_LEVEL_FUNCTION', 2, "Top-level functions cannot be declared to be 'abstract'");
   static final ParserErrorCode ABSTRACT_TOP_LEVEL_VARIABLE = new ParserErrorCode.con2('ABSTRACT_TOP_LEVEL_VARIABLE', 3, "Top-level variables cannot be declared to be 'abstract'");
@@ skipping 1049 matching lines @@
         for (int i = 0; i < size; i++) {
           if (i > 0) {
             _writer.print(separator);
           }
           nodes[i].accept(this);
         }
       }
     }
   }
 }