Remove trailing spaces in analyzer_experimental

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
  * 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}.
  */
 class SimpleParserTest extends ParserTestCase {
   void fail_parseCommentReference_this() {
     CommentReference reference = ParserTestCase.parse("parseCommentReference", <Object> ["this", 5], "");
@@ skipping 3631 matching lines @@
   void test_skipTypeName_parameterized() {
     Token following = skip("skipTypeName", "C<E<F<G>>> +");
     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.
    * @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_20();
     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
    * 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
    * 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
    * 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
    * 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
    * 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
    * 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
    * 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}
    */
   Token skip(String methodName, String source) {
@@ skipping 2078 matching lines @@
         runJUnitTest(__test, __test.test_skipTypeName_simple);
       });
     });
   }
 }
 class AnalysisErrorListener_20 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
  * 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}.
  */
 class ComplexParserTest extends ParserTestCase {
   void test_additiveExpression_normal() {
     BinaryExpression expression = ParserTestCase.parseExpression("x + y - z", []);
@@ skipping 390 matching lines @@
         final __test = new ComplexParserTest();
         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
  * AST structure.
  */
 class ASTValidator extends GeneralizingASTVisitor<Object> {
-  
+
   /**
    * A list containing the errors found while traversing the AST structure.
    */
   List<String> _errors = new List<String>();
-  
+
   /**
    * Assert that no errors were found while traversing any of the AST structures that have been
    * visited.
    */
   void assertValid() {
     if (!_errors.isEmpty) {
       JavaStringBuilder builder = new JavaStringBuilder();
       builder.append("Invalid AST structure:");
       for (String message in _errors) {
         builder.append("\r\n   ");
         builder.append(message);
       }
       JUnitTestCase.fail(builder.toString());
     }
   }
   Object visitNode(ASTNode node) {
     validate(node);
     return super.visitNode(node);
   }
-  
+
   /**
    * Validate that the given AST node is correctly constructed.
    * @param node the AST node being validated
    */
   void validate(ASTNode node) {
     ASTNode parent2 = node.parent;
     if (node is CompilationUnit) {
       if (parent2 != null) {
         _errors.add("Compilation units should not have a parent");
       }
@@ skipping 20 matching lines @@
       if (nodeStart < parentStart) {
         _errors.add("Invalid source start (${nodeStart}) for ${node.runtimeType.toString()} inside ${parent2.runtimeType.toString()} (${parentStart})");
       }
       if (nodeEnd > parentEnd) {
         _errors.add("Invalid source end (${nodeEnd}) for ${node.runtimeType.toString()} inside ${parent2.runtimeType.toString()} (${parentStart})");
       }
     }
   }
 }
 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
    * 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
    */
   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
    * 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
    * 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
    * 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
    * 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>
    * 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
    * 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}
    */
   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}
    */
   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}
    */
   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}
    */
   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
    * 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
    * 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>
    * 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
    * 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
  * 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]);
@@ skipping 700 matching lines @@
         final __test = new RecoveryParserTest();
         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
  * 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() {
@@ skipping 1557 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);
 }