Analyzer snapshot.

pkg/analyzer/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/src/generated/java_core.dart';
 import 'package:analyzer/src/generated/java_junit.dart';
 import 'package:analyzer/src/generated/error.dart';
 import 'package:analyzer/src/generated/source.dart' show Source;
 import 'package:analyzer/src/generated/scanner.dart';
@@ skipping 1115 matching lines @@
     JUnitTestCase.assertNull(constructor.name);
     JUnitTestCase.assertNotNull(constructor.parameters);
     JUnitTestCase.assertNotNull(constructor.separator);
     EngineTestCase.assertSize(0, constructor.initializers);
     JUnitTestCase.assertNotNull(constructor.redirectedConstructor);
     JUnitTestCase.assertNotNull(constructor.body);
   }
 
   void test_parseClassTypeAlias() {
     Token token = TokenFactory.token(Keyword.CLASS);
-    ClassTypeAlias classTypeAlias = ParserTestCase.parse("parseClassTypeAlias", <Object> [emptyCommentAndMetadata(), token], "A = B;");
+    ClassTypeAlias classTypeAlias = ParserTestCase.parse("parseClassTypeAlias", <Object> [emptyCommentAndMetadata(), null, token], "A = B;");
     JUnitTestCase.assertNotNull(classTypeAlias.keyword);
     JUnitTestCase.assertEquals("A", classTypeAlias.name.name);
     JUnitTestCase.assertNotNull(classTypeAlias.equals);
     JUnitTestCase.assertNull(classTypeAlias.abstractKeyword);
     JUnitTestCase.assertNotNullMsg("B", classTypeAlias.superclass.name.name);
     JUnitTestCase.assertNull(classTypeAlias.withClause);
     JUnitTestCase.assertNull(classTypeAlias.implementsClause);
     JUnitTestCase.assertNotNull(classTypeAlias.semicolon);
   }
 
   void test_parseClassTypeAlias_abstract() {
     Token token = TokenFactory.token(Keyword.CLASS);
-    ClassTypeAlias classTypeAlias = ParserTestCase.parse("parseClassTypeAlias", <Object> [emptyCommentAndMetadata(), token], "A = abstract B;");
+    ClassTypeAlias classTypeAlias = ParserTestCase.parse("parseClassTypeAlias", <Object> [emptyCommentAndMetadata(), null, token], "A = abstract B;");
     JUnitTestCase.assertNotNull(classTypeAlias.keyword);
     JUnitTestCase.assertEquals("A", classTypeAlias.name.name);
     JUnitTestCase.assertNotNull(classTypeAlias.equals);
     JUnitTestCase.assertNotNull(classTypeAlias.abstractKeyword);
     JUnitTestCase.assertNotNullMsg("B", classTypeAlias.superclass.name.name);
     JUnitTestCase.assertNull(classTypeAlias.withClause);
     JUnitTestCase.assertNull(classTypeAlias.implementsClause);
     JUnitTestCase.assertNotNull(classTypeAlias.semicolon);
   }
 
   void test_parseClassTypeAlias_implements() {
     Token token = TokenFactory.token(Keyword.CLASS);
-    ClassTypeAlias classTypeAlias = ParserTestCase.parse("parseClassTypeAlias", <Object> [emptyCommentAndMetadata(), token], "A = B implements C;");
+    ClassTypeAlias classTypeAlias = ParserTestCase.parse("parseClassTypeAlias", <Object> [emptyCommentAndMetadata(), null, token], "A = B implements C;");
     JUnitTestCase.assertNotNull(classTypeAlias.keyword);
     JUnitTestCase.assertEquals("A", classTypeAlias.name.name);
     JUnitTestCase.assertNotNull(classTypeAlias.equals);
     JUnitTestCase.assertNull(classTypeAlias.abstractKeyword);
     JUnitTestCase.assertNotNullMsg("B", classTypeAlias.superclass.name.name);
     JUnitTestCase.assertNull(classTypeAlias.withClause);
     JUnitTestCase.assertNotNull(classTypeAlias.implementsClause);
     JUnitTestCase.assertNotNull(classTypeAlias.semicolon);
   }
 
   void test_parseClassTypeAlias_with() {
     Token token = TokenFactory.token(Keyword.CLASS);
-    ClassTypeAlias classTypeAlias = ParserTestCase.parse("parseClassTypeAlias", <Object> [emptyCommentAndMetadata(), token], "A = B with C;");
+    ClassTypeAlias classTypeAlias = ParserTestCase.parse("parseClassTypeAlias", <Object> [emptyCommentAndMetadata(), null, token], "A = B with C;");
     JUnitTestCase.assertNotNull(classTypeAlias.keyword);
     JUnitTestCase.assertEquals("A", classTypeAlias.name.name);
     JUnitTestCase.assertNotNull(classTypeAlias.equals);
     JUnitTestCase.assertNull(classTypeAlias.abstractKeyword);
     JUnitTestCase.assertNotNullMsg("B", classTypeAlias.superclass.name.name);
     JUnitTestCase.assertNotNull(classTypeAlias.withClause);
     JUnitTestCase.assertNull(classTypeAlias.implementsClause);
     JUnitTestCase.assertNotNull(classTypeAlias.semicolon);
   }
 
   void test_parseClassTypeAlias_with_implements() {
     Token token = TokenFactory.token(Keyword.CLASS);
-    ClassTypeAlias classTypeAlias = ParserTestCase.parse("parseClassTypeAlias", <Object> [emptyCommentAndMetadata(), token], "A = B with C implements D;");
+    ClassTypeAlias classTypeAlias = ParserTestCase.parse("parseClassTypeAlias", <Object> [emptyCommentAndMetadata(), null, token], "A = B with C implements D;");
     JUnitTestCase.assertNotNull(classTypeAlias.keyword);
     JUnitTestCase.assertEquals("A", classTypeAlias.name.name);
     JUnitTestCase.assertNotNull(classTypeAlias.equals);
     JUnitTestCase.assertNull(classTypeAlias.abstractKeyword);
     JUnitTestCase.assertNotNullMsg("B", classTypeAlias.superclass.name.name);
     JUnitTestCase.assertNotNull(classTypeAlias.withClause);
     JUnitTestCase.assertNotNull(classTypeAlias.implementsClause);
     JUnitTestCase.assertNotNull(classTypeAlias.semicolon);
   }
 
@@ skipping 321 matching lines @@
     JUnitTestCase.assertNotNull(declaration.semicolon);
     JUnitTestCase.assertNotNull(declaration.variables);
   }
 
   void test_parseCompilationUnitMember_class() {
     ClassDeclaration declaration = ParserTestCase.parse("parseCompilationUnitMember", <Object> [emptyCommentAndMetadata()], "class A {}");
     JUnitTestCase.assertEquals("A", declaration.name.name);
     EngineTestCase.assertSize(0, declaration.members);
   }
 
+  void test_parseCompilationUnitMember_classTypeAlias() {
+    ClassTypeAlias alias = ParserTestCase.parse("parseCompilationUnitMember", <Object> [emptyCommentAndMetadata()], "abstract class A = B with C;");
+    JUnitTestCase.assertEquals("A", alias.name.name);
+    JUnitTestCase.assertNotNull(alias.abstractKeyword);
+  }
+
   void test_parseCompilationUnitMember_constVariable() {
     TopLevelVariableDeclaration declaration = ParserTestCase.parse("parseCompilationUnitMember", <Object> [emptyCommentAndMetadata()], "const int x = 0;");
     JUnitTestCase.assertNotNull(declaration.semicolon);
     JUnitTestCase.assertNotNull(declaration.variables);
   }
 
   void test_parseCompilationUnitMember_finalVariable() {
     TopLevelVariableDeclaration declaration = ParserTestCase.parse("parseCompilationUnitMember", <Object> [emptyCommentAndMetadata()], "final x = 0;");
     JUnitTestCase.assertNotNull(declaration.semicolon);
     JUnitTestCase.assertNotNull(declaration.variables);
@@ skipping 73 matching lines @@
   void test_parseCompilationUnitMember_setter_noType() {
     FunctionDeclaration declaration = ParserTestCase.parse("parseCompilationUnitMember", <Object> [emptyCommentAndMetadata()], "set p(v) {}");
     JUnitTestCase.assertNotNull(declaration.functionExpression);
     JUnitTestCase.assertNotNull(declaration.propertyKeyword);
   }
 
   void test_parseCompilationUnitMember_setter_type() {
     FunctionDeclaration declaration = ParserTestCase.parse("parseCompilationUnitMember", <Object> [emptyCommentAndMetadata()], "void set p(int v) {}");
     JUnitTestCase.assertNotNull(declaration.functionExpression);
     JUnitTestCase.assertNotNull(declaration.propertyKeyword);
+    JUnitTestCase.assertNotNull(declaration.returnType);
   }
 
   void test_parseCompilationUnitMember_typeAlias_abstract() {
     ClassTypeAlias typeAlias = ParserTestCase.parse("parseCompilationUnitMember", <Object> [emptyCommentAndMetadata()], "class C = abstract S with M;");
     JUnitTestCase.assertNotNull(typeAlias.keyword);
     JUnitTestCase.assertEquals("C", typeAlias.name.name);
     JUnitTestCase.assertNull(typeAlias.typeParameters);
     JUnitTestCase.assertNotNull(typeAlias.equals);
     JUnitTestCase.assertNotNull(typeAlias.abstractKeyword);
     JUnitTestCase.assertEquals("S", typeAlias.superclass.name.name);
@@ skipping 1828 matching lines @@
   }
 
   void test_parsePrimaryExpression_parenthesized() {
     ParenthesizedExpression expression = ParserTestCase.parse5("parsePrimaryExpression", "(x)", []);
     JUnitTestCase.assertNotNull(expression);
   }
 
   void test_parsePrimaryExpression_string() {
     SimpleStringLiteral literal = ParserTestCase.parse5("parsePrimaryExpression", "\"string\"", []);
     JUnitTestCase.assertFalse(literal.isMultiline);
+    JUnitTestCase.assertFalse(literal.isRaw);
     JUnitTestCase.assertEquals("string", literal.value);
   }
 
+  void test_parsePrimaryExpression_string_multiline() {
+    SimpleStringLiteral literal = ParserTestCase.parse5("parsePrimaryExpression", "'''string'''", []);
+    JUnitTestCase.assertTrue(literal.isMultiline);
+    JUnitTestCase.assertFalse(literal.isRaw);
+    JUnitTestCase.assertEquals("string", literal.value);
+  }
+
+  void test_parsePrimaryExpression_string_raw() {
+    SimpleStringLiteral literal = ParserTestCase.parse5("parsePrimaryExpression", "r'string'", []);
+    JUnitTestCase.assertFalse(literal.isMultiline);
+    JUnitTestCase.assertTrue(literal.isRaw);
+    JUnitTestCase.assertEquals("string", literal.value);
+  }
+
   void test_parsePrimaryExpression_super() {
     PropertyAccess propertyAccess = ParserTestCase.parse5("parsePrimaryExpression", "super.x", []);
     JUnitTestCase.assertTrue(propertyAccess.target is SuperExpression);
     JUnitTestCase.assertNotNull(propertyAccess.operator);
     JUnitTestCase.assertEquals(TokenType.PERIOD, propertyAccess.operator.type);
     JUnitTestCase.assertNotNull(propertyAccess.propertyName);
   }
 
   void test_parsePrimaryExpression_this() {
     ThisExpression expression = ParserTestCase.parse5("parsePrimaryExpression", "this", []);
@@ skipping 913 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_28();
+    AnalysisErrorListener listener = new AnalysisErrorListener_30();
     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 801 matching lines @@
         runJUnitTest(__test, __test.test_parseCommentReferences_skipReferenceLink);
       });
       _ut.test('test_parseCompilationUnitMember_abstractAsPrefix', () {
         final __test = new SimpleParserTest();
         runJUnitTest(__test, __test.test_parseCompilationUnitMember_abstractAsPrefix);
       });
       _ut.test('test_parseCompilationUnitMember_class', () {
         final __test = new SimpleParserTest();
         runJUnitTest(__test, __test.test_parseCompilationUnitMember_class);
       });
+      _ut.test('test_parseCompilationUnitMember_classTypeAlias', () {
+        final __test = new SimpleParserTest();
+        runJUnitTest(__test, __test.test_parseCompilationUnitMember_classTypeAlias);
+      });
       _ut.test('test_parseCompilationUnitMember_constVariable', () {
         final __test = new SimpleParserTest();
         runJUnitTest(__test, __test.test_parseCompilationUnitMember_constVariable);
       });
       _ut.test('test_parseCompilationUnitMember_finalVariable', () {
         final __test = new SimpleParserTest();
         runJUnitTest(__test, __test.test_parseCompilationUnitMember_finalVariable);
       });
       _ut.test('test_parseCompilationUnitMember_function_external_noType', () {
         final __test = new SimpleParserTest();
@@ skipping 964 matching lines @@
         runJUnitTest(__test, __test.test_parsePrimaryExpression_null);
       });
       _ut.test('test_parsePrimaryExpression_parenthesized', () {
         final __test = new SimpleParserTest();
         runJUnitTest(__test, __test.test_parsePrimaryExpression_parenthesized);
       });
       _ut.test('test_parsePrimaryExpression_string', () {
         final __test = new SimpleParserTest();
         runJUnitTest(__test, __test.test_parsePrimaryExpression_string);
       });
+      _ut.test('test_parsePrimaryExpression_string_multiline', () {
+        final __test = new SimpleParserTest();
+        runJUnitTest(__test, __test.test_parsePrimaryExpression_string_multiline);
+      });
+      _ut.test('test_parsePrimaryExpression_string_raw', () {
+        final __test = new SimpleParserTest();
+        runJUnitTest(__test, __test.test_parsePrimaryExpression_string_raw);
+      });
       _ut.test('test_parsePrimaryExpression_super', () {
         final __test = new SimpleParserTest();
         runJUnitTest(__test, __test.test_parsePrimaryExpression_super);
       });
       _ut.test('test_parsePrimaryExpression_this', () {
         final __test = new SimpleParserTest();
         runJUnitTest(__test, __test.test_parsePrimaryExpression_this);
       });
       _ut.test('test_parsePrimaryExpression_true', () {
         final __test = new SimpleParserTest();
@@ skipping 444 matching lines @@
         runJUnitTest(__test, __test.test_skipTypeName_parameterized);
       });
       _ut.test('test_skipTypeName_simple', () {
         final __test = new SimpleParserTest();
         runJUnitTest(__test, __test.test_skipTypeName_simple);
       });
     });
   }
 }
 
-class AnalysisErrorListener_28 implements AnalysisErrorListener {
+class AnalysisErrorListener_30 implements AnalysisErrorListener {
   void onError(AnalysisError event) {
     JUnitTestCase.fail("Unexpected compilation error: ${event.message} (${event.offset}, ${event.length})");
   }
 }
 
 class NonErrorParserTest extends ParserTestCase {
   void test_constFactory_external() {
     ParserTestCase.parse("parseClassMember", <Object> ["C"], "external const factory C();");
   }
 
@@ skipping 3074 matching lines @@
   }
 
   void test_expectedToken_parseStatement_afterVoid() {
     ParserTestCase.parseStatement("void}", [
         ParserErrorCode.EXPECTED_TOKEN,
         ParserErrorCode.MISSING_IDENTIFIER]);
   }
 
   void test_expectedToken_semicolonAfterClass() {
     Token token = TokenFactory.token(Keyword.CLASS);
-    ParserTestCase.parse4("parseClassTypeAlias", <Object> [emptyCommentAndMetadata(), token], "A = B", [ParserErrorCode.EXPECTED_TOKEN]);
+    ParserTestCase.parse4("parseClassTypeAlias", <Object> [emptyCommentAndMetadata(), null, token], "A = B", [ParserErrorCode.EXPECTED_TOKEN]);
   }
 
   void test_expectedToken_semicolonMissingAfterExpression() {
     ParserTestCase.parseStatement("x", [ParserErrorCode.EXPECTED_TOKEN]);
   }
 
   void test_expectedToken_whileMissingInDoStatement() {
     ParserTestCase.parseStatement("do {} (x);", [ParserErrorCode.EXPECTED_TOKEN]);
   }
 
@@ skipping 1741 matching lines @@
   'parseArgumentDefinitionTest_0': new MethodTrampoline(0, (Parser target) => target.parseArgumentDefinitionTest()),
   'parseAssertStatement_0': new MethodTrampoline(0, (Parser target) => target.parseAssertStatement()),
   'parseAssignableExpression_1': new MethodTrampoline(1, (Parser target, arg0) => target.parseAssignableExpression(arg0)),
   'parseAssignableSelector_2': new MethodTrampoline(2, (Parser target, arg0, arg1) => target.parseAssignableSelector(arg0, arg1)),
   'parseBitwiseAndExpression_0': new MethodTrampoline(0, (Parser target) => target.parseBitwiseAndExpression()),
   'parseBitwiseXorExpression_0': new MethodTrampoline(0, (Parser target) => target.parseBitwiseXorExpression()),
   'parseBreakStatement_0': new MethodTrampoline(0, (Parser target) => target.parseBreakStatement()),
   'parseCascadeSection_0': new MethodTrampoline(0, (Parser target) => target.parseCascadeSection()),
   'parseClassDeclaration_2': new MethodTrampoline(2, (Parser target, arg0, arg1) => target.parseClassDeclaration(arg0, arg1)),
   'parseClassMembers_2': new MethodTrampoline(2, (Parser target, arg0, arg1) => target.parseClassMembers(arg0, arg1)),
-  'parseClassTypeAlias_2': new MethodTrampoline(2, (Parser target, arg0, arg1) => target.parseClassTypeAlias(arg0, arg1)),
+  'parseClassTypeAlias_3': new MethodTrampoline(3, (Parser target, arg0, arg1, arg2) => target.parseClassTypeAlias(arg0, arg1, arg2)),
   'parseCombinators_0': new MethodTrampoline(0, (Parser target) => target.parseCombinators()),
   'parseCommentAndMetadata_0': new MethodTrampoline(0, (Parser target) => target.parseCommentAndMetadata()),
   'parseCommentReference_2': new MethodTrampoline(2, (Parser target, arg0, arg1) => target.parseCommentReference(arg0, arg1)),
   'parseCommentReferences_1': new MethodTrampoline(1, (Parser target, arg0) => target.parseCommentReferences(arg0)),
   'parseCompilationUnitMember_1': new MethodTrampoline(1, (Parser target, arg0) => target.parseCompilationUnitMember(arg0)),
   'parseConstExpression_0': new MethodTrampoline(0, (Parser target) => target.parseConstExpression()),
   'parseConstructor_8': new MethodTrampoline(8, (Parser target, arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7) => target.parseConstructor(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7)),
   'parseConstructorFieldInitializer_0': new MethodTrampoline(0, (Parser target) => target.parseConstructorFieldInitializer()),
   'parseContinueStatement_0': new MethodTrampoline(0, (Parser target) => target.parseContinueStatement()),
   'parseDirective_1': new MethodTrampoline(1, (Parser target, arg0) => target.parseDirective(arg0)),
@@ skipping 87 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);
 }