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 481 matching lines @@
   }
 
   void test_parseAssignableSelector_index() {
     IndexExpression selector = ParserTestCase.parse("parseAssignableSelector", <Object> [null, true], "[x]");
     JUnitTestCase.assertNotNull(selector.leftBracket);
     JUnitTestCase.assertNotNull(selector.index);
     JUnitTestCase.assertNotNull(selector.rightBracket);
   }
 
   void test_parseAssignableSelector_none() {
-    SimpleIdentifier selector = ParserTestCase.parse("parseAssignableSelector", <Object> [new SimpleIdentifier.full(null), true], ";");
+    SimpleIdentifier selector = ParserTestCase.parse("parseAssignableSelector", <Object> [new SimpleIdentifier(null), true], ";");
     JUnitTestCase.assertNotNull(selector);
   }
 
   void test_parseBitwiseAndExpression_normal() {
     BinaryExpression expression = ParserTestCase.parse5("parseBitwiseAndExpression", "x & y", []);
     JUnitTestCase.assertNotNull(expression.leftOperand);
     JUnitTestCase.assertNotNull(expression.operator);
     JUnitTestCase.assertEquals(TokenType.AMPERSAND, expression.operator.type);
     JUnitTestCase.assertNotNull(expression.rightOperand);
   }
@@ skipping 2018 matching lines @@
   }
 
   void test_parseFunctionBody_skip_expression() {
     ParserTestCase._parseFunctionBodies = false;
     FunctionBody functionBody = ParserTestCase.parse("parseFunctionBody", <Object> [false, null, false], "=> y;");
     EngineTestCase.assertInstanceOf(EmptyFunctionBody, functionBody);
   }
 
   void test_parseFunctionDeclaration_function() {
     Comment comment = Comment.createDocumentationComment(new List<Token>(0));
-    TypeName returnType = new TypeName.full(new SimpleIdentifier.full(null), null);
+    TypeName returnType = new TypeName(new SimpleIdentifier(null), null);
     FunctionDeclaration declaration = ParserTestCase.parse("parseFunctionDeclaration", <Object> [commentAndMetadata(comment, []), null, returnType], "f() {}");
     JUnitTestCase.assertEquals(comment, declaration.documentationComment);
     JUnitTestCase.assertEquals(returnType, declaration.returnType);
     JUnitTestCase.assertNotNull(declaration.name);
     FunctionExpression expression = declaration.functionExpression;
     JUnitTestCase.assertNotNull(expression);
     JUnitTestCase.assertNotNull(expression.body);
     JUnitTestCase.assertNotNull(expression.parameters);
     JUnitTestCase.assertNull(declaration.propertyKeyword);
   }
 
   void test_parseFunctionDeclaration_getter() {
     Comment comment = Comment.createDocumentationComment(new List<Token>(0));
-    TypeName returnType = new TypeName.full(new SimpleIdentifier.full(null), null);
+    TypeName returnType = new TypeName(new SimpleIdentifier(null), null);
     FunctionDeclaration declaration = ParserTestCase.parse("parseFunctionDeclaration", <Object> [commentAndMetadata(comment, []), null, returnType], "get p => 0;");
     JUnitTestCase.assertEquals(comment, declaration.documentationComment);
     JUnitTestCase.assertEquals(returnType, declaration.returnType);
     JUnitTestCase.assertNotNull(declaration.name);
     FunctionExpression expression = declaration.functionExpression;
     JUnitTestCase.assertNotNull(expression);
     JUnitTestCase.assertNotNull(expression.body);
     JUnitTestCase.assertNull(expression.parameters);
     JUnitTestCase.assertNotNull(declaration.propertyKeyword);
   }
 
   void test_parseFunctionDeclaration_setter() {
     Comment comment = Comment.createDocumentationComment(new List<Token>(0));
-    TypeName returnType = new TypeName.full(new SimpleIdentifier.full(null), null);
+    TypeName returnType = new TypeName(new SimpleIdentifier(null), null);
     FunctionDeclaration declaration = ParserTestCase.parse("parseFunctionDeclaration", <Object> [commentAndMetadata(comment, []), null, returnType], "set p(v) {}");
     JUnitTestCase.assertEquals(comment, declaration.documentationComment);
     JUnitTestCase.assertEquals(returnType, declaration.returnType);
     JUnitTestCase.assertNotNull(declaration.name);
     FunctionExpression expression = declaration.functionExpression;
     JUnitTestCase.assertNotNull(expression);
     JUnitTestCase.assertNotNull(expression.body);
     JUnitTestCase.assertNotNull(expression.parameters);
     JUnitTestCase.assertNotNull(declaration.propertyKeyword);
   }
@@ skipping 11 matching lines @@
   }
 
   void test_parseFunctionExpression_minimal() {
     FunctionExpression expression = ParserTestCase.parse5("parseFunctionExpression", "() {}", []);
     JUnitTestCase.assertNotNull(expression.body);
     JUnitTestCase.assertNotNull(expression.parameters);
   }
 
   void test_parseGetter_nonStatic() {
     Comment comment = Comment.createDocumentationComment(new List<Token>(0));
-    TypeName returnType = new TypeName.full(new SimpleIdentifier.full(null), null);
+    TypeName returnType = new TypeName(new SimpleIdentifier(null), null);
     MethodDeclaration method = ParserTestCase.parse("parseGetter", <Object> [commentAndMetadata(comment, []), null, null, returnType], "get a;");
     JUnitTestCase.assertNotNull(method.body);
     JUnitTestCase.assertEquals(comment, method.documentationComment);
     JUnitTestCase.assertNull(method.externalKeyword);
     JUnitTestCase.assertNull(method.modifierKeyword);
     JUnitTestCase.assertNotNull(method.name);
     JUnitTestCase.assertNull(method.operatorKeyword);
     JUnitTestCase.assertNull(method.parameters);
     JUnitTestCase.assertNotNull(method.propertyKeyword);
     JUnitTestCase.assertEquals(returnType, method.returnType);
   }
 
   void test_parseGetter_static() {
     Comment comment = Comment.createDocumentationComment(new List<Token>(0));
     Token staticKeyword = TokenFactory.token(Keyword.STATIC);
-    TypeName returnType = new TypeName.full(new SimpleIdentifier.full(null), null);
+    TypeName returnType = new TypeName(new SimpleIdentifier(null), null);
     MethodDeclaration method = ParserTestCase.parse("parseGetter", <Object> [
         commentAndMetadata(comment, []),
         null,
         staticKeyword,
         returnType], "get a => 42;");
     JUnitTestCase.assertNotNull(method.body);
     JUnitTestCase.assertEquals(comment, method.documentationComment);
     JUnitTestCase.assertNull(method.externalKeyword);
     JUnitTestCase.assertEquals(staticKeyword, method.modifierKeyword);
     JUnitTestCase.assertNotNull(method.name);
@@ skipping 125 matching lines @@
     JUnitTestCase.assertNotNull(directive.uri);
     JUnitTestCase.assertNull(directive.asToken);
     JUnitTestCase.assertNull(directive.prefix);
     EngineTestCase.assertSize(1, directive.combinators);
     JUnitTestCase.assertNotNull(directive.semicolon);
   }
 
   void test_parseInitializedIdentifierList_type() {
     Comment comment = Comment.createDocumentationComment(new List<Token>(0));
     Token staticKeyword = TokenFactory.token(Keyword.STATIC);
-    TypeName type = new TypeName.full(new SimpleIdentifier.full(null), null);
+    TypeName type = new TypeName(new SimpleIdentifier(null), null);
     FieldDeclaration declaration = ParserTestCase.parse("parseInitializedIdentifierList", <Object> [
         commentAndMetadata(comment, []),
         staticKeyword,
         null,
         type], "a = 1, b, c = 3;");
     JUnitTestCase.assertEquals(comment, declaration.documentationComment);
     VariableDeclarationList fields = declaration.fields;
     JUnitTestCase.assertNotNull(fields);
     JUnitTestCase.assertNull(fields.keyword);
     JUnitTestCase.assertEquals(type, fields.type);
@@ skipping 514 matching lines @@
 
   void test_parseNormalFormalParameter_simple_type() {
     SimpleFormalParameter parameter = ParserTestCase.parse5("parseNormalFormalParameter", "A a)", []);
     JUnitTestCase.assertNull(parameter.keyword);
     JUnitTestCase.assertNotNull(parameter.type);
     JUnitTestCase.assertNotNull(parameter.identifier);
   }
 
   void test_parseOperator() {
     Comment comment = Comment.createDocumentationComment(new List<Token>(0));
-    TypeName returnType = new TypeName.full(new SimpleIdentifier.full(null), null);
+    TypeName returnType = new TypeName(new SimpleIdentifier(null), null);
     MethodDeclaration method = ParserTestCase.parse("parseOperator", <Object> [commentAndMetadata(comment, []), null, returnType], "operator +(A a);");
     JUnitTestCase.assertNotNull(method.body);
     JUnitTestCase.assertEquals(comment, method.documentationComment);
     JUnitTestCase.assertNull(method.externalKeyword);
     JUnitTestCase.assertNull(method.modifierKeyword);
     JUnitTestCase.assertNotNull(method.name);
     JUnitTestCase.assertNotNull(method.operatorKeyword);
     JUnitTestCase.assertNotNull(method.parameters);
     JUnitTestCase.assertNull(method.propertyKeyword);
     JUnitTestCase.assertEquals(returnType, method.returnType);
@@ skipping 266 matching lines @@
   }
 
   void test_parseReturnType_void() {
     TypeName typeName = ParserTestCase.parse5("parseReturnType", "void", []);
     JUnitTestCase.assertNotNull(typeName.name);
     JUnitTestCase.assertNull(typeName.typeArguments);
   }
 
   void test_parseSetter_nonStatic() {
     Comment comment = Comment.createDocumentationComment(new List<Token>(0));
-    TypeName returnType = new TypeName.full(new SimpleIdentifier.full(null), null);
+    TypeName returnType = new TypeName(new SimpleIdentifier(null), null);
     MethodDeclaration method = ParserTestCase.parse("parseSetter", <Object> [commentAndMetadata(comment, []), null, null, returnType], "set a(var x);");
     JUnitTestCase.assertNotNull(method.body);
     JUnitTestCase.assertEquals(comment, method.documentationComment);
     JUnitTestCase.assertNull(method.externalKeyword);
     JUnitTestCase.assertNull(method.modifierKeyword);
     JUnitTestCase.assertNotNull(method.name);
     JUnitTestCase.assertNull(method.operatorKeyword);
     JUnitTestCase.assertNotNull(method.parameters);
     JUnitTestCase.assertNotNull(method.propertyKeyword);
     JUnitTestCase.assertEquals(returnType, method.returnType);
   }
 
   void test_parseSetter_static() {
     Comment comment = Comment.createDocumentationComment(new List<Token>(0));
     Token staticKeyword = TokenFactory.token(Keyword.STATIC);
-    TypeName returnType = new TypeName.full(new SimpleIdentifier.full(null), null);
+    TypeName returnType = new TypeName(new SimpleIdentifier(null), null);
     MethodDeclaration method = ParserTestCase.parse("parseSetter", <Object> [
         commentAndMetadata(comment, []),
         null,
         staticKeyword,
         returnType], "set a(var x) {}");
     JUnitTestCase.assertNotNull(method.body);
     JUnitTestCase.assertEquals(comment, method.documentationComment);
     JUnitTestCase.assertNull(method.externalKeyword);
     JUnitTestCase.assertEquals(staticKeyword, method.modifierKeyword);
     JUnitTestCase.assertNotNull(method.name);
@@ skipping 615 matching lines @@
   }
 
   void test_parseVariableDeclarationList_var_single() {
     VariableDeclarationList declarationList = ParserTestCase.parse("parseVariableDeclarationList", <Object> [emptyCommentAndMetadata()], "var a");
     JUnitTestCase.assertNotNull(declarationList.keyword);
     JUnitTestCase.assertNull(declarationList.type);
     EngineTestCase.assertSize(1, declarationList.variables);
   }
 
   void test_parseVariableDeclarationList2_type() {
-    TypeName type = new TypeName.full(new SimpleIdentifier.full(null), null);
+    TypeName type = new TypeName(new SimpleIdentifier(null), null);
     VariableDeclarationList declarationList = ParserTestCase.parse("parseVariableDeclarationList", <Object> [emptyCommentAndMetadata(), null, type], "a");
     JUnitTestCase.assertNull(declarationList.keyword);
     JUnitTestCase.assertEquals(type, declarationList.type);
     EngineTestCase.assertSize(1, declarationList.variables);
   }
 
   void test_parseVariableDeclarationList2_var() {
     Token keyword = TokenFactory.token(Keyword.VAR);
     VariableDeclarationList declarationList = ParserTestCase.parse("parseVariableDeclarationList", <Object> [emptyCommentAndMetadata(), keyword, null], "a, b, c");
     JUnitTestCase.assertEquals(keyword, declarationList.keyword);
@@ skipping 149 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_26();
+    AnalysisErrorListener listener = new AnalysisErrorListener_27();
     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 2249 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_26 implements AnalysisErrorListener {
+class AnalysisErrorListener_27 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 2448 matching lines @@
       });
       _ut.test('test_typedef_eof', () {
         final __test = new RecoveryParserTest();
         runJUnitTest(__test, __test.test_typedef_eof);
       });
     });
   }
 }
 
 class IncrementalParserTest extends EngineTestCase {
-  void fail_delete_everything() {
+  void test_delete_everything() {
     assertParse("", "f() => a + b;", "", "");
   }
 
   void test_delete_identifier_beginning() {
     assertParse("f() => ", "ab", "", "s + b;");
   }
 
   void test_delete_identifier_end() {
     assertParse("f() => a", "bs", "", " + b;");
   }
@@ skipping 35 matching lines @@
   }
 
   void test_insert_newIdentifier1() {
     assertParse("f() => a;", "", " b", " c;");
   }
 
   void test_insert_newIdentifier2() {
     assertParse("f() => a;", "", "b", "  c;");
   }
 
+  void test_insert_newIdentifier3() {
+    assertParse("/** A simple function. */ f() => a;", "", " b", " c;");
+  }
+
+  void test_insert_newIdentifier4() {
+    assertParse("/** An [A]. */ class A {} class B { m() { return 1", "", " + 2", "; } }");
+  }
+
   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;");
   }
 
   void test_insert_periodAndIdentifier() {
     assertParse("f() => a + b", "", ".x", ";");
   }
 
+  void test_insert_simpleToComplexExression() {
+    assertParse("/** An [A]. */ class A {} class B { m() => 1", "", " + 2", "; }");
+  }
+
   void test_insert_whitespace_end() {
     assertParse("f() => a + b;", "", " ", "");
   }
 
   void test_insert_whitespace_end_multiple() {
     assertParse("f() => a + b;", "", "  ", "");
   }
 
   void test_insert_whitespace_middle() {
     assertParse("f() => a", "", " ", " + b;");
@@ skipping 56 matching lines @@
     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.leftToken, incrementalScanner.rightToken, replaceStart, prefix.length + removed.length);
     JUnitTestCase.assertNotNull(incrementalUnit);
     JUnitTestCase.assertTrue(ASTComparator.equals4(modifiedUnit, incrementalUnit));
   }
 
   static dartSuite() {
     _ut.group('IncrementalParserTest', () {
+      _ut.test('test_delete_everything', () {
+        final __test = new IncrementalParserTest();
+        runJUnitTest(__test, __test.test_delete_everything);
+      });
       _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();
@@ skipping 32 matching lines @@
         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_newIdentifier3', () {
+        final __test = new IncrementalParserTest();
+        runJUnitTest(__test, __test.test_insert_newIdentifier3);
+      });
+      _ut.test('test_insert_newIdentifier4', () {
+        final __test = new IncrementalParserTest();
+        runJUnitTest(__test, __test.test_insert_newIdentifier4);
+      });
       _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();
         runJUnitTest(__test, __test.test_insert_period_insideExistingIdentifier);
       });
+      _ut.test('test_insert_simpleToComplexExression', () {
+        final __test = new IncrementalParserTest();
+        runJUnitTest(__test, __test.test_insert_simpleToComplexExression);
+      });
       _ut.test('test_insert_whitespace_end', () {
         final __test = new IncrementalParserTest();
         runJUnitTest(__test, __test.test_insert_whitespace_end);
       });
       _ut.test('test_insert_whitespace_end_multiple', () {
         final __test = new IncrementalParserTest();
         runJUnitTest(__test, __test.test_insert_whitespace_end_multiple);
       });
       _ut.test('test_insert_whitespace_middle', () {
         final __test = new IncrementalParserTest();
@@ skipping 2216 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);
 }