New analyzer snapshot.

pkg/analyzer/test/generated/ast_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.ast_test;
 
 import 'package:analyzer/src/generated/java_core.dart';
@@ skipping 57 matching lines @@
  * second is places where a shorter name seemed unambiguous and easier to read, such as using
  * 'identifier' rather than 'prefixedIdentifier', or 'integer' rather than 'integerLiteral'.
  */
 class AstFactory {
   static AdjacentStrings adjacentStrings(List<StringLiteral> strings) => new AdjacentStrings(list(strings));
 
   static Annotation annotation(Identifier name) => new Annotation(TokenFactory.tokenFromType(TokenType.AT), name, null, null, null);
 
   static Annotation annotation2(Identifier name, SimpleIdentifier constructorName, ArgumentList arguments) => new Annotation(TokenFactory.tokenFromType(TokenType.AT), name, TokenFactory.tokenFromType(TokenType.PERIOD), constructorName, arguments);
 
-  static ArgumentDefinitionTest argumentDefinitionTest(String identifier) => new ArgumentDefinitionTest(TokenFactory.tokenFromType(TokenType.QUESTION), identifier3(identifier));
-
   static ArgumentList argumentList(List<Expression> arguments) => new ArgumentList(TokenFactory.tokenFromType(TokenType.OPEN_PAREN), list(arguments), TokenFactory.tokenFromType(TokenType.CLOSE_PAREN));
 
   static AsExpression asExpression(Expression expression, TypeName type) => new AsExpression(expression, TokenFactory.tokenFromKeyword(Keyword.AS), type);
 
   static AssertStatement assertStatement(Expression condition) => new AssertStatement(TokenFactory.tokenFromKeyword(Keyword.ASSERT), TokenFactory.tokenFromType(TokenType.OPEN_PAREN), condition, TokenFactory.tokenFromType(TokenType.CLOSE_PAREN), TokenFactory.tokenFromType(TokenType.SEMICOLON));
 
   static AssignmentExpression assignmentExpression(Expression leftHandSide, TokenType operator, Expression rightHandSide) => new AssignmentExpression(leftHandSide, TokenFactory.tokenFromType(operator), rightHandSide);
 
   static BinaryExpression binaryExpression(Expression leftOperand, TokenType operator, Expression rightOperand) => new BinaryExpression(leftOperand, TokenFactory.tokenFromType(operator), rightOperand);
 
@@ skipping 133 matching lines @@
   static PrefixedIdentifier identifier4(String prefix, SimpleIdentifier identifier) => new PrefixedIdentifier(identifier3(prefix), TokenFactory.tokenFromType(TokenType.PERIOD), identifier);
 
   static PrefixedIdentifier identifier5(String prefix, String identifier) => new PrefixedIdentifier(identifier3(prefix), TokenFactory.tokenFromType(TokenType.PERIOD), identifier3(identifier));
 
   static IfStatement ifStatement(Expression condition, Statement thenStatement) => ifStatement2(condition, thenStatement, null);
 
   static IfStatement ifStatement2(Expression condition, Statement thenStatement, Statement elseStatement) => new IfStatement(TokenFactory.tokenFromKeyword(Keyword.IF), TokenFactory.tokenFromType(TokenType.OPEN_PAREN), condition, TokenFactory.tokenFromType(TokenType.CLOSE_PAREN), thenStatement, elseStatement == null ? null : TokenFactory.tokenFromKeyword(Keyword.ELSE), elseStatement);
 
   static ImplementsClause implementsClause(List<TypeName> types) => new ImplementsClause(TokenFactory.tokenFromKeyword(Keyword.IMPLEMENTS), list(types));
 
-  static ImportDirective importDirective(List<Annotation> metadata, String uri, String prefix, List<Combinator> combinators) => new ImportDirective(null, metadata, TokenFactory.tokenFromKeyword(Keyword.IMPORT), string2(uri), null, prefix == null ? null : TokenFactory.tokenFromKeyword(Keyword.AS), prefix == null ? null : identifier3(prefix), list(combinators), TokenFactory.tokenFromType(TokenType.SEMICOLON));
+  static ImportDirective importDirective(List<Annotation> metadata, String uri, bool isDeferred, String prefix, List<Combinator> combinators) => new ImportDirective(null, metadata, TokenFactory.tokenFromKeyword(Keyword.IMPORT), string2(uri), !isDeferred ? null : TokenFactory.tokenFromKeyword(Keyword.DEFERRED), prefix == null ? null : TokenFactory.tokenFromKeyword(Keyword.AS), prefix == null ? null : identifier3(prefix), list(combinators), TokenFactory.tokenFromType(TokenType.SEMICOLON));
 
-  static ImportDirective importDirective2(String uri, String prefix, List<Combinator> combinators) => importDirective(new List<Annotation>(), uri, prefix, combinators);
+  static ImportDirective importDirective2(String uri, bool isDeferred, String prefix, List<Combinator> combinators) => importDirective(new List<Annotation>(), uri, isDeferred, prefix, combinators);
+
+  static ImportDirective importDirective3(String uri, String prefix, List<Combinator> combinators) => importDirective(new List<Annotation>(), uri, false, prefix, combinators);
 
   static IndexExpression indexExpression(Expression array, Expression index) => new IndexExpression.forTarget(array, TokenFactory.tokenFromType(TokenType.OPEN_SQUARE_BRACKET), index, TokenFactory.tokenFromType(TokenType.CLOSE_SQUARE_BRACKET));
 
   static InstanceCreationExpression instanceCreationExpression(Keyword keyword, ConstructorName name, List<Expression> arguments) => new InstanceCreationExpression(keyword == null ? null : TokenFactory.tokenFromKeyword(keyword), name, argumentList(arguments));
 
   static InstanceCreationExpression instanceCreationExpression2(Keyword keyword, TypeName type, List<Expression> arguments) => instanceCreationExpression3(keyword, type, null, arguments);
 
   static InstanceCreationExpression instanceCreationExpression3(Keyword keyword, TypeName type, String identifier, List<Expression> arguments) => instanceCreationExpression(keyword, new ConstructorName(type, identifier == null ? null : TokenFactory.tokenFromType(TokenType.PERIOD), identifier == null ? null : identifier3(identifier)), arguments);
 
   static IntegerLiteral integer(int value) => new IntegerLiteral(TokenFactory.tokenFromTypeAndString(TokenType.INT, value.toString()), value);
@@ skipping 1377 matching lines @@
       });
       _ut.test('test_searchWithin_offsetBeforeNode', () {
         final __test = new NodeLocatorTest();
         runJUnitTest(__test, __test.test_searchWithin_offsetBeforeNode);
       });
     });
   }
 }
 
 class SimpleIdentifierTest extends ParserTestCase {
-  void test_inDeclarationContext_argumentDefinition() {
-    SimpleIdentifier identifier = AstFactory.argumentDefinitionTest("p").identifier;
-    JUnitTestCase.assertFalse(identifier.inDeclarationContext());
-  }
-
   void test_inDeclarationContext_catch_exception() {
     SimpleIdentifier identifier = AstFactory.catchClause("e", []).exceptionParameter;
     JUnitTestCase.assertTrue(identifier.inDeclarationContext());
   }
 
   void test_inDeclarationContext_catch_stack() {
     SimpleIdentifier identifier = AstFactory.catchClause2("e", "s", []).stackTraceParameter;
     JUnitTestCase.assertTrue(identifier.inDeclarationContext());
   }
 
@@ skipping 167 matching lines @@
     AstNode parent = identifier.parent;
     while (parent != null) {
       child = parent;
       parent = parent.parent;
     }
     return child;
   }
 
   static dartSuite() {
     _ut.group('SimpleIdentifierTest', () {
-      _ut.test('test_inDeclarationContext_argumentDefinition', () {
-        final __test = new SimpleIdentifierTest();
-        runJUnitTest(__test, __test.test_inDeclarationContext_argumentDefinition);
-      });
       _ut.test('test_inDeclarationContext_catch_exception', () {
         final __test = new SimpleIdentifierTest();
         runJUnitTest(__test, __test.test_inDeclarationContext_catch_exception);
       });
       _ut.test('test_inDeclarationContext_catch_stack', () {
         final __test = new SimpleIdentifierTest();
         runJUnitTest(__test, __test.test_inDeclarationContext_catch_stack);
       });
       _ut.test('test_inDeclarationContext_classDeclaration', () {
         final __test = new SimpleIdentifierTest();
@@ skipping 138 matching lines @@
   }
 
   void test_visitAnnotation_constant() {
     _assertSource("@A", AstFactory.annotation(AstFactory.identifier3("A")));
   }
 
   void test_visitAnnotation_constructor() {
     _assertSource("@A.c()", AstFactory.annotation2(AstFactory.identifier3("A"), AstFactory.identifier3("c"), AstFactory.argumentList([])));
   }
 
-  void test_visitArgumentDefinitionTest() {
-    _assertSource("?a", AstFactory.argumentDefinitionTest("a"));
-  }
-
   void test_visitArgumentList() {
     _assertSource("(a, b)", AstFactory.argumentList([AstFactory.identifier3("a"), AstFactory.identifier3("b")]));
   }
 
   void test_visitAsExpression() {
     _assertSource("e as T", AstFactory.asExpression(AstFactory.identifier3("e"), AstFactory.typeName4("T", [])));
   }
 
   void test_visitAssertStatement() {
     _assertSource("assert (a);", AstFactory.assertStatement(AstFactory.identifier3("a")));
@@ skipping 585 matching lines @@
     _assertSource("implements A, B", AstFactory.implementsClause([
         AstFactory.typeName4("A", []),
         AstFactory.typeName4("B", [])]));
   }
 
   void test_visitImplementsClause_single() {
     _assertSource("implements A", AstFactory.implementsClause([AstFactory.typeName4("A", [])]));
   }
 
   void test_visitImportDirective_combinator() {
-    _assertSource("import 'a.dart' show A;", AstFactory.importDirective2("a.dart", null, [AstFactory.showCombinator([AstFactory.identifier3("A")])]));
+    _assertSource("import 'a.dart' show A;", AstFactory.importDirective3("a.dart", null, [AstFactory.showCombinator([AstFactory.identifier3("A")])]));
   }
 
   void test_visitImportDirective_combinators() {
-    _assertSource("import 'a.dart' show A hide B;", AstFactory.importDirective2("a.dart", null, [
+    _assertSource("import 'a.dart' show A hide B;", AstFactory.importDirective3("a.dart", null, [
         AstFactory.showCombinator([AstFactory.identifier3("A")]),
         AstFactory.hideCombinator([AstFactory.identifier3("B")])]));
   }
 
+  void test_visitImportDirective_deferred() {
+    _assertSource("import 'a.dart' deferred as p;", AstFactory.importDirective2("a.dart", true, "p", []));
+  }
+
   void test_visitImportDirective_minimal() {
-    _assertSource("import 'a.dart';", AstFactory.importDirective2("a.dart", null, []));
+    _assertSource("import 'a.dart';", AstFactory.importDirective3("a.dart", null, []));
   }
 
   void test_visitImportDirective_prefix() {
-    _assertSource("import 'a.dart' as p;", AstFactory.importDirective2("a.dart", "p", []));
+    _assertSource("import 'a.dart' as p;", AstFactory.importDirective3("a.dart", "p", []));
   }
 
   void test_visitImportDirective_prefix_combinator() {
-    _assertSource("import 'a.dart' as p show A;", AstFactory.importDirective2("a.dart", "p", [AstFactory.showCombinator([AstFactory.identifier3("A")])]));
+    _assertSource("import 'a.dart' as p show A;", AstFactory.importDirective3("a.dart", "p", [AstFactory.showCombinator([AstFactory.identifier3("A")])]));
   }
 
   void test_visitImportDirective_prefix_combinators() {
-    _assertSource("import 'a.dart' as p show A hide B;", AstFactory.importDirective2("a.dart", "p", [
+    _assertSource("import 'a.dart' as p show A hide B;", AstFactory.importDirective3("a.dart", "p", [
         AstFactory.showCombinator([AstFactory.identifier3("A")]),
         AstFactory.hideCombinator([AstFactory.identifier3("B")])]));
   }
 
   void test_visitImportDirective_withMetadata() {
-    ImportDirective directive = AstFactory.importDirective2("a.dart", null, []);
+    ImportDirective directive = AstFactory.importDirective3("a.dart", null, []);
     directive.metadata = AstFactory.list([AstFactory.annotation(AstFactory.identifier3("deprecated"))]);
     _assertSource("@deprecated import 'a.dart';", directive);
   }
 
   void test_visitImportHideCombinator_multiple() {
     _assertSource("hide a, b", AstFactory.hideCombinator([AstFactory.identifier3("a"), AstFactory.identifier3("b")]));
   }
 
   void test_visitImportHideCombinator_single() {
     _assertSource("hide a", AstFactory.hideCombinator([AstFactory.identifier3("a")]));
@@ skipping 528 matching lines @@
         runJUnitTest(__test, __test.test_visitAdjacentStrings);
       });
       _ut.test('test_visitAnnotation_constant', () {
         final __test = new ToSourceVisitorTest();
         runJUnitTest(__test, __test.test_visitAnnotation_constant);
       });
       _ut.test('test_visitAnnotation_constructor', () {
         final __test = new ToSourceVisitorTest();
         runJUnitTest(__test, __test.test_visitAnnotation_constructor);
       });
-      _ut.test('test_visitArgumentDefinitionTest', () {
-        final __test = new ToSourceVisitorTest();
-        runJUnitTest(__test, __test.test_visitArgumentDefinitionTest);
-      });
       _ut.test('test_visitArgumentList', () {
         final __test = new ToSourceVisitorTest();
         runJUnitTest(__test, __test.test_visitArgumentList);
       });
       _ut.test('test_visitAsExpression', () {
         final __test = new ToSourceVisitorTest();
         runJUnitTest(__test, __test.test_visitAsExpression);
       });
       _ut.test('test_visitAssertStatement', () {
         final __test = new ToSourceVisitorTest();
@@ skipping 532 matching lines @@
         runJUnitTest(__test, __test.test_visitImplementsClause_single);
       });
       _ut.test('test_visitImportDirective_combinator', () {
         final __test = new ToSourceVisitorTest();
         runJUnitTest(__test, __test.test_visitImportDirective_combinator);
       });
       _ut.test('test_visitImportDirective_combinators', () {
         final __test = new ToSourceVisitorTest();
         runJUnitTest(__test, __test.test_visitImportDirective_combinators);
       });
+      _ut.test('test_visitImportDirective_deferred', () {
+        final __test = new ToSourceVisitorTest();
+        runJUnitTest(__test, __test.test_visitImportDirective_deferred);
+      });
       _ut.test('test_visitImportDirective_minimal', () {
         final __test = new ToSourceVisitorTest();
         runJUnitTest(__test, __test.test_visitImportDirective_minimal);
       });
       _ut.test('test_visitImportDirective_prefix', () {
         final __test = new ToSourceVisitorTest();
         runJUnitTest(__test, __test.test_visitImportDirective_prefix);
       });
       _ut.test('test_visitImportDirective_prefix_combinator', () {
         final __test = new ToSourceVisitorTest();
@@ skipping 534 matching lines @@
   ToSourceVisitorTest.dartSuite();
   BreadthFirstVisitorTest.dartSuite();
   ClassDeclarationTest.dartSuite();
   ClassTypeAliasTest.dartSuite();
   IndexExpressionTest.dartSuite();
   NodeListTest.dartSuite();
   SimpleIdentifierTest.dartSuite();
   SimpleStringLiteralTest.dartSuite();
   VariableDeclarationTest.dartSuite();
 }