New analyzer_experimental snapshot.

pkg/analyzer_experimental/test/generated/parser_test.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_test;
 import 'dart:collection';
 import 'package:analyzer_experimental/src/generated/java_core.dart';
 import 'package:analyzer_experimental/src/generated/java_engine.dart';
 import 'package:analyzer_experimental/src/generated/java_junit.dart';
 import 'package:analyzer_experimental/src/generated/source.dart';
 import 'package:analyzer_experimental/src/generated/error.dart';
 import 'package:analyzer_experimental/src/generated/scanner.dart';
 import 'package:analyzer_experimental/src/generated/ast.dart';
 import 'package:analyzer_experimental/src/generated/parser.dart';
 import 'package:analyzer_experimental/src/generated/utilities_dart.dart';
 import 'package:unittest/unittest.dart' as _ut;
 import 'test_support.dart';
 import 'scanner_test.dart' show TokenFactory;
 import 'ast_test.dart' show ASTFactory;
 /**
- * The class {@code SimpleParserTest} defines parser tests that test individual parsing method. The
+ * The class `SimpleParserTest` defines parser tests that test individual parsing method. The
  * code fragments should be as minimal as possible in order to test the method, but should not test
  * the interactions between the method under test and other methods.
- * <p>
- * More complex tests should be defined in the class {@link ComplexParserTest}.
+ *
+ * More complex tests should be defined in the class [ComplexParserTest].
  */
 class SimpleParserTest extends ParserTestCase {
   void fail_parseCommentReference_this() {
     CommentReference reference = ParserTestCase.parse("parseCommentReference", <Object> ["this", 5], "");
     SimpleIdentifier identifier = EngineTestCase.assertInstanceOf(SimpleIdentifier, reference.identifier);
     JUnitTestCase.assertNotNull(identifier.token);
     JUnitTestCase.assertEquals("a", identifier.name);
     JUnitTestCase.assertEquals(5, identifier.offset);
   }
   void test_computeStringValue_emptyInterpolationPrefix() {
@@ skipping 3627 matching lines @@
     JUnitTestCase.assertNotNull(following);
     JUnitTestCase.assertEquals(TokenType.PLUS, following.type);
   }
   void test_skipTypeName_simple() {
     Token following = skip("skipTypeName", "C +");
     JUnitTestCase.assertNotNull(following);
     JUnitTestCase.assertEquals(TokenType.PLUS, following.type);
   }
 
   /**
-   * Invoke the method {@link Parser#computeStringValue(String)} with the given argument.
+   * Invoke the method [Parser#computeStringValue] with the given argument.
    * @param lexeme the argument to the method
    * @return the result of invoking the method
    * @throws Exception if the method could not be invoked or throws an exception
    */
   String computeStringValue(String lexeme) {
     AnalysisErrorListener listener = new AnalysisErrorListener_19();
     Parser parser = new Parser(null, listener);
     return invokeParserMethodImpl(parser, "computeStringValue", <Object> [lexeme], null) as String;
   }
 
   /**
-   * Invoke the method {@link Parser#createSyntheticIdentifier()} with the parser set to the token
+   * Invoke the method [Parser#createSyntheticIdentifier] with the parser set to the token
    * stream produced by scanning the given source.
    * @param source the source to be scanned to produce the token stream being tested
    * @return the result of invoking the method
    * @throws Exception if the method could not be invoked or throws an exception
    */
   SimpleIdentifier createSyntheticIdentifier() {
     GatheringErrorListener listener = new GatheringErrorListener();
     return ParserTestCase.invokeParserMethod2("createSyntheticIdentifier", "", listener);
   }
 
   /**
-   * Invoke the method {@link Parser#createSyntheticIdentifier()} with the parser set to the token
+   * Invoke the method [Parser#createSyntheticIdentifier] with the parser set to the token
    * stream produced by scanning the given source.
    * @param source the source to be scanned to produce the token stream being tested
    * @return the result of invoking the method
    * @throws Exception if the method could not be invoked or throws an exception
    */
   SimpleStringLiteral createSyntheticStringLiteral() {
     GatheringErrorListener listener = new GatheringErrorListener();
     return ParserTestCase.invokeParserMethod2("createSyntheticStringLiteral", "", listener);
   }
 
   /**
-   * Invoke the method {@link Parser#isFunctionDeclaration()} with the parser set to the token
+   * Invoke the method [Parser#isFunctionDeclaration] with the parser set to the token
    * stream produced by scanning the given source.
    * @param source the source to be scanned to produce the token stream being tested
    * @return the result of invoking the method
    * @throws Exception if the method could not be invoked or throws an exception
    */
   bool isFunctionDeclaration(String source) {
     GatheringErrorListener listener = new GatheringErrorListener();
     return ParserTestCase.invokeParserMethod2("isFunctionDeclaration", source, listener) as bool;
   }
 
   /**
-   * Invoke the method {@link Parser#isFunctionExpression()} with the parser set to the token stream
+   * Invoke the method [Parser#isFunctionExpression] with the parser set to the token stream
    * produced by scanning the given source.
    * @param source the source to be scanned to produce the token stream being tested
    * @return the result of invoking the method
    * @throws Exception if the method could not be invoked or throws an exception
    */
   bool isFunctionExpression(String source) {
     GatheringErrorListener listener = new GatheringErrorListener();
     StringScanner scanner = new StringScanner(null, source, listener);
     Token tokenStream = scanner.tokenize();
     Parser parser = new Parser(null, listener);
     return invokeParserMethodImpl(parser, "isFunctionExpression", <Object> [tokenStream], tokenStream) as bool;
   }
 
   /**
-   * Invoke the method {@link Parser#isInitializedVariableDeclaration()} with the parser set to the
+   * Invoke the method [Parser#isInitializedVariableDeclaration] with the parser set to the
    * token stream produced by scanning the given source.
    * @param source the source to be scanned to produce the token stream being tested
    * @return the result of invoking the method
    * @throws Exception if the method could not be invoked or throws an exception
    */
   bool isInitializedVariableDeclaration(String source) {
     GatheringErrorListener listener = new GatheringErrorListener();
     return ParserTestCase.invokeParserMethod2("isInitializedVariableDeclaration", source, listener) as bool;
   }
 
   /**
-   * Invoke the method {@link Parser#isSwitchMember()} with the parser set to the token stream
+   * Invoke the method [Parser#isSwitchMember] with the parser set to the token stream
    * produced by scanning the given source.
    * @param source the source to be scanned to produce the token stream being tested
    * @return the result of invoking the method
    * @throws Exception if the method could not be invoked or throws an exception
    */
   bool isSwitchMember(String source) {
     GatheringErrorListener listener = new GatheringErrorListener();
     return ParserTestCase.invokeParserMethod2("isSwitchMember", source, listener) as bool;
   }
 
   /**
-   * Invoke a "skip" method in {@link Parser}. The method is assumed to take a token as it's
+   * Invoke a "skip" method in [Parser]. The method is assumed to take a token as it's
    * parameter and is given the first token in the scanned source.
    * @param methodName the name of the method that should be invoked
    * @param source the source to be processed by the method
    * @return the result of invoking the method
    * @throws Exception if the method could not be invoked or throws an exception
-   * @throws AssertionFailedError if the result is {@code null}
+   * @throws AssertionFailedError if the result is `null`
    */
   Token skip(String methodName, String source) {
     GatheringErrorListener listener = new GatheringErrorListener();
     StringScanner scanner = new StringScanner(null, source, listener);
     Token tokenStream = scanner.tokenize();
     Parser parser = new Parser(null, listener);
     return invokeParserMethodImpl(parser, methodName, <Object> [tokenStream], tokenStream) as Token;
   }
   static dartSuite() {
     _ut.group('SimpleParserTest', () {
@@ skipping 2071 matching lines @@
       });
     });
   }
 }
 class AnalysisErrorListener_19 implements AnalysisErrorListener {
   void onError(AnalysisError event) {
     JUnitTestCase.fail("Unexpected compilation error: ${event.message} (${event.offset}, ${event.length})");
   }
 }
 /**
- * The class {@code ComplexParserTest} defines parser tests that test the parsing of more complex
+ * The class `ComplexParserTest` defines parser tests that test the parsing of more complex
  * code fragments or the interactions between multiple parsing methods. For example, tests to ensure
  * that the precedence of operations is being handled correctly should be defined in this class.
- * <p>
- * Simpler tests should be defined in the class {@link SimpleParserTest}.
+ *
+ * Simpler tests should be defined in the class [SimpleParserTest].
  */
 class ComplexParserTest extends ParserTestCase {
   void test_additiveExpression_normal() {
     BinaryExpression expression = ParserTestCase.parseExpression("x + y - z", []);
     EngineTestCase.assertInstanceOf(BinaryExpression, expression.leftOperand);
   }
   void test_additiveExpression_noSpaces() {
     BinaryExpression expression = ParserTestCase.parseExpression("i+1", []);
     EngineTestCase.assertInstanceOf(SimpleIdentifier, expression.leftOperand);
     EngineTestCase.assertInstanceOf(IntegerLiteral, expression.rightOperand);
@@ skipping 385 matching lines @@
         runJUnitTest(__test, __test.test_shiftExpression_precedence_additive_right);
       });
       _ut.test('test_shiftExpression_super', () {
         final __test = new ComplexParserTest();
         runJUnitTest(__test, __test.test_shiftExpression_super);
       });
     });
   }
 }
 /**
- * Instances of the class {@code ASTValidator} are used to validate the correct construction of an
+ * Instances of the class `ASTValidator` are used to validate the correct construction of an
  * AST structure.
  */
 class ASTValidator extends GeneralizingASTVisitor<Object> {
 
   /**
    * A list containing the errors found while traversing the AST structure.
    */
   List<String> _errors = new List<String>();
 
   /**
@@ skipping 56 matching lines @@
   }
 }
 class ParserTestCase extends EngineTestCase {
 
   /**
    * An empty array of objects used as arguments to zero-argument methods.
    */
   static List<Object> _EMPTY_ARGUMENTS = new List<Object>(0);
 
   /**
-   * Invoke a parse method in {@link Parser}. The method is assumed to have the given number and
+   * Invoke a parse method in [Parser]. The method is assumed to have the given number and
    * type of parameters and will be invoked with the given arguments.
-   * <p>
+   *
    * The given source is scanned and the parser is initialized to start with the first token in the
    * source before the parse method is invoked.
    * @param methodName the name of the parse method that should be invoked to parse the source
    * @param objects the values of the arguments to the method
    * @param source the source to be parsed by the parse method
    * @return the result of invoking the method
    * @throws Exception if the method could not be invoked or throws an exception
-   * @throws AssertionFailedError if the result is {@code null} or if any errors are produced
+   * @throws AssertionFailedError if the result is `null` or if any errors are produced
    */
   static Object parse(String methodName, List<Object> objects, String source) => parse3(methodName, objects, source, new List<AnalysisError>(0));
 
   /**
-   * Invoke a parse method in {@link Parser}. The method is assumed to have the given number and
+   * Invoke a parse method in [Parser]. The method is assumed to have the given number and
    * type of parameters and will be invoked with the given arguments.
-   * <p>
+   *
    * The given source is scanned and the parser is initialized to start with the first token in the
    * source before the parse method is invoked.
    * @param methodName the name of the parse method that should be invoked to parse the source
    * @param objects the values of the arguments to the method
    * @param source the source to be parsed by the parse method
    * @param errorCodes the error codes of the errors that should be generated
    * @return the result of invoking the method
    * @throws Exception if the method could not be invoked or throws an exception
-   * @throws AssertionFailedError if the result is {@code null} or the errors produced while
+   * @throws AssertionFailedError if the result is `null` or the errors produced while
    * scanning and parsing the source do not match the expected errors
    */
   static Object parse3(String methodName, List<Object> objects, String source, List<AnalysisError> errors) {
     GatheringErrorListener listener = new GatheringErrorListener();
     Object result = invokeParserMethod(methodName, objects, source, listener);
     listener.assertErrors(errors);
     return result;
   }
 
   /**
-   * Invoke a parse method in {@link Parser}. The method is assumed to have the given number and
+   * Invoke a parse method in [Parser]. The method is assumed to have the given number and
    * type of parameters and will be invoked with the given arguments.
-   * <p>
+   *
    * The given source is scanned and the parser is initialized to start with the first token in the
    * source before the parse method is invoked.
    * @param methodName the name of the parse method that should be invoked to parse the source
    * @param objects the values of the arguments to the method
    * @param source the source to be parsed by the parse method
    * @param errorCodes the error codes of the errors that should be generated
    * @return the result of invoking the method
    * @throws Exception if the method could not be invoked or throws an exception
-   * @throws AssertionFailedError if the result is {@code null} or the errors produced while
+   * @throws AssertionFailedError if the result is `null` or the errors produced while
    * scanning and parsing the source do not match the expected errors
    */
   static Object parse4(String methodName, List<Object> objects, String source, List<ErrorCode> errorCodes) {
     GatheringErrorListener listener = new GatheringErrorListener();
     Object result = invokeParserMethod(methodName, objects, source, listener);
     listener.assertErrors2(errorCodes);
     return result;
   }
 
   /**
-   * Invoke a parse method in {@link Parser}. The method is assumed to have no arguments.
-   * <p>
+   * Invoke a parse method in [Parser]. The method is assumed to have no arguments.
+   *
    * The given source is scanned and the parser is initialized to start with the first token in the
    * source before the parse method is invoked.
    * @param methodName the name of the parse method that should be invoked to parse the source
    * @param source the source to be parsed by the parse method
    * @param errorCodes the error codes of the errors that should be generated
    * @return the result of invoking the method
    * @throws Exception if the method could not be invoked or throws an exception
-   * @throws AssertionFailedError if the result is {@code null} or the errors produced while
+   * @throws AssertionFailedError if the result is `null` or the errors produced while
    * scanning and parsing the source do not match the expected errors
    */
   static Object parse5(String methodName, String source, List<ErrorCode> errorCodes) => parse4(methodName, _EMPTY_ARGUMENTS, source, errorCodes);
 
   /**
    * Parse the given source as a compilation unit.
    * @param source the source to be parsed
    * @param errorCodes the error codes of the errors that are expected to be found
    * @return the compilation unit that was parsed
    * @throws Exception if the source could not be parsed, if the compilation errors in the source do
-   * not match those that are expected, or if the result would have been {@code null}
+   * not match those that are expected, or if the result would have been `null`
    */
   static CompilationUnit parseCompilationUnit(String source, List<ErrorCode> errorCodes) {
     GatheringErrorListener listener = new GatheringErrorListener();
     StringScanner scanner = new StringScanner(null, source, listener);
     listener.setLineInfo(new TestSource(), scanner.lineStarts);
     Token token = scanner.tokenize();
     Parser parser = new Parser(null, listener);
     CompilationUnit unit = parser.parseCompilationUnit(token);
     JUnitTestCase.assertNotNull(unit);
     listener.assertErrors2(errorCodes);
     return unit;
   }
 
   /**
    * Parse the given source as an expression.
    * @param source the source to be parsed
    * @param errorCodes the error codes of the errors that are expected to be found
    * @return the expression that was parsed
    * @throws Exception if the source could not be parsed, if the compilation errors in the source do
-   * not match those that are expected, or if the result would have been {@code null}
+   * not match those that are expected, or if the result would have been `null`
    */
   static Expression parseExpression(String source, List<ErrorCode> errorCodes) {
     GatheringErrorListener listener = new GatheringErrorListener();
     StringScanner scanner = new StringScanner(null, source, listener);
     listener.setLineInfo(new TestSource(), scanner.lineStarts);
     Token token = scanner.tokenize();
     Parser parser = new Parser(null, listener);
     Expression expression = parser.parseExpression(token);
     JUnitTestCase.assertNotNull(expression);
     listener.assertErrors2(errorCodes);
     return expression as Expression;
   }
 
   /**
    * Parse the given source as a statement.
    * @param source the source to be parsed
    * @param errorCodes the error codes of the errors that are expected to be found
    * @return the statement that was parsed
    * @throws Exception if the source could not be parsed, if the compilation errors in the source do
-   * not match those that are expected, or if the result would have been {@code null}
+   * not match those that are expected, or if the result would have been `null`
    */
   static Statement parseStatement(String source, List<ErrorCode> errorCodes) {
     GatheringErrorListener listener = new GatheringErrorListener();
     StringScanner scanner = new StringScanner(null, source, listener);
     listener.setLineInfo(new TestSource(), scanner.lineStarts);
     Token token = scanner.tokenize();
     Parser parser = new Parser(null, listener);
     Statement statement = parser.parseStatement(token);
     JUnitTestCase.assertNotNull(statement);
     listener.assertErrors2(errorCodes);
     return statement as Statement;
   }
 
   /**
    * Parse the given source as a sequence of statements.
    * @param source the source to be parsed
    * @param expectedCount the number of statements that are expected
    * @param errorCodes the error codes of the errors that are expected to be found
    * @return the statements that were parsed
    * @throws Exception if the source could not be parsed, if the number of statements does not match
    * the expected count, if the compilation errors in the source do not match those that
-   * are expected, or if the result would have been {@code null}
+   * are expected, or if the result would have been `null`
    */
   static List<Statement> parseStatements(String source, int expectedCount, List<ErrorCode> errorCodes) {
     GatheringErrorListener listener = new GatheringErrorListener();
     StringScanner scanner = new StringScanner(null, source, listener);
     listener.setLineInfo(new TestSource(), scanner.lineStarts);
     Token token = scanner.tokenize();
     Parser parser = new Parser(null, listener);
     List<Statement> statements = parser.parseStatements(token);
     EngineTestCase.assertSize(expectedCount, statements);
     listener.assertErrors2(errorCodes);
     return statements;
   }
 
   /**
-   * Invoke a method in {@link Parser}. The method is assumed to have the given number and type of
+   * Invoke a method in [Parser]. The method is assumed to have the given number and type of
    * parameters and will be invoked with the given arguments.
-   * <p>
+   *
    * The given source is scanned and the parser is initialized to start with the first token in the
    * source before the method is invoked.
    * @param methodName the name of the method that should be invoked
    * @param objects the values of the arguments to the method
    * @param source the source to be processed by the parse method
    * @param listener the error listener that will be used for both scanning and parsing
    * @return the result of invoking the method
    * @throws Exception if the method could not be invoked or throws an exception
-   * @throws AssertionFailedError if the result is {@code null} or the errors produced while
+   * @throws AssertionFailedError if the result is `null` or the errors produced while
    * scanning and parsing the source do not match the expected errors
    */
   static Object invokeParserMethod(String methodName, List<Object> objects, String source, GatheringErrorListener listener) {
     StringScanner scanner = new StringScanner(null, source, listener);
     Token tokenStream = scanner.tokenize();
     listener.setLineInfo(new TestSource(), scanner.lineStarts);
     Parser parser = new Parser(null, listener);
     Object result = invokeParserMethodImpl(parser, methodName, objects, tokenStream);
     if (!listener.hasErrors()) {
       JUnitTestCase.assertNotNull(result);
     }
     return result as Object;
   }
 
   /**
-   * Invoke a method in {@link Parser}. The method is assumed to have no arguments.
-   * <p>
+   * Invoke a method in [Parser]. The method is assumed to have no arguments.
+   *
    * The given source is scanned and the parser is initialized to start with the first token in the
    * source before the method is invoked.
    * @param methodName the name of the method that should be invoked
    * @param source the source to be processed by the parse method
    * @param listener the error listener that will be used for both scanning and parsing
    * @return the result of invoking the method
    * @throws Exception if the method could not be invoked or throws an exception
-   * @throws AssertionFailedError if the result is {@code null} or the errors produced while
+   * @throws AssertionFailedError if the result is `null` or the errors produced while
    * scanning and parsing the source do not match the expected errors
    */
   static Object invokeParserMethod2(String methodName, String source, GatheringErrorListener listener) => invokeParserMethod(methodName, _EMPTY_ARGUMENTS, source, listener);
 
   /**
    * Return a CommentAndMetadata object with the given values that can be used for testing.
    * @param comment the comment to be wrapped in the object
    * @param annotations the annotations to be wrapped in the object
    * @return a CommentAndMetadata object that can be used for testing
    */
   CommentAndMetadata commentAndMetadata(Comment comment, List<Annotation> annotations) {
     List<Annotation> metadata = new List<Annotation>();
     for (Annotation annotation in annotations) {
       metadata.add(annotation);
     }
     return new CommentAndMetadata(comment, metadata);
   }
 
   /**
    * Return an empty CommentAndMetadata object that can be used for testing.
    * @return an empty CommentAndMetadata object that can be used for testing
    */
   CommentAndMetadata emptyCommentAndMetadata() => new CommentAndMetadata(null, new List<Annotation>());
   static dartSuite() {
     _ut.group('ParserTestCase', () {
     });
   }
 }
 /**
- * The class {@code RecoveryParserTest} defines parser tests that test the parsing of invalid code
+ * The class `RecoveryParserTest` defines parser tests that test the parsing of invalid code
  * sequences to ensure that the correct recovery steps are taken in the parser.
  */
 class RecoveryParserTest extends ParserTestCase {
   void fail_incompleteReturnType() {
     ParserTestCase.parseCompilationUnit(EngineTestCase.createSource(["Map<Symbol, convertStringToSymbolMap(Map<String, dynamic> map) {", "  if (map == null) return null;", "  Map<Symbol, dynamic> result = new Map<Symbol, dynamic>();", "  map.forEach((name, value) {", "    result[new Symbol(name)] = value;", "  });", "  return result;", "}"]), []);
   }
   void test_additiveExpression_missing_LHS() {
     BinaryExpression expression = ParserTestCase.parseExpression("+ y", [ParserErrorCode.MISSING_IDENTIFIER]);
     EngineTestCase.assertInstanceOf(SimpleIdentifier, expression.leftOperand);
     JUnitTestCase.assertTrue(expression.leftOperand.isSynthetic());
@@ skipping 699 matching lines @@
         runJUnitTest(__test, __test.test_shiftExpression_super);
       });
       _ut.test('test_typedef_eof', () {
         final __test = new RecoveryParserTest();
         runJUnitTest(__test, __test.test_typedef_eof);
       });
     });
   }
 }
 /**
- * The class {@code ErrorParserTest} defines parser tests that test the parsing of code to ensure
+ * The class `ErrorParserTest` defines parser tests that test the parsing of code to ensure
  * that errors are correctly reported, and in some cases, not reported.
  */
 class ErrorParserTest extends ParserTestCase {
   void fail_expectedListOrMapLiteral() {
     TypedLiteral literal = ParserTestCase.parse4("parseListOrMapLiteral", <Object> [null], "1", [ParserErrorCode.EXPECTED_LIST_OR_MAP_LITERAL]);
     JUnitTestCase.assertTrue(literal.isSynthetic());
   }
   void fail_illegalAssignmentToNonAssignable_superAssigned() {
     ParserTestCase.parseExpression("super = x;", [ParserErrorCode.ILLEGAL_ASSIGNMENT_TO_NON_ASSIGNABLE]);
   }
@@ skipping 1555 matching lines @@
   'validateModifiersForTopLevelFunction_1': new MethodTrampoline(1, (Parser target, arg0) => target.validateModifiersForTopLevelFunction(arg0)),
   'validateModifiersForTopLevelVariable_1': new MethodTrampoline(1, (Parser target, arg0) => target.validateModifiersForTopLevelVariable(arg0)),
   'validateModifiersForTypedef_1': new MethodTrampoline(1, (Parser target, arg0) => target.validateModifiersForTypedef(arg0)),};
 
 
 Object invokeParserMethodImpl(Parser parser, String methodName, List<Object> objects, Token tokenStream) {
   parser.currentToken = tokenStream;
   MethodTrampoline method = _methodTable_Parser['${methodName}_${objects.length}'];
   return method.invoke(parser, objects);
 }