New 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 4361 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_25();
+    AnalysisErrorListener listener = new AnalysisErrorListener_26();
     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 2233 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_25 implements AnalysisErrorListener {
+class AnalysisErrorListener_26 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();");
+  }
+
+  static dartSuite() {
+    _ut.group('NonErrorParserTest', () {
+      _ut.test('test_constFactory_external', () {
+        final __test = new NonErrorParserTest();
+        runJUnitTest(__test, __test.test_constFactory_external);
+      });
+    });
+  }
+}
+
 /**
  * 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].
  */
 class ComplexParserTest extends ParserTestCase {
   void test_additiveExpression_normal() {
     BinaryExpression expression = ParserTestCase.parseExpression("x + y - z", []);
@@ skipping 2417 matching lines @@
       });
       _ut.test('test_typedef_eof', () {
         final __test = new RecoveryParserTest();
         runJUnitTest(__test, __test.test_typedef_eof);
       });
     });
   }
 }
 
 class IncrementalParserTest extends EngineTestCase {
-  void fail_delete_identifier_beginning() {
+  void fail_delete_everything() {
+    assertParse("", "f() => a + b;", "", "");
+  }
+
+  void test_delete_identifier_beginning() {
     assertParse("f() => ", "ab", "", "s + b;");
   }
 
-  void fail_delete_mergeTokens() {
-    assertParse("f() => a", " + b + ", "", "c;");
-  }
-
-  void fail_insert_convertOneFunctionToTwo() {
-    assertParse("f()", "", " => 0; g()", " {}");
-  }
-
-  void fail_insert_period_betweenIdentifiers1() {
-    assertParse("f() => a", "", ".", " b;");
-  }
-
-  void fail_replace_multiple_partialFirstAndLast() {
-    assertParse("f() => a", "a + b", "b * a", "b;");
-  }
-
   void test_delete_identifier_end() {
     assertParse("f() => a", "bs", "", " + b;");
   }
 
   void test_delete_identifier_middle() {
     assertParse("f() => a", "b", "", "s + b;");
   }
 
+  void test_delete_mergeTokens() {
+    assertParse("f() => a", " + b + ", "", "c;");
+  }
+
   void test_insert_afterIdentifier1() {
     assertParse("f() => a", "", "bs", " + b;");
   }
 
   void test_insert_afterIdentifier2() {
     assertParse("f() => a + b", "", "ar", ";");
   }
 
   void test_insert_beforeIdentifier1() {
     assertParse("f() => ", "", "x", "a + b;");
   }
 
   void test_insert_beforeIdentifier2() {
     assertParse("f() => a + ", "", "x", "b;");
   }
 
+  void test_insert_convertOneFunctionToTwo() {
+    assertParse("f()", "", " => 0; g()", " {}");
+  }
+
+  void test_insert_end() {
+    assertParse("class A {}", "", " class B {}", "");
+  }
+
+  void test_insert_insideIdentifier() {
+    assertParse("f() => co", "", "w.", "b;");
+  }
+
   void test_insert_newIdentifier1() {
     assertParse("f() => a;", "", " b", " c;");
   }
 
   void test_insert_newIdentifier2() {
     assertParse("f() => a;", "", "b", "  c;");
   }
 
   void test_insert_period() {
     assertParse("f() => a + b", "", ".", ";");
   }
 
+  void test_insert_period_betweenIdentifiers1() {
+    assertParse("f() => a", "", ".", " b;");
+  }
+
   void test_insert_period_betweenIdentifiers2() {
     assertParse("f() => a ", "", ".", "b;");
   }
 
   void test_insert_period_betweenIdentifiers3() {
     assertParse("f() => a ", "", ".", " b;");
   }
 
   void test_insert_period_insideExistingIdentifier() {
     assertParse("f() => a", "", ".", "b;");
@@ skipping 20 matching lines @@
   }
 
   void test_replace_identifier_end() {
     assertParse("f() => bel", "l", "t", " + b;");
   }
 
   void test_replace_identifier_middle() {
     assertParse("f() => f", "ir", "ro", "st + b;");
   }
 
+  void test_replace_multiple_partialFirstAndLast() {
+    assertParse("f() => a", "a + b", "b * a", "b;");
+  }
+
   void test_replace_operator_oneForMany() {
     assertParse("f() => a ", "+", "* c -", " b;");
   }
 
   void test_replace_operator_oneForOne() {
     assertParse("f() => a ", "+", "*", " b;");
   }
 
   /**
    * Given a description of the original and modified contents, perform an incremental scan of the
@@ skipping 21 matching lines @@
     Token modifiedTokens = modifiedScanner.tokenize();
     JUnitTestCase.assertNotNull(modifiedTokens);
     Parser modifiedParser = new Parser(source, modifiedListener);
     CompilationUnit modifiedUnit = modifiedParser.parseCompilationUnit(modifiedTokens);
     JUnitTestCase.assertNotNull(modifiedUnit);
     GatheringErrorListener incrementalListener = new GatheringErrorListener();
     IncrementalScanner incrementalScanner = new IncrementalScanner(source, new CharSequenceReader(new CharSequence(modifiedContents)), incrementalListener);
     Token incrementalTokens = incrementalScanner.rescan(originalTokens, replaceStart, removed.length, added.length);
     JUnitTestCase.assertNotNull(incrementalTokens);
     IncrementalParser incrementalParser = new IncrementalParser(source, incrementalScanner.tokenMap, incrementalListener);
-    CompilationUnit incrementalUnit = incrementalParser.reparse(originalUnit, incrementalScanner.firstToken, incrementalScanner.lastToken, replaceStart, prefix.length + removed.length);
+    CompilationUnit incrementalUnit = incrementalParser.reparse(originalUnit, incrementalScanner.leftToken, incrementalScanner.rightToken, replaceStart, prefix.length + removed.length);
     JUnitTestCase.assertNotNull(incrementalUnit);
-    JUnitTestCase.assertTrue(ASTComparator.equals3(modifiedUnit, incrementalUnit));
+    JUnitTestCase.assertTrue(ASTComparator.equals4(modifiedUnit, incrementalUnit));
   }
 
   static dartSuite() {
     _ut.group('IncrementalParserTest', () {
+      _ut.test('test_delete_identifier_beginning', () {
+        final __test = new IncrementalParserTest();
+        runJUnitTest(__test, __test.test_delete_identifier_beginning);
+      });
       _ut.test('test_delete_identifier_end', () {
         final __test = new IncrementalParserTest();
         runJUnitTest(__test, __test.test_delete_identifier_end);
       });
       _ut.test('test_delete_identifier_middle', () {
         final __test = new IncrementalParserTest();
         runJUnitTest(__test, __test.test_delete_identifier_middle);
       });
+      _ut.test('test_delete_mergeTokens', () {
+        final __test = new IncrementalParserTest();
+        runJUnitTest(__test, __test.test_delete_mergeTokens);
+      });
       _ut.test('test_insert_afterIdentifier1', () {
         final __test = new IncrementalParserTest();
         runJUnitTest(__test, __test.test_insert_afterIdentifier1);
       });
       _ut.test('test_insert_afterIdentifier2', () {
         final __test = new IncrementalParserTest();
         runJUnitTest(__test, __test.test_insert_afterIdentifier2);
       });
       _ut.test('test_insert_beforeIdentifier1', () {
         final __test = new IncrementalParserTest();
         runJUnitTest(__test, __test.test_insert_beforeIdentifier1);
       });
       _ut.test('test_insert_beforeIdentifier2', () {
         final __test = new IncrementalParserTest();
         runJUnitTest(__test, __test.test_insert_beforeIdentifier2);
       });
+      _ut.test('test_insert_convertOneFunctionToTwo', () {
+        final __test = new IncrementalParserTest();
+        runJUnitTest(__test, __test.test_insert_convertOneFunctionToTwo);
+      });
+      _ut.test('test_insert_end', () {
+        final __test = new IncrementalParserTest();
+        runJUnitTest(__test, __test.test_insert_end);
+      });
+      _ut.test('test_insert_insideIdentifier', () {
+        final __test = new IncrementalParserTest();
+        runJUnitTest(__test, __test.test_insert_insideIdentifier);
+      });
       _ut.test('test_insert_newIdentifier1', () {
         final __test = new IncrementalParserTest();
         runJUnitTest(__test, __test.test_insert_newIdentifier1);
       });
       _ut.test('test_insert_newIdentifier2', () {
         final __test = new IncrementalParserTest();
         runJUnitTest(__test, __test.test_insert_newIdentifier2);
       });
       _ut.test('test_insert_period', () {
         final __test = new IncrementalParserTest();
         runJUnitTest(__test, __test.test_insert_period);
       });
       _ut.test('test_insert_periodAndIdentifier', () {
         final __test = new IncrementalParserTest();
         runJUnitTest(__test, __test.test_insert_periodAndIdentifier);
       });
+      _ut.test('test_insert_period_betweenIdentifiers1', () {
+        final __test = new IncrementalParserTest();
+        runJUnitTest(__test, __test.test_insert_period_betweenIdentifiers1);
+      });
       _ut.test('test_insert_period_betweenIdentifiers2', () {
         final __test = new IncrementalParserTest();
         runJUnitTest(__test, __test.test_insert_period_betweenIdentifiers2);
       });
       _ut.test('test_insert_period_betweenIdentifiers3', () {
         final __test = new IncrementalParserTest();
         runJUnitTest(__test, __test.test_insert_period_betweenIdentifiers3);
       });
       _ut.test('test_insert_period_insideExistingIdentifier', () {
         final __test = new IncrementalParserTest();
@@ skipping 16 matching lines @@
         runJUnitTest(__test, __test.test_replace_identifier_beginning);
       });
       _ut.test('test_replace_identifier_end', () {
         final __test = new IncrementalParserTest();
         runJUnitTest(__test, __test.test_replace_identifier_end);
       });
       _ut.test('test_replace_identifier_middle', () {
         final __test = new IncrementalParserTest();
         runJUnitTest(__test, __test.test_replace_identifier_middle);
       });
+      _ut.test('test_replace_multiple_partialFirstAndLast', () {
+        final __test = new IncrementalParserTest();
+        runJUnitTest(__test, __test.test_replace_multiple_partialFirstAndLast);
+      });
       _ut.test('test_replace_operator_oneForMany', () {
         final __test = new IncrementalParserTest();
         runJUnitTest(__test, __test.test_replace_operator_oneForMany);
       });
       _ut.test('test_replace_operator_oneForOne', () {
         final __test = new IncrementalParserTest();
         runJUnitTest(__test, __test.test_replace_operator_oneForOne);
       });
     });
   }
@@ skipping 1998 matching lines @@
         runJUnitTest(__test, __test.test_wrongTerminatorForParameterGroup_optional);
       });
     });
   }
 }
 
 main() {
   ComplexParserTest.dartSuite();
   ErrorParserTest.dartSuite();
   IncrementalParserTest.dartSuite();
+  NonErrorParserTest.dartSuite();
   RecoveryParserTest.dartSuite();
   ResolutionCopierTest.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)),
   'parseAnnotation_0': new MethodTrampoline(0, (Parser target) => target.parseAnnotation()),
@@ skipping 30 matching lines @@
   'appendScalarValue_5': new MethodTrampoline(5, (Parser target, arg0, arg1, arg2, arg3, arg4) => target.appendScalarValue(arg0, arg1, arg2, arg3, arg4)),
   '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)),
-  'gatherTodoComments_1': new MethodTrampoline(1, (Parser target, arg0) => target.gatherTodoComments(arg0)),
   'getCodeBlockRanges_1': new MethodTrampoline(1, (Parser target, arg0) => target.getCodeBlockRanges(arg0)),
   'getEndToken_1': new MethodTrampoline(1, (Parser target, arg0) => target.getEndToken(arg0)),
   'hasReturnTypeInTypeAlias_0': new MethodTrampoline(0, (Parser target) => target.hasReturnTypeInTypeAlias()),
+  'injectToken_1': new MethodTrampoline(1, (Parser target, arg0) => target.injectToken(arg0)),
   'isFunctionDeclaration_0': new MethodTrampoline(0, (Parser target) => target.isFunctionDeclaration()),
   'isFunctionExpression_1': new MethodTrampoline(1, (Parser target, arg0) => target.isFunctionExpression(arg0)),
   'isHexDigit_1': new MethodTrampoline(1, (Parser target, arg0) => target.isHexDigit(arg0)),
   'isInitializedVariableDeclaration_0': new MethodTrampoline(0, (Parser target) => target.isInitializedVariableDeclaration()),
   'isLinkText_2': new MethodTrampoline(2, (Parser target, arg0, arg1) => target.isLinkText(arg0, arg1)),
   'isOperator_1': new MethodTrampoline(1, (Parser target, arg0) => target.isOperator(arg0)),
   'isSwitchMember_0': new MethodTrampoline(0, (Parser target) => target.isSwitchMember()),
   'isTypedIdentifier_1': new MethodTrampoline(1, (Parser target, arg0) => target.isTypedIdentifier(arg0)),
   'lexicallyFirst_1': new MethodTrampoline(1, (Parser target, arg0) => target.lexicallyFirst(arg0)),
   'matches_1': new MethodTrampoline(1, (Parser target, arg0) => target.matches(arg0)),
@@ skipping 81 matching lines @@
   'parseVariableDeclaration_0': new MethodTrampoline(0, (Parser target) => target.parseVariableDeclaration()),
   'parseVariableDeclarationList_1': new MethodTrampoline(1, (Parser target, arg0) => target.parseVariableDeclarationList(arg0)),
   'parseVariableDeclarationList_3': new MethodTrampoline(3, (Parser target, arg0, arg1, arg2) => target.parseVariableDeclarationList2(arg0, arg1, arg2)),
   'parseVariableDeclarationStatement_1': new MethodTrampoline(1, (Parser target, arg0) => target.parseVariableDeclarationStatement(arg0)),
   'parseVariableDeclarationStatement_3': new MethodTrampoline(3, (Parser target, arg0, arg1, arg2) => target.parseVariableDeclarationStatement2(arg0, arg1, arg2)),
   'parseWhileStatement_0': new MethodTrampoline(0, (Parser target) => target.parseWhileStatement()),
   'peek_0': new MethodTrampoline(0, (Parser target) => target.peek()),
   'peek_1': new MethodTrampoline(1, (Parser target, arg0) => target.peek2(arg0)),
   'reportError_3': new MethodTrampoline(3, (Parser target, arg0, arg1, arg2) => target.reportError(arg0, arg1, arg2)),
   'reportError_2': new MethodTrampoline(2, (Parser target, arg0, arg1) => target.reportError9(arg0, arg1)),
-  'scrapeTodoComment_1': new MethodTrampoline(1, (Parser target, arg0) => target.scrapeTodoComment(arg0)),
   'skipFinalConstVarOrType_1': new MethodTrampoline(1, (Parser target, arg0) => target.skipFinalConstVarOrType(arg0)),
   'skipFormalParameterList_1': new MethodTrampoline(1, (Parser target, arg0) => target.skipFormalParameterList(arg0)),
   'skipPastMatchingToken_1': new MethodTrampoline(1, (Parser target, arg0) => target.skipPastMatchingToken(arg0)),
   'skipPrefixedIdentifier_1': new MethodTrampoline(1, (Parser target, arg0) => target.skipPrefixedIdentifier(arg0)),
   'skipReturnType_1': new MethodTrampoline(1, (Parser target, arg0) => target.skipReturnType(arg0)),
   'skipSimpleIdentifier_1': new MethodTrampoline(1, (Parser target, arg0) => target.skipSimpleIdentifier(arg0)),
   'skipStringInterpolation_1': new MethodTrampoline(1, (Parser target, arg0) => target.skipStringInterpolation(arg0)),
   'skipStringLiteral_1': new MethodTrampoline(1, (Parser target, arg0) => target.skipStringLiteral(arg0)),
   'skipTypeArgumentList_1': new MethodTrampoline(1, (Parser target, arg0) => target.skipTypeArgumentList(arg0)),
   'skipTypeName_1': new MethodTrampoline(1, (Parser target, arg0) => target.skipTypeName(arg0)),
@@ skipping 10 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);
 }