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 'package:analyzer_experimental/src/generated/java_core.dart';
 import 'package:analyzer_experimental/src/generated/java_junit.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';
@@ skipping 3770 matching lines @@
   /**
    * Invoke the method [Parser#computeStringValue] with the given argument.
    *
    * @param lexeme the argument to the method
    * @param first `true` if this is the first token in a string literal
    * @param last `true` if this is the last token in a string literal
    * @return the result of invoking the method
    * @throws Exception if the method could not be invoked or throws an exception
    */
   String computeStringValue(String lexeme, bool first, bool last) {
-    AnalysisErrorListener listener = new AnalysisErrorListener_23();
+    AnalysisErrorListener listener = new AnalysisErrorListener_25();
     Parser parser = new Parser(null, listener);
     return invokeParserMethodImpl(parser, "computeStringValue", <Object> [lexeme, first, last], null) as String;
   }
 
   /**
    * 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
@@ skipping 33 matching lines @@
   /**
    * 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);
+    Scanner scanner = new Scanner(null, new CharSequenceReader(new CharSequence(source)), listener);
     Token tokenStream = scanner.tokenize();
     Parser parser = new Parser(null, listener);
     return invokeParserMethodImpl(parser, "isFunctionExpression", <Object> [tokenStream], tokenStream) as bool;
   }
 
   /**
    * 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
@@ skipping 23 matching lines @@
    * 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 `null`
    */
   Token skip(String methodName, String source) {
     GatheringErrorListener listener = new GatheringErrorListener();
-    StringScanner scanner = new StringScanner(null, source, listener);
+    Scanner scanner = new Scanner(null, new CharSequenceReader(new CharSequence(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', () {
       _ut.test('test_Parser', () {
         final __test = new SimpleParserTest();
         runJUnitTest(__test, __test.test_Parser);
       });
@@ skipping 2113 matching lines @@
         final __test = new SimpleParserTest();
         runJUnitTest(__test, __test.test_skipTypeName_parameterized);
       });
       _ut.test('test_skipTypeName_simple', () {
         final __test = new SimpleParserTest();
         runJUnitTest(__test, __test.test_skipTypeName_simple);
       });
     });
   }
 }
-class AnalysisErrorListener_23 implements AnalysisErrorListener {
+class AnalysisErrorListener_25 implements AnalysisErrorListener {
   void onError(AnalysisError event) {
     JUnitTestCase.fail("Unexpected compilation error: ${event.message} (${event.offset}, ${event.length})");
   }
 }
 /**
  * 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.
  *
  * Simpler tests should be defined in the class [SimpleParserTest].
@@ skipping 573 matching lines @@
    * 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 `null`
    */
   static CompilationUnit parseCompilationUnit(String source, List<ErrorCode> errorCodes) {
     GatheringErrorListener listener = new GatheringErrorListener();
-    StringScanner scanner = new StringScanner(null, source, listener);
+    Scanner scanner = new Scanner(null, new CharSequenceReader(new CharSequence(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 `null`
    */
   static Expression parseExpression(String source, List<ErrorCode> errorCodes) {
     GatheringErrorListener listener = new GatheringErrorListener();
-    StringScanner scanner = new StringScanner(null, source, listener);
+    Scanner scanner = new Scanner(null, new CharSequenceReader(new CharSequence(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 `null`
    */
   static Statement parseStatement(String source, List<ErrorCode> errorCodes) {
     GatheringErrorListener listener = new GatheringErrorListener();
-    StringScanner scanner = new StringScanner(null, source, listener);
+    Scanner scanner = new Scanner(null, new CharSequenceReader(new CharSequence(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 `null`
    */
   static List<Statement> parseStatements(String source, int expectedCount, List<ErrorCode> errorCodes) {
     GatheringErrorListener listener = new GatheringErrorListener();
-    StringScanner scanner = new StringScanner(null, source, listener);
+    Scanner scanner = new Scanner(null, new CharSequenceReader(new CharSequence(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 [Parser]. The method is assumed to have the given number and type of
    * parameters and will be invoked with the given 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 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 `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);
+    Scanner scanner = new Scanner(null, new CharSequenceReader(new CharSequence(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;
   }
 
@@ skipping 872 matching lines @@
         runJUnitTest(__test, __test.test_typedef_eof);
       });
     });
   }
 }
 /**
  * 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_deprecatedClassTypeAlias() {
-    ParserTestCase.parseCompilationUnit("typedef C = abstract S with M;", [ParserErrorCode.DEPRECATED_CLASS_TYPE_ALIAS]);
-  }
-  void fail_deprecatedClassTypeAlias_withGeneric() {
-    ParserTestCase.parseCompilationUnit("typedef C<T> = abstract S<T> with M;", [ParserErrorCode.DEPRECATED_CLASS_TYPE_ALIAS]);
-  }
   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]);
   }
   void fail_invalidCommentReference__new_nonIdentifier() {
     ParserTestCase.parse4("parseCommentReference", <Object> ["new 42", 0], "", [ParserErrorCode.INVALID_COMMENT_REFERENCE]);
   }
@@ skipping 141 matching lines @@
   }
   void test_continueWithoutLabelInCase_error() {
     ParserTestCase.parse5("parseSwitchStatement", "switch (x) {case 1: continue;}", [ParserErrorCode.CONTINUE_WITHOUT_LABEL_IN_CASE]);
   }
   void test_continueWithoutLabelInCase_noError() {
     ParserTestCase.parse5("parseSwitchStatement", "switch (x) {case 1: continue a;}", []);
   }
   void test_continueWithoutLabelInCase_noError_switchInLoop() {
     ParserTestCase.parse5("parseWhileStatement", "while (a) { switch (b) {default: continue;}}", []);
   }
+  void test_deprecatedClassTypeAlias() {
+    ParserTestCase.parseCompilationUnit("typedef C = abstract S with M;", [ParserErrorCode.DEPRECATED_CLASS_TYPE_ALIAS]);
+  }
+  void test_deprecatedClassTypeAlias_withGeneric() {
+    ParserTestCase.parseCompilationUnit("typedef C<T> = abstract S<T> with M;", [ParserErrorCode.DEPRECATED_CLASS_TYPE_ALIAS]);
+  }
   void test_directiveAfterDeclaration_classBeforeDirective() {
     CompilationUnit unit = ParserTestCase.parseCompilationUnit("class Foo{} library l;", [ParserErrorCode.DIRECTIVE_AFTER_DECLARATION]);
     JUnitTestCase.assertNotNull(unit);
   }
   void test_directiveAfterDeclaration_classBetweenDirectives() {
     CompilationUnit unit = ParserTestCase.parseCompilationUnit("library l;\nclass Foo{}\npart 'a.dart';", [ParserErrorCode.DIRECTIVE_AFTER_DECLARATION]);
     JUnitTestCase.assertNotNull(unit);
   }
   void test_duplicatedModifier_const() {
     ParserTestCase.parse4("parseClassMember", <Object> ["C"], "const const m;", [ParserErrorCode.DUPLICATED_MODIFIER]);
@@ skipping 763 matching lines @@
         runJUnitTest(__test, __test.test_continueWithoutLabelInCase_error);
       });
       _ut.test('test_continueWithoutLabelInCase_noError', () {
         final __test = new ErrorParserTest();
         runJUnitTest(__test, __test.test_continueWithoutLabelInCase_noError);
       });
       _ut.test('test_continueWithoutLabelInCase_noError_switchInLoop', () {
         final __test = new ErrorParserTest();
         runJUnitTest(__test, __test.test_continueWithoutLabelInCase_noError_switchInLoop);
       });
+      _ut.test('test_deprecatedClassTypeAlias', () {
+        final __test = new ErrorParserTest();
+        runJUnitTest(__test, __test.test_deprecatedClassTypeAlias);
+      });
+      _ut.test('test_deprecatedClassTypeAlias_withGeneric', () {
+        final __test = new ErrorParserTest();
+        runJUnitTest(__test, __test.test_deprecatedClassTypeAlias_withGeneric);
+      });
       _ut.test('test_directiveAfterDeclaration_classBeforeDirective', () {
         final __test = new ErrorParserTest();
         runJUnitTest(__test, __test.test_directiveAfterDeclaration_classBeforeDirective);
       });
       _ut.test('test_directiveAfterDeclaration_classBetweenDirectives', () {
         final __test = new ErrorParserTest();
         runJUnitTest(__test, __test.test_directiveAfterDeclaration_classBetweenDirectives);
       });
       _ut.test('test_duplicateLabelInSwitchStatement', () {
         final __test = new ErrorParserTest();
@@ skipping 954 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);
 }