New analyzer snapshot.

pkg/analyzer/lib/src/generated/ast.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;
 
 import 'dart:collection';
@@ skipping 360 matching lines @@
 
   @override
   void visitChildren(AstVisitor visitor) {
     safelyVisitChild(_name, visitor);
     safelyVisitChild(_constructorName, visitor);
     safelyVisitChild(_arguments, visitor);
   }
 }
 
 /**
- * Instances of the class `ArgumentDefinitionTest` represent an argument definition test.
- *
- * <pre>
- * argumentDefinitionTest ::=
- *     '?' [SimpleIdentifier]
- * </pre>
- */
-class ArgumentDefinitionTest extends Expression {
-  /**
-   * The token representing the question mark.
-   */
-  Token question;
-
-  /**
-   * The identifier representing the argument being tested.
-   */
-  SimpleIdentifier _identifier;
-
-  /**
-   * Initialize a newly created argument definition test.
-   *
-   * @param question the token representing the question mark
-   * @param identifier the identifier representing the argument being tested
-   */
-  ArgumentDefinitionTest(this.question, SimpleIdentifier identifier) {
-    this._identifier = becomeParentOf(identifier);
-  }
-
-  @override
-  accept(AstVisitor visitor) => visitor.visitArgumentDefinitionTest(this);
-
-  @override
-  Token get beginToken => question;
-
-  @override
-  Token get endToken => _identifier.endToken;
-
-  /**
-   * Return the identifier representing the argument being tested.
-   *
-   * @return the identifier representing the argument being tested
-   */
-  SimpleIdentifier get identifier => _identifier;
-
-  @override
-  int get precedence => 15;
-
-  /**
-   * Set the identifier representing the argument being tested to the given identifier.
-   *
-   * @param identifier the identifier representing the argument being tested
-   */
-  void set identifier(SimpleIdentifier identifier) {
-    this._identifier = becomeParentOf(identifier);
-  }
-
-  @override
-  void visitChildren(AstVisitor visitor) {
-    safelyVisitChild(_identifier, visitor);
-  }
-}
-
-/**
  * Instances of the class `ArgumentList` represent a list of arguments in the invocation of a
  * executable element: a function, method, or constructor.
  *
  * <pre>
  * argumentList ::=
  *     '(' arguments? ')'
  *
  * arguments ::=
  *     [NamedExpression] (',' [NamedExpression])*
  *   | [Expression] (',' [NamedExpression])*
@@ skipping 558 matching lines @@
  * results or properties associated with the nodes.
  */
 class AstCloner implements AstVisitor<AstNode> {
   @override
   AdjacentStrings visitAdjacentStrings(AdjacentStrings node) => new AdjacentStrings(_cloneNodeList(node.strings));
 
   @override
   Annotation visitAnnotation(Annotation node) => new Annotation(node.atSign, _cloneNode(node.name), node.period, _cloneNode(node.constructorName), _cloneNode(node.arguments));
 
   @override
-  ArgumentDefinitionTest visitArgumentDefinitionTest(ArgumentDefinitionTest node) => new ArgumentDefinitionTest(node.question, _cloneNode(node.identifier));
-
-  @override
   ArgumentList visitArgumentList(ArgumentList node) => new ArgumentList(node.leftParenthesis, _cloneNodeList(node.arguments), node.rightParenthesis);
 
   @override
   AsExpression visitAsExpression(AsExpression node) => new AsExpression(_cloneNode(node.expression), node.asOperator, _cloneNode(node.type));
 
   @override
   AstNode visitAssertStatement(AssertStatement node) => new AssertStatement(node.keyword, node.leftParenthesis, _cloneNode(node.condition), node.rightParenthesis, node.semicolon);
 
   @override
   AssignmentExpression visitAssignmentExpression(AssignmentExpression node) => new AssignmentExpression(_cloneNode(node.leftHandSide), node.operator, _cloneNode(node.rightHandSide));
@@ skipping 375 matching lines @@
     return _isEqualNodeLists(node.strings, other.strings);
   }
 
   @override
   bool visitAnnotation(Annotation node) {
     Annotation other = this._other as Annotation;
     return _isEqualTokens(node.atSign, other.atSign) && _isEqualNodes(node.name, other.name) && _isEqualTokens(node.period, other.period) && _isEqualNodes(node.constructorName, other.constructorName) && _isEqualNodes(node.arguments, other.arguments);
   }
 
   @override
-  bool visitArgumentDefinitionTest(ArgumentDefinitionTest node) {
-    ArgumentDefinitionTest other = this._other as ArgumentDefinitionTest;
-    return _isEqualTokens(node.question, other.question) && _isEqualNodes(node.identifier, other.identifier);
-  }
-
-  @override
   bool visitArgumentList(ArgumentList node) {
     ArgumentList other = this._other as ArgumentList;
     return _isEqualTokens(node.leftParenthesis, other.leftParenthesis) && _isEqualNodeLists(node.arguments, other.arguments) && _isEqualTokens(node.rightParenthesis, other.rightParenthesis);
   }
 
   @override
   bool visitAsExpression(AsExpression node) {
     AsExpression other = this._other as AsExpression;
     return _isEqualNodes(node.expression, other.expression) && _isEqualTokens(node.asOperator, other.asOperator) && _isEqualNodes(node.type, other.type);
   }
@@ skipping 910 matching lines @@
 
 /**
  * The interface `AstVisitor` defines the behavior of objects that can be used to visit an AST
  * structure.
  */
 abstract class AstVisitor<R> {
   R visitAdjacentStrings(AdjacentStrings node);
 
   R visitAnnotation(Annotation node);
 
-  R visitArgumentDefinitionTest(ArgumentDefinitionTest node);
-
   R visitArgumentList(ArgumentList node);
 
   R visitAsExpression(AsExpression node);
 
   R visitAssertStatement(AssertStatement assertStatement);
 
   R visitAssignmentExpression(AssignmentExpression node);
 
   R visitBinaryExpression(BinaryExpression node);
 
@@ skipping 3114 matching lines @@
   }
 
   @override
   void visitChildren(AstVisitor visitor) {
     safelyVisitChild(_parameter, visitor);
     safelyVisitChild(_defaultValue, visitor);
   }
 }
 
 /**
+ * This recursive Ast visitor is used to run over [Expression]s to determine if the expression
+ * is composed by at least one deferred [PrefixedIdentifier].
+ *
+ * @see PrefixedIdentifier#isDeferred()
+ */
+class DeferredLibraryReferenceDetector extends RecursiveAstVisitor<Object> {
+  bool _result = false;
+
+  /**
+   * Return the result, `true` if the visitor found a [PrefixedIdentifier] that returned
+   * `true` to the [PrefixedIdentifier#isDeferred] query.
+   *
+   * @return `true` if the visitor found a [PrefixedIdentifier] that returned
+   *         `true` to the [PrefixedIdentifier#isDeferred] query
+   */
+  bool get result => _result;
+
+  @override
+  Object visitPrefixedIdentifier(PrefixedIdentifier node) {
+    // If result is already true, skip.
+    if (!_result) {
+      // Set result to true if isDeferred() is true
+      if (node.isDeferred) {
+        _result = true;
+      }
+    }
+    return null;
+  }
+}
+
+/**
  * The abstract class `Directive` defines the behavior common to nodes that represent a
  * directive.
  *
  * <pre>
  * directive ::=
  *     [ExportDirective]
  *   | [ImportDirective]
  *   | [LibraryDirective]
  *   | [PartDirective]
  *   | [PartOfDirective]
@@ skipping 245 matching lines @@
   }
 
   /**
    * Locate the [Element] associated with the given [AstNode] and offset.
    *
    * @param node the node (not `null`)
    * @param offset the offset relative to source
    * @return the associated element, or `null` if none is found
    */
   static Element locateWithOffset(AstNode node, int offset) {
+    if (node == null) {
+      return null;
+    }
     // try to get Element from node
     {
       Element nodeElement = locate(node);
       if (nodeElement != null) {
         return nodeElement;
       }
     }
     // try to get Angular specific Element
     {
       Element element = null;
@@ skipping 2108 matching lines @@
 class GeneralizingAstVisitor<R> implements AstVisitor<R> {
   @override
   R visitAdjacentStrings(AdjacentStrings node) => visitStringLiteral(node);
 
   R visitAnnotatedNode(AnnotatedNode node) => visitNode(node);
 
   @override
   R visitAnnotation(Annotation node) => visitNode(node);
 
   @override
-  R visitArgumentDefinitionTest(ArgumentDefinitionTest node) => visitExpression(node);
-
-  @override
   R visitArgumentList(ArgumentList node) => visitNode(node);
 
   @override
   R visitAsExpression(AsExpression node) => visitExpression(node);
 
   @override
   R visitAssertStatement(AssertStatement node) => visitStatement(node);
 
   @override
   R visitAssignmentExpression(AssignmentExpression node) => visitExpression(node);
@@ skipping 849 matching lines @@
   AdjacentStrings visitAdjacentStrings(AdjacentStrings node) => new AdjacentStrings(_cloneNodeList(node.strings));
 
   @override
   Annotation visitAnnotation(Annotation node) {
     Annotation copy = new Annotation(_mapToken(node.atSign), _cloneNode(node.name), _mapToken(node.period), _cloneNode(node.constructorName), _cloneNode(node.arguments));
     copy.element = node.element;
     return copy;
   }
 
   @override
-  ArgumentDefinitionTest visitArgumentDefinitionTest(ArgumentDefinitionTest node) {
-    ArgumentDefinitionTest copy = new ArgumentDefinitionTest(_mapToken(node.question), _cloneNode(node.identifier));
-    copy.propagatedType = node.propagatedType;
-    copy.staticType = node.staticType;
-    return copy;
-  }
-
-  @override
   ArgumentList visitArgumentList(ArgumentList node) => new ArgumentList(_mapToken(node.leftParenthesis), _cloneNodeList(node.arguments), _mapToken(node.rightParenthesis));
 
   @override
   AsExpression visitAsExpression(AsExpression node) {
     AsExpression copy = new AsExpression(_cloneNode(node.expression), _mapToken(node.asOperator), _cloneNode(node.type));
     copy.propagatedType = node.propagatedType;
     copy.staticType = node.staticType;
     return copy;
   }
 
@@ skipping 3691 matching lines @@
     return null;
   }
 
   @override
   R visitAnnotation(Annotation node) {
     node.visitChildren(this);
     return null;
   }
 
   @override
-  R visitArgumentDefinitionTest(ArgumentDefinitionTest node) {
-    node.visitChildren(this);
-    return null;
-  }
-
-  @override
   R visitArgumentList(ArgumentList node) {
     node.visitChildren(this);
     return null;
   }
 
   @override
   R visitAsExpression(AsExpression node) {
     node.visitChildren(this);
     return null;
   }
@@ skipping 1063 matching lines @@
  * structure) and that only need to visit a small number of node types.
  */
 class SimpleAstVisitor<R> implements AstVisitor<R> {
   @override
   R visitAdjacentStrings(AdjacentStrings node) => null;
 
   @override
   R visitAnnotation(Annotation node) => null;
 
   @override
-  R visitArgumentDefinitionTest(ArgumentDefinitionTest node) => null;
-
-  @override
   R visitArgumentList(ArgumentList node) => null;
 
   @override
   R visitAsExpression(AsExpression node) => null;
 
   @override
   R visitAssertStatement(AssertStatement node) => null;
 
   @override
   R visitAssignmentExpression(AssignmentExpression node) => null;
@@ skipping 1470 matching lines @@
   @override
   Object visitAnnotation(Annotation node) {
     _writer.print('@');
     _visitNode(node.name);
     _visitNodeWithPrefix(".", node.constructorName);
     _visitNode(node.arguments);
     return null;
   }
 
   @override
-  Object visitArgumentDefinitionTest(ArgumentDefinitionTest node) {
-    _writer.print('?');
-    _visitNode(node.identifier);
-    return null;
-  }
-
-  @override
   Object visitArgumentList(ArgumentList node) {
     _writer.print('(');
     _visitNodeListWithSeparator(node.arguments, ", ");
     _writer.print(')');
     return null;
   }
 
   @override
   Object visitAsExpression(AsExpression node) {
     _visitNode(node.expression);
@@ skipping 421 matching lines @@
     _writer.print("implements ");
     _visitNodeListWithSeparator(node.interfaces, ", ");
     return null;
   }
 
   @override
   Object visitImportDirective(ImportDirective node) {
     _visitNodeListWithSeparatorAndSuffix(node.metadata, " ", " ");
     _writer.print("import ");
     _visitNode(node.uri);
+    if (node.deferredToken != null) {
+      _writer.print(" deferred");
+    }
     _visitNodeWithPrefix(" as ", node.prefix);
     _visitNodeListWithSeparatorAndPrefix(" ", node.combinators, " ");
     _writer.print(';');
     return null;
   }
 
   @override
   Object visitIndexExpression(IndexExpression node) {
     if (node.isCascaded) {
       _writer.print("..");
@@ skipping 1189 matching lines @@
  * cause the children of the visited node to not be visited.
  */
 class UnifyingAstVisitor<R> implements AstVisitor<R> {
   @override
   R visitAdjacentStrings(AdjacentStrings node) => visitNode(node);
 
   @override
   R visitAnnotation(Annotation node) => visitNode(node);
 
   @override
-  R visitArgumentDefinitionTest(ArgumentDefinitionTest node) => visitNode(node);
-
-  @override
   R visitArgumentList(ArgumentList node) => visitNode(node);
 
   @override
   R visitAsExpression(AsExpression node) => visitNode(node);
 
   @override
   R visitAssertStatement(AssertStatement node) => visitNode(node);
 
   @override
   R visitAssignmentExpression(AssignmentExpression node) => visitNode(node);
@@ skipping 1003 matching lines @@
     _elements[index] = node;
   }
   void clear() {
     _elements = <E> [];
   }
   int get length => _elements.length;
   void set length(int value) {
     throw new UnsupportedError("Cannot resize NodeList.");
   }
 }