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';
@@ skipping 13 matching lines @@
  */
 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() {
-    JUnitTestCase.assertEquals("", computeStringValue("'''"));
+    JUnitTestCase.assertEquals("", computeStringValue("'''", true, false));
   }
   void test_computeStringValue_escape_b() {
-    JUnitTestCase.assertEquals("\b", computeStringValue("'\\b'"));
+    JUnitTestCase.assertEquals("\b", computeStringValue("'\\b'", true, true));
   }
   void test_computeStringValue_escape_f() {
-    JUnitTestCase.assertEquals("\f", computeStringValue("'\\f'"));
+    JUnitTestCase.assertEquals("\f", computeStringValue("'\\f'", true, true));
   }
   void test_computeStringValue_escape_n() {
-    JUnitTestCase.assertEquals("\n", computeStringValue("'\\n'"));
+    JUnitTestCase.assertEquals("\n", computeStringValue("'\\n'", true, true));
   }
   void test_computeStringValue_escape_notSpecial() {
-    JUnitTestCase.assertEquals(":", computeStringValue("'\\:'"));
+    JUnitTestCase.assertEquals(":", computeStringValue("'\\:'", true, true));
   }
   void test_computeStringValue_escape_r() {
-    JUnitTestCase.assertEquals("\r", computeStringValue("'\\r'"));
+    JUnitTestCase.assertEquals("\r", computeStringValue("'\\r'", true, true));
   }
   void test_computeStringValue_escape_t() {
-    JUnitTestCase.assertEquals("\t", computeStringValue("'\\t'"));
+    JUnitTestCase.assertEquals("\t", computeStringValue("'\\t'", true, true));
   }
   void test_computeStringValue_escape_u_fixed() {
-    JUnitTestCase.assertEquals("\u4321", computeStringValue("'\\u4321'"));
+    JUnitTestCase.assertEquals("\u4321", computeStringValue("'\\u4321'", true, true));
   }
   void test_computeStringValue_escape_u_variable() {
-    JUnitTestCase.assertEquals("\u0123", computeStringValue("'\\u{123}'"));
+    JUnitTestCase.assertEquals("\u0123", computeStringValue("'\\u{123}'", true, true));
   }
   void test_computeStringValue_escape_v() {
-    JUnitTestCase.assertEquals("\u000B", computeStringValue("'\\v'"));
+    JUnitTestCase.assertEquals("\u000B", computeStringValue("'\\v'", true, true));
   }
   void test_computeStringValue_escape_x() {
-    JUnitTestCase.assertEquals("\u00FF", computeStringValue("'\\xFF'"));
+    JUnitTestCase.assertEquals("\u00FF", computeStringValue("'\\xFF'", true, true));
   }
   void test_computeStringValue_noEscape_single() {
-    JUnitTestCase.assertEquals("text", computeStringValue("'text'"));
+    JUnitTestCase.assertEquals("text", computeStringValue("'text'", true, true));
   }
   void test_computeStringValue_noEscape_triple() {
-    JUnitTestCase.assertEquals("text", computeStringValue("'''text'''"));
+    JUnitTestCase.assertEquals("text", computeStringValue("'''text'''", true, true));
   }
   void test_computeStringValue_raw_single() {
-    JUnitTestCase.assertEquals("text", computeStringValue("r'text'"));
+    JUnitTestCase.assertEquals("text", computeStringValue("r'text'", true, true));
   }
   void test_computeStringValue_raw_triple() {
-    JUnitTestCase.assertEquals("text", computeStringValue("r'''text'''"));
+    JUnitTestCase.assertEquals("text", computeStringValue("r'''text'''", true, true));
   }
   void test_computeStringValue_raw_withEscape() {
-    JUnitTestCase.assertEquals("two\\nlines", computeStringValue("r'two\\nlines'"));
+    JUnitTestCase.assertEquals("two\\nlines", computeStringValue("r'two\\nlines'", true, true));
+  }
+  void test_computeStringValue_triple_internalQuote_first_empty() {
+    JUnitTestCase.assertEquals("'", computeStringValue("''''", true, false));
+  }
+  void test_computeStringValue_triple_internalQuote_first_nonEmpty() {
+    JUnitTestCase.assertEquals("'text", computeStringValue("''''text", true, false));
+  }
+  void test_computeStringValue_triple_internalQuote_last_empty() {
+    JUnitTestCase.assertEquals("", computeStringValue("'''", false, true));
+  }
+  void test_computeStringValue_triple_internalQuote_last_nonEmpty() {
+    JUnitTestCase.assertEquals("text", computeStringValue("text'''", false, true));
   }
   void test_constFactory() {
     ParserTestCase.parse("parseClassMember", <Object> ["C"], "const factory C() = A;");
   }
   void test_createSyntheticIdentifier() {
     SimpleIdentifier identifier = createSyntheticIdentifier();
     JUnitTestCase.assertTrue(identifier.isSynthetic);
   }
   void test_createSyntheticStringLiteral() {
     SimpleStringLiteral literal = createSyntheticStringLiteral();
@@ skipping 229 matching lines @@
     JUnitTestCase.assertNotNull(propertyAccess.propertyName);
   }
   void test_parseAssignableExpression_expression_dot() {
     PropertyAccess propertyAccess = ParserTestCase.parse("parseAssignableExpression", <Object> [false], "(x).y");
     JUnitTestCase.assertNotNull(propertyAccess.target);
     JUnitTestCase.assertNotNull(propertyAccess.operator);
     JUnitTestCase.assertNotNull(propertyAccess.propertyName);
   }
   void test_parseAssignableExpression_expression_index() {
     IndexExpression expression = ParserTestCase.parse("parseAssignableExpression", <Object> [false], "(x)[y]");
-    JUnitTestCase.assertNotNull(expression.array);
+    JUnitTestCase.assertNotNull(expression.target);
     JUnitTestCase.assertNotNull(expression.leftBracket);
     JUnitTestCase.assertNotNull(expression.index);
     JUnitTestCase.assertNotNull(expression.rightBracket);
   }
   void test_parseAssignableExpression_identifier() {
     SimpleIdentifier identifier = ParserTestCase.parse("parseAssignableExpression", <Object> [false], "x");
     JUnitTestCase.assertNotNull(identifier);
   }
   void test_parseAssignableExpression_identifier_args_dot() {
     PropertyAccess propertyAccess = ParserTestCase.parse("parseAssignableExpression", <Object> [false], "x(y).z");
     MethodInvocation invocation = propertyAccess.target as MethodInvocation;
     JUnitTestCase.assertEquals("x", invocation.methodName.name);
     ArgumentList argumentList = invocation.argumentList;
     JUnitTestCase.assertNotNull(argumentList);
     EngineTestCase.assertSize(1, argumentList.arguments);
     JUnitTestCase.assertNotNull(propertyAccess.operator);
     JUnitTestCase.assertNotNull(propertyAccess.propertyName);
   }
   void test_parseAssignableExpression_identifier_dot() {
     PropertyAccess propertyAccess = ParserTestCase.parse("parseAssignableExpression", <Object> [false], "x.y");
     JUnitTestCase.assertNotNull(propertyAccess.target);
     JUnitTestCase.assertNotNull(propertyAccess.operator);
     JUnitTestCase.assertNotNull(propertyAccess.propertyName);
   }
   void test_parseAssignableExpression_identifier_index() {
     IndexExpression expression = ParserTestCase.parse("parseAssignableExpression", <Object> [false], "x[y]");
-    JUnitTestCase.assertNotNull(expression.array);
+    JUnitTestCase.assertNotNull(expression.target);
     JUnitTestCase.assertNotNull(expression.leftBracket);
     JUnitTestCase.assertNotNull(expression.index);
     JUnitTestCase.assertNotNull(expression.rightBracket);
   }
   void test_parseAssignableExpression_super_dot() {
     PropertyAccess propertyAccess = ParserTestCase.parse("parseAssignableExpression", <Object> [false], "super.y");
     EngineTestCase.assertInstanceOf(SuperExpression, propertyAccess.target);
     JUnitTestCase.assertNotNull(propertyAccess.operator);
     JUnitTestCase.assertNotNull(propertyAccess.propertyName);
   }
   void test_parseAssignableExpression_super_index() {
     IndexExpression expression = ParserTestCase.parse("parseAssignableExpression", <Object> [false], "super[y]");
-    EngineTestCase.assertInstanceOf(SuperExpression, expression.array);
+    EngineTestCase.assertInstanceOf(SuperExpression, expression.target);
     JUnitTestCase.assertNotNull(expression.leftBracket);
     JUnitTestCase.assertNotNull(expression.index);
     JUnitTestCase.assertNotNull(expression.rightBracket);
   }
   void test_parseAssignableSelector_dot() {
     PropertyAccess selector = ParserTestCase.parse("parseAssignableSelector", <Object> [null, true], ".x");
     JUnitTestCase.assertNotNull(selector.operator);
     JUnitTestCase.assertNotNull(selector.propertyName);
   }
   void test_parseAssignableSelector_index() {
@@ skipping 67 matching lines @@
     JUnitTestCase.assertNotNull(statement.semicolon);
   }
   void test_parseBreakStatement_noLabel() {
     BreakStatement statement = ParserTestCase.parse5("parseBreakStatement", "break;", [ParserErrorCode.BREAK_OUTSIDE_OF_LOOP]);
     JUnitTestCase.assertNotNull(statement.keyword);
     JUnitTestCase.assertNull(statement.label);
     JUnitTestCase.assertNotNull(statement.semicolon);
   }
   void test_parseCascadeSection_i() {
     IndexExpression section = ParserTestCase.parse5("parseCascadeSection", "..[i]", []);
-    JUnitTestCase.assertNull(section.array);
+    JUnitTestCase.assertNull(section.target);
     JUnitTestCase.assertNotNull(section.leftBracket);
     JUnitTestCase.assertNotNull(section.index);
     JUnitTestCase.assertNotNull(section.rightBracket);
   }
   void test_parseCascadeSection_ia() {
     FunctionExpressionInvocation section = ParserTestCase.parse5("parseCascadeSection", "..[i](b)", []);
     EngineTestCase.assertInstanceOf(IndexExpression, section.function);
     JUnitTestCase.assertNotNull(section.argumentList);
   }
   void test_parseCascadeSection_p() {
@@ skipping 2353 matching lines @@
     JUnitTestCase.assertEquals(TokenType.MINUS_MINUS, expression.operator.type);
   }
   void test_parsePostfixExpression_increment() {
     PostfixExpression expression = ParserTestCase.parse5("parsePostfixExpression", "i++", []);
     JUnitTestCase.assertNotNull(expression.operand);
     JUnitTestCase.assertNotNull(expression.operator);
     JUnitTestCase.assertEquals(TokenType.PLUS_PLUS, expression.operator.type);
   }
   void test_parsePostfixExpression_none_indexExpression() {
     IndexExpression expression = ParserTestCase.parse5("parsePostfixExpression", "a[0]", []);
-    JUnitTestCase.assertNotNull(expression.array);
+    JUnitTestCase.assertNotNull(expression.target);
     JUnitTestCase.assertNotNull(expression.index);
   }
   void test_parsePostfixExpression_none_methodInvocation() {
     MethodInvocation expression = ParserTestCase.parse5("parsePostfixExpression", "a.m()", []);
     JUnitTestCase.assertNotNull(expression.target);
     JUnitTestCase.assertNotNull(expression.methodName);
     JUnitTestCase.assertNotNull(expression.argumentList);
   }
   void test_parsePostfixExpression_none_propertyAccess() {
     PrefixedIdentifier expression = ParserTestCase.parse5("parsePostfixExpression", "a.b", []);
@@ skipping 348 matching lines @@
     JUnitTestCase.assertNotNull(statement.expression);
     JUnitTestCase.assertNotNull(statement.rightParenthesis);
     JUnitTestCase.assertNotNull(statement.leftBracket);
     EngineTestCase.assertSize(1, statement.members);
     EngineTestCase.assertSize(3, statement.members[0].statements);
     JUnitTestCase.assertNotNull(statement.rightBracket);
   }
   void test_parseSymbolLiteral_multiple() {
     SymbolLiteral literal = ParserTestCase.parse5("parseSymbolLiteral", "#a.b.c", []);
     JUnitTestCase.assertNotNull(literal.poundSign);
-    NodeList<SimpleIdentifier> components = literal.components;
-    EngineTestCase.assertSize(3, components);
-    JUnitTestCase.assertEquals("a", components[0].name);
-    JUnitTestCase.assertEquals("b", components[1].name);
-    JUnitTestCase.assertEquals("c", components[2].name);
+    List<Token> components = literal.components;
+    EngineTestCase.assertLength(3, components);
+    JUnitTestCase.assertEquals("a", components[0].lexeme);
+    JUnitTestCase.assertEquals("b", components[1].lexeme);
+    JUnitTestCase.assertEquals("c", components[2].lexeme);
+  }
+  void test_parseSymbolLiteral_operator() {
+    SymbolLiteral literal = ParserTestCase.parse5("parseSymbolLiteral", "#==", []);
+    JUnitTestCase.assertNotNull(literal.poundSign);
+    List<Token> components = literal.components;
+    EngineTestCase.assertLength(1, components);
+    JUnitTestCase.assertEquals("==", components[0].lexeme);
   }
   void test_parseSymbolLiteral_single() {
     SymbolLiteral literal = ParserTestCase.parse5("parseSymbolLiteral", "#a", []);
     JUnitTestCase.assertNotNull(literal.poundSign);
-    NodeList<SimpleIdentifier> components = literal.components;
-    EngineTestCase.assertSize(1, components);
-    JUnitTestCase.assertEquals("a", components[0].name);
+    List<Token> components = literal.components;
+    EngineTestCase.assertLength(1, components);
+    JUnitTestCase.assertEquals("a", components[0].lexeme);
   }
   void test_parseThrowExpression() {
     ThrowExpression expression = ParserTestCase.parse5("parseThrowExpression", "throw x;", []);
     JUnitTestCase.assertNotNull(expression.keyword);
     JUnitTestCase.assertNotNull(expression.expression);
   }
   void test_parseThrowExpressionWithoutCascade() {
     ThrowExpression expression = ParserTestCase.parse5("parseThrowExpressionWithoutCascade", "throw x;", []);
     JUnitTestCase.assertNotNull(expression.keyword);
     JUnitTestCase.assertNotNull(expression.expression);
@@ skipping 524 matching lines @@
   void test_skipTypeName_simple() {
     Token following = skip("skipTypeName", "C +");
     JUnitTestCase.assertNotNull(following);
     JUnitTestCase.assertEquals(TokenType.PLUS, following.type);
   }
 
   /**
    * 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) {
-    AnalysisErrorListener listener = new AnalysisErrorListener_21();
+  String computeStringValue(String lexeme, bool first, bool last) {
+    AnalysisErrorListener listener = new AnalysisErrorListener_22();
     Parser parser = new Parser(null, listener);
-    return invokeParserMethodImpl(parser, "computeStringValue", <Object> [lexeme], null) as String;
+    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
    * @throws Exception if the method could not be invoked or throws an exception
    */
@@ skipping 150 matching lines @@
         runJUnitTest(__test, __test.test_computeStringValue_raw_single);
       });
       _ut.test('test_computeStringValue_raw_triple', () {
         final __test = new SimpleParserTest();
         runJUnitTest(__test, __test.test_computeStringValue_raw_triple);
       });
       _ut.test('test_computeStringValue_raw_withEscape', () {
         final __test = new SimpleParserTest();
         runJUnitTest(__test, __test.test_computeStringValue_raw_withEscape);
       });
+      _ut.test('test_computeStringValue_triple_internalQuote_first_empty', () {
+        final __test = new SimpleParserTest();
+        runJUnitTest(__test, __test.test_computeStringValue_triple_internalQuote_first_empty);
+      });
+      _ut.test('test_computeStringValue_triple_internalQuote_first_nonEmpty', () {
+        final __test = new SimpleParserTest();
+        runJUnitTest(__test, __test.test_computeStringValue_triple_internalQuote_first_nonEmpty);
+      });
+      _ut.test('test_computeStringValue_triple_internalQuote_last_empty', () {
+        final __test = new SimpleParserTest();
+        runJUnitTest(__test, __test.test_computeStringValue_triple_internalQuote_last_empty);
+      });
+      _ut.test('test_computeStringValue_triple_internalQuote_last_nonEmpty', () {
+        final __test = new SimpleParserTest();
+        runJUnitTest(__test, __test.test_computeStringValue_triple_internalQuote_last_nonEmpty);
+      });
       _ut.test('test_constFactory', () {
         final __test = new SimpleParserTest();
         runJUnitTest(__test, __test.test_constFactory);
       });
       _ut.test('test_createSyntheticIdentifier', () {
         final __test = new SimpleParserTest();
         runJUnitTest(__test, __test.test_createSyntheticIdentifier);
       });
       _ut.test('test_createSyntheticStringLiteral', () {
         final __test = new SimpleParserTest();
@@ skipping 1704 matching lines @@
         runJUnitTest(__test, __test.test_parseSwitchStatement_labeledCase);
       });
       _ut.test('test_parseSwitchStatement_labeledStatementInCase', () {
         final __test = new SimpleParserTest();
         runJUnitTest(__test, __test.test_parseSwitchStatement_labeledStatementInCase);
       });
       _ut.test('test_parseSymbolLiteral_multiple', () {
         final __test = new SimpleParserTest();
         runJUnitTest(__test, __test.test_parseSymbolLiteral_multiple);
       });
+      _ut.test('test_parseSymbolLiteral_operator', () {
+        final __test = new SimpleParserTest();
+        runJUnitTest(__test, __test.test_parseSymbolLiteral_operator);
+      });
       _ut.test('test_parseSymbolLiteral_single', () {
         final __test = new SimpleParserTest();
         runJUnitTest(__test, __test.test_parseSymbolLiteral_single);
       });
       _ut.test('test_parseThrowExpression', () {
         final __test = new SimpleParserTest();
         runJUnitTest(__test, __test.test_parseThrowExpression);
       });
       _ut.test('test_parseThrowExpressionWithoutCascade', () {
         final __test = new SimpleParserTest();
@@ skipping 291 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_21 implements AnalysisErrorListener {
+class AnalysisErrorListener_22 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 3270 matching lines @@
   RecoveryParserTest.dartSuite();
   SimpleParserTest.dartSuite();
 }
 Map<String, MethodTrampoline> _methodTable_Parser = <String, MethodTrampoline> {
   'parseCompilationUnit_1': new MethodTrampoline(1, (Parser target, arg0) => target.parseCompilationUnit(arg0)),
   'parseExpression_1': new MethodTrampoline(1, (Parser target, arg0) => target.parseExpression(arg0)),
   'parseStatement_1': new MethodTrampoline(1, (Parser target, arg0) => target.parseStatement(arg0)),
   'parseStatements_1': new MethodTrampoline(1, (Parser target, arg0) => target.parseStatements(arg0)),
   'advance_0': new MethodTrampoline(0, (Parser target) => target.advance()),
   'appendScalarValue_5': new MethodTrampoline(5, (Parser target, arg0, arg1, arg2, arg3, arg4) => target.appendScalarValue(arg0, arg1, arg2, arg3, arg4)),
-  'computeStringValue_1': new MethodTrampoline(1, (Parser target, arg0) => target.computeStringValue(arg0)),
+  'computeStringValue_3': new MethodTrampoline(3, (Parser target, arg0, arg1, arg2) => target.computeStringValue(arg0, arg1, arg2)),
   'convertToFunctionDeclaration_1': new MethodTrampoline(1, (Parser target, arg0) => target.convertToFunctionDeclaration(arg0)),
   'couldBeStartOfCompilationUnitMember_0': new MethodTrampoline(0, (Parser target) => target.couldBeStartOfCompilationUnitMember()),
   'createSyntheticIdentifier_0': new MethodTrampoline(0, (Parser target) => target.createSyntheticIdentifier()),
   'createSyntheticStringLiteral_0': new MethodTrampoline(0, (Parser target) => target.createSyntheticStringLiteral()),
   'createSyntheticToken_1': new MethodTrampoline(1, (Parser target, arg0) => target.createSyntheticToken(arg0)),
   'ensureAssignable_1': new MethodTrampoline(1, (Parser target, arg0) => target.ensureAssignable(arg0)),
   'expect_1': new MethodTrampoline(1, (Parser target, arg0) => target.expect(arg0)),
   'findRange_2': new MethodTrampoline(2, (Parser target, arg0, arg1) => target.findRange(arg0, arg1)),
   'getCodeBlockRanges_1': new MethodTrampoline(1, (Parser target, arg0) => target.getCodeBlockRanges(arg0)),
   'getEndToken_1': new MethodTrampoline(1, (Parser target, arg0) => target.getEndToken(arg0)),
@@ skipping 151 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);
 }