New analyzer snapshot with MapIterator.

pkg/analyzer/test/generated/parser_test.dart

 // Copyright (c) 2014, the Dart project authors.  Please see the AUTHORS file
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 
 // 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';
@@ skipping 2727 matching lines @@
     EngineTestCase.assertSizeOfList(3, clause.interfaces);
     JUnitTestCase.assertNotNull(clause.keyword);
   }
 
   void test_parseImplementsClause_single() {
     ImplementsClause clause = ParserTestCase.parse4("parseImplementsClause", "implements A", []);
     EngineTestCase.assertSizeOfList(1, clause.interfaces);
     JUnitTestCase.assertNotNull(clause.keyword);
   }
 
+  void test_parseImportDirective_deferred() {
+    ImportDirective directive = ParserTestCase.parse("parseImportDirective", <Object> [emptyCommentAndMetadata()], "import 'lib/lib.dart' deferred as a;");
+    JUnitTestCase.assertNotNull(directive.keyword);
+    JUnitTestCase.assertNotNull(directive.uri);
+    JUnitTestCase.assertNotNull(directive.deferredToken);
+    JUnitTestCase.assertNotNull(directive.asToken);
+    JUnitTestCase.assertNotNull(directive.prefix);
+    EngineTestCase.assertSizeOfList(0, directive.combinators);
+    JUnitTestCase.assertNotNull(directive.semicolon);
+  }
+
   void test_parseImportDirective_hide() {
     ImportDirective directive = ParserTestCase.parse("parseImportDirective", <Object> [emptyCommentAndMetadata()], "import 'lib/lib.dart' hide A, B;");
     JUnitTestCase.assertNotNull(directive.keyword);
     JUnitTestCase.assertNotNull(directive.uri);
+    JUnitTestCase.assertNull(directive.deferredToken);
     JUnitTestCase.assertNull(directive.asToken);
     JUnitTestCase.assertNull(directive.prefix);
     EngineTestCase.assertSizeOfList(1, directive.combinators);
     JUnitTestCase.assertNotNull(directive.semicolon);
   }
 
   void test_parseImportDirective_noCombinator() {
     ImportDirective directive = ParserTestCase.parse("parseImportDirective", <Object> [emptyCommentAndMetadata()], "import 'lib/lib.dart';");
     JUnitTestCase.assertNotNull(directive.keyword);
     JUnitTestCase.assertNotNull(directive.uri);
+    JUnitTestCase.assertNull(directive.deferredToken);
     JUnitTestCase.assertNull(directive.asToken);
     JUnitTestCase.assertNull(directive.prefix);
     EngineTestCase.assertSizeOfList(0, directive.combinators);
     JUnitTestCase.assertNotNull(directive.semicolon);
   }
 
   void test_parseImportDirective_prefix() {
     ImportDirective directive = ParserTestCase.parse("parseImportDirective", <Object> [emptyCommentAndMetadata()], "import 'lib/lib.dart' as a;");
     JUnitTestCase.assertNotNull(directive.keyword);
     JUnitTestCase.assertNotNull(directive.uri);
+    JUnitTestCase.assertNull(directive.deferredToken);
     JUnitTestCase.assertNotNull(directive.asToken);
     JUnitTestCase.assertNotNull(directive.prefix);
     EngineTestCase.assertSizeOfList(0, directive.combinators);
     JUnitTestCase.assertNotNull(directive.semicolon);
   }
 
   void test_parseImportDirective_prefix_hide_show() {
     ImportDirective directive = ParserTestCase.parse("parseImportDirective", <Object> [emptyCommentAndMetadata()], "import 'lib/lib.dart' as a hide A show B;");
     JUnitTestCase.assertNotNull(directive.keyword);
     JUnitTestCase.assertNotNull(directive.uri);
+    JUnitTestCase.assertNull(directive.deferredToken);
     JUnitTestCase.assertNotNull(directive.asToken);
     JUnitTestCase.assertNotNull(directive.prefix);
     EngineTestCase.assertSizeOfList(2, directive.combinators);
     JUnitTestCase.assertNotNull(directive.semicolon);
   }
 
   void test_parseImportDirective_prefix_show_hide() {
     ImportDirective directive = ParserTestCase.parse("parseImportDirective", <Object> [emptyCommentAndMetadata()], "import 'lib/lib.dart' as a show B hide A;");
     JUnitTestCase.assertNotNull(directive.keyword);
     JUnitTestCase.assertNotNull(directive.uri);
+    JUnitTestCase.assertNull(directive.deferredToken);
     JUnitTestCase.assertNotNull(directive.asToken);
     JUnitTestCase.assertNotNull(directive.prefix);
     EngineTestCase.assertSizeOfList(2, directive.combinators);
     JUnitTestCase.assertNotNull(directive.semicolon);
   }
 
   void test_parseImportDirective_show() {
     ImportDirective directive = ParserTestCase.parse("parseImportDirective", <Object> [emptyCommentAndMetadata()], "import 'lib/lib.dart' show A, B;");
     JUnitTestCase.assertNotNull(directive.keyword);
     JUnitTestCase.assertNotNull(directive.uri);
+    JUnitTestCase.assertNull(directive.deferredToken);
     JUnitTestCase.assertNull(directive.asToken);
     JUnitTestCase.assertNull(directive.prefix);
     EngineTestCase.assertSizeOfList(1, directive.combinators);
     JUnitTestCase.assertNotNull(directive.semicolon);
   }
 
   void test_parseInitializedIdentifierList_type() {
     Comment comment = Comment.createDocumentationComment(new List<Token>(0));
     Token staticKeyword = TokenFactory.tokenFromKeyword(Keyword.STATIC);
     TypeName type = new TypeName(new SimpleIdentifier(null), null);
@@ skipping 3068 matching lines @@
         runJUnitTest(__test, __test.test_parseIfStatement_noElse_statement);
       });
       _ut.test('test_parseImplementsClause_multiple', () {
         final __test = new SimpleParserTest();
         runJUnitTest(__test, __test.test_parseImplementsClause_multiple);
       });
       _ut.test('test_parseImplementsClause_single', () {
         final __test = new SimpleParserTest();
         runJUnitTest(__test, __test.test_parseImplementsClause_single);
       });
+      _ut.test('test_parseImportDirective_deferred', () {
+        final __test = new SimpleParserTest();
+        runJUnitTest(__test, __test.test_parseImportDirective_deferred);
+      });
       _ut.test('test_parseImportDirective_hide', () {
         final __test = new SimpleParserTest();
         runJUnitTest(__test, __test.test_parseImportDirective_hide);
       });
       _ut.test('test_parseImportDirective_noCombinator', () {
         final __test = new SimpleParserTest();
         runJUnitTest(__test, __test.test_parseImportDirective_noCombinator);
       });
       _ut.test('test_parseImportDirective_prefix', () {
         final __test = new SimpleParserTest();
@@ skipping 1406 matching lines @@
   /**
    * Invoke a parse 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 parse method is invoked.
    *
    * @param methodName the name of the parse method that should be invoked to parse the source
    * @param objects the values of the arguments to the method
    * @param source the source to be parsed by the parse method
-   * @param errorCodes the error codes of the errors that should be generated
+   * @param errors the errors that should be generated
    * @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 parse2(String methodName, List<Object> objects, String source, List<AnalysisError> errors) {
     GatheringErrorListener listener = new GatheringErrorListener();
     Object result = invokeParserMethod(methodName, objects, source, listener);
     listener.assertErrors(errors);
     return result;
@@ skipping 2661 matching lines @@
   }
 
   void test_expectedExecutable_topLevel_beforeType() {
     ParserTestCase.parse3("parseCompilationUnitMember", <Object> [emptyCommentAndMetadata()], "4 score", [ParserErrorCode.EXPECTED_EXECUTABLE]);
   }
 
   void test_expectedInterpolationIdentifier() {
     ParserTestCase.parse4("parseStringLiteral", "'\$x\$'", [ParserErrorCode.MISSING_IDENTIFIER]);
   }
 
+  void test_expectedInterpolationIdentifier_emptyString() {
+    // The scanner inserts an empty string token between the two $'s; we need to make sure that the
+    // MISSING_IDENTIFIER error that is generated has a nonzero width so that it will show up in
+    // the editor UI.
+    ParserTestCase.parse2("parseStringLiteral", <Object> [], "'\$\$foo'", [new AnalysisError.con2(null, 2, 1, ParserErrorCode.MISSING_IDENTIFIER, [])]);
+  }
+
   void test_expectedStringLiteral() {
     StringLiteral expression = ParserTestCase.parse4("parseStringLiteral", "1", [ParserErrorCode.EXPECTED_STRING_LITERAL]);
     JUnitTestCase.assertTrue(expression.isSynthetic);
   }
 
   void test_expectedToken_commaMissingInArgumentList() {
     ParserTestCase.parse4("parseArgumentList", "(x, y z)", [ParserErrorCode.EXPECTED_TOKEN]);
   }
 
   void test_expectedToken_parseStatement_afterVoid() {
@@ skipping 407 matching lines @@
   void test_missingNameInLibraryDirective() {
     CompilationUnit unit = ParserTestCase.parseCompilationUnit("library;", [ParserErrorCode.MISSING_NAME_IN_LIBRARY_DIRECTIVE]);
     JUnitTestCase.assertNotNull(unit);
   }
 
   void test_missingNameInPartOfDirective() {
     CompilationUnit unit = ParserTestCase.parseCompilationUnit("part of;", [ParserErrorCode.MISSING_NAME_IN_PART_OF_DIRECTIVE]);
     JUnitTestCase.assertNotNull(unit);
   }
 
+  void test_missingPrefixInDeferredImport() {
+    ParserTestCase.parseCompilationUnit("import 'foo.dart' deferred;", [ParserErrorCode.MISSING_PREFIX_IN_DEFERRED_IMPORT]);
+  }
+
   void test_missingStatement() {
     ParserTestCase.parseStatement("is", [ParserErrorCode.MISSING_STATEMENT]);
   }
 
   void test_missingStatement_afterVoid() {
     ParserTestCase.parseStatement("void;", [ParserErrorCode.MISSING_STATEMENT]);
   }
 
   void test_missingTerminatorForParameterGroup_named() {
     ParserTestCase.parse4("parseFormalParameterList", "(a, {b: 0)", [ParserErrorCode.MISSING_TERMINATOR_FOR_PARAMETER_GROUP]);
@@ skipping 561 matching lines @@
         runJUnitTest(__test, __test.test_expectedExecutable_topLevel_afterVoid);
       });
       _ut.test('test_expectedExecutable_topLevel_beforeType', () {
         final __test = new ErrorParserTest();
         runJUnitTest(__test, __test.test_expectedExecutable_topLevel_beforeType);
       });
       _ut.test('test_expectedInterpolationIdentifier', () {
         final __test = new ErrorParserTest();
         runJUnitTest(__test, __test.test_expectedInterpolationIdentifier);
       });
+      _ut.test('test_expectedInterpolationIdentifier_emptyString', () {
+        final __test = new ErrorParserTest();
+        runJUnitTest(__test, __test.test_expectedInterpolationIdentifier_emptyString);
+      });
       _ut.test('test_expectedStringLiteral', () {
         final __test = new ErrorParserTest();
         runJUnitTest(__test, __test.test_expectedStringLiteral);
       });
       _ut.test('test_expectedToken_commaMissingInArgumentList', () {
         final __test = new ErrorParserTest();
         runJUnitTest(__test, __test.test_expectedToken_commaMissingInArgumentList);
       });
       _ut.test('test_expectedToken_parseStatement_afterVoid', () {
         final __test = new ErrorParserTest();
@@ skipping 380 matching lines @@
         runJUnitTest(__test, __test.test_missingKeywordOperator_parseClassMember_afterVoid);
       });
       _ut.test('test_missingNameInLibraryDirective', () {
         final __test = new ErrorParserTest();
         runJUnitTest(__test, __test.test_missingNameInLibraryDirective);
       });
       _ut.test('test_missingNameInPartOfDirective', () {
         final __test = new ErrorParserTest();
         runJUnitTest(__test, __test.test_missingNameInPartOfDirective);
       });
+      _ut.test('test_missingPrefixInDeferredImport', () {
+        final __test = new ErrorParserTest();
+        runJUnitTest(__test, __test.test_missingPrefixInDeferredImport);
+      });
       _ut.test('test_missingStatement', () {
         final __test = new ErrorParserTest();
         runJUnitTest(__test, __test.test_missingStatement);
       });
       _ut.test('test_missingStatement_afterVoid', () {
         final __test = new ErrorParserTest();
         runJUnitTest(__test, __test.test_missingStatement_afterVoid);
       });
       _ut.test('test_missingTerminatorForParameterGroup_named', () {
         final __test = new ErrorParserTest();
@@ skipping 309 matching lines @@
 
 main() {
   ComplexParserTest.dartSuite();
   ErrorParserTest.dartSuite();
   IncrementalParserTest.dartSuite();
   NonErrorParserTest.dartSuite();
   RecoveryParserTest.dartSuite();
   ResolutionCopierTest.dartSuite();
   SimpleParserTest.dartSuite();
 }