New analyzer snapshot, based on r35422.

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 9455 matching lines @@
 
   @override
   Element get staticElement {
     if (_identifier == null) {
       return null;
     }
     return _identifier.staticElement;
   }
 
   /**
+   * Return `true` if this type is a deferred type.
+   *
+   * 15.1 Static Types: A type <i>T</i> is deferred iff it is of the form </i>p.T</i> where <i>p</i>
+   * is a deferred prefix.
+   *
+   * @return `true` if this type is a deferred type
+   */
+  bool get isDeferred {
+    Element element = _prefix.staticElement;
+    if (element is! PrefixElement) {
+      return false;
+    }
+    PrefixElement prefixElement = element as PrefixElement;
+    List<ImportElement> imports = prefixElement.enclosingElement.getImportsWithPrefix(prefixElement);
+    if (imports.length != 1) {
+      return false;
+    }
+    return imports[0].isDeferred;
+  }
+
+  /**
    * Set the identifier being prefixed to the given identifier.
    *
    * @param identifier the identifier being prefixed
    */
   void set identifier(SimpleIdentifier identifier) {
     this._identifier = becomeParentOf(identifier);
   }
 
   /**
    * Set the prefix associated with the library in which the identifier is defined to the given
@@ skipping 1936 matching lines @@
   Identifier get name => _name;
 
   /**
    * Return the type arguments associated with the type, or `null` if there are no type
    * arguments.
    *
    * @return the type arguments associated with the type
    */
   TypeArgumentList get typeArguments => _typeArguments;
 
+  /**
+   * Return `true` if this type is a deferred type.
+   *
+   * 15.1 Static Types: A type <i>T</i> is deferred iff it is of the form </i>p.T</i> where <i>p</i>
+   * is a deferred prefix.
+   *
+   * @return `true` if this type is a deferred type
+   */
+  bool get isDeferred {
+    Identifier identifier = name;
+    if (identifier is! PrefixedIdentifier) {
+      return false;
+    }
+    return (identifier as PrefixedIdentifier).isDeferred;
+  }
+
   @override
   bool get isSynthetic => _name.isSynthetic && _typeArguments == null;
 
   /**
    * Set the name of the type to the given identifier.
    *
    * @param identifier the name of the type
    */
   void set name(Identifier identifier) {
     _name = becomeParentOf(identifier);
@@ skipping 221 matching lines @@
  *   | [PartDirective]
  * </pre>
  */
 abstract class UriBasedDirective extends Directive {
   /**
    * The URI referenced by this directive.
    */
   StringLiteral _uri;
 
   /**
+   * The prefix of a URI using the `dart-ext` scheme to reference a native code library.
+   */
+  static String _DART_EXT_SCHEME = "dart-ext:";
+
+  /**
    * The content of the URI.
    */
   String uriContent;
 
   /**
    * The source to which the URI was resolved.
    */
   Source source;
 
   /**
@@ skipping 25 matching lines @@
 
   /**
    * Set the URI referenced by this directive to the given URI.
    *
    * @param uri the URI referenced by this directive
    */
   void set uri(StringLiteral uri) {
     this._uri = becomeParentOf(uri);
   }
 
+  /**
+   * Validate the given directive, but do not check for existance.
+   *
+   * @return a code indicating the problem if there is one, or `null` no problem
+   */
+  UriValidationCode validate() {
+    StringLiteral uriLiteral = uri;
+    if (uriLiteral is StringInterpolation) {
+      return UriValidationCode.URI_WITH_INTERPOLATION;
+    }
+    String uriContent = this.uriContent;
+    if (uriContent == null) {
+      return UriValidationCode.INVALID_URI;
+    }
+    if (this is ImportDirective && uriContent.startsWith(_DART_EXT_SCHEME)) {
+      return UriValidationCode.URI_WITH_DART_EXT_SCHEME;
+    }
+    try {
+      parseUriWithException(Uri.encodeFull(uriContent));
+    } on URISyntaxException catch (exception) {
+      return UriValidationCode.INVALID_URI;
+    }
+    return null;
+  }
+
   @override
   void visitChildren(AstVisitor visitor) {
     super.visitChildren(visitor);
     safelyVisitChild(_uri, visitor);
   }
 }
 
 /**
+ * Validation codes returned by [UriBasedDirective#validate].
+ */
+class UriValidationCode extends Enum<UriValidationCode> {
+  static const UriValidationCode INVALID_URI = const UriValidationCode('INVALID_URI', 0);
+
+  static const UriValidationCode URI_WITH_INTERPOLATION = const UriValidationCode('URI_WITH_INTERPOLATION', 1);
+
+  static const UriValidationCode URI_WITH_DART_EXT_SCHEME = const UriValidationCode('URI_WITH_DART_EXT_SCHEME', 2);
+
+  static const List<UriValidationCode> values = const [
+      INVALID_URI,
+      URI_WITH_INTERPOLATION,
+      URI_WITH_DART_EXT_SCHEME];
+
+  const UriValidationCode(String name, int ordinal) : super(name, ordinal);
+}
+
+/**
  * Instances of the class `VariableDeclaration` represent an identifier that has an initial
  * value associated with it. Instances of this class are always children of the class
  * [VariableDeclarationList].
  *
  * <pre>
  * variableDeclaration ::=
  *     [SimpleIdentifier] ('=' [Expression])?
  * </pre>
  */
 class VariableDeclaration extends Declaration {
@@ skipping 5910 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.");
   }
 }