New analyzer snapshot.

pkg/analyzer/lib/src/generated/element.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.element;
 
 import 'dart:collection';
@@ skipping 186 matching lines @@
 
   /**
    * Return `true` if this class has reference to super (so, for example, cannot be used as a
    * mixin).
    *
    * @return `true` if this class has reference to super
    */
   bool get hasReferenceToSuper;
 
   /**
+   * Return `true` if this class declares a static member.
+   *
+   * @return `true` if this class declares a static member
+   */
+  bool get hasStaticMember;
+
+  /**
    * Return `true` if this class is abstract. A class is abstract if it has an explicit
    * `abstract` modifier. Note, that this definition of <i>abstract</i> is different from
    * <i>has unimplemented members</i>.
    *
    * @return `true` if this class is abstract
    */
   bool get isAbstract;
 
   /**
    * Return `true` if this class [isProxy], or if it inherits the proxy annotation
@@ skipping 1002 matching lines @@
   PrefixElement get prefix;
 
   /**
    * Return the offset of the prefix of this import in the file that contains this import directive,
    * or `-1` if this import is synthetic, does not have a prefix, or otherwise does not have
    * an offset.
    *
    * @return the offset of the prefix of this import
    */
   int get prefixOffset;
-
-  /**
-   * Return the offset of the character immediately following the last character of this node's URI,
-   * or `-1` for synthetic import.
-   *
-   * @return the offset of the character just past the node's URI
-   */
-  int get uriEnd;
 }
 
 /**
  * The interface `LabelElement` defines the behavior of elements representing a label
  * associated with a statement.
  */
 abstract class LabelElement implements Element {
   /**
    * Return the executable element in which this label is defined.
    *
@@ skipping 489 matching lines @@
  */
 abstract class UndefinedElement implements Element {
 }
 
 /**
  * The interface `UriReferencedElement` defines the behavior of objects included into a
  * library using some URI.
  */
 abstract class UriReferencedElement implements Element {
   /**
+   * Return the offset of the character immediately following the last character of this node's URI,
+   * or `-1` for synthetic import.
+   *
+   * @return the offset of the character just past the node's URI
+   */
+  int get uriEnd;
+
+  /**
+   * Return the offset of the URU in the file, or `-1` if this element is synthetic.
+   *
+   * @return the offset of the URI
+   */
+  int get uriOffset;
+
+  /**
    * Return the URI that is used to include this element into the enclosing library, or `null`
    * if this is the defining compilation unit of a library.
    *
    * @return the URI that is used to include this element into the enclosing library
    */
   String get uri;
 }
 
 /**
  * The interface `VariableElement` defines the behavior common to elements that represent a
@@ skipping 1042 matching lines @@
       }
     }
     // not found
     return false;
   }
 
   @override
   bool get hasReferenceToSuper => hasModifier(Modifier.REFERENCES_SUPER);
 
   @override
+  bool get hasStaticMember {
+    for (MethodElement method in _methods) {
+      if (method.isStatic) {
+        return true;
+      }
+    }
+    for (PropertyAccessorElement accessor in _accessors) {
+      if (accessor.isStatic) {
+        return true;
+      }
+    }
+    return false;
+  }
+
+  @override
   bool get isAbstract => hasModifier(Modifier.ABSTRACT);
 
   @override
   bool get isOrInheritsProxy => _safeIsOrInheritsProxy(this, new Set<ClassElement>());
 
   @override
   bool get isProxy {
     for (ElementAnnotation annotation in metadata) {
       if (annotation.isProxy) {
         return true;
@@ skipping 284 matching lines @@
       }
     }
     return false;
   }
 }
 
 /**
  * Instances of the class `CompilationUnitElementImpl` implement a
  * [CompilationUnitElement].
  */
-class CompilationUnitElementImpl extends ElementImpl implements CompilationUnitElement {
+class CompilationUnitElementImpl extends UriReferencedElementImpl implements CompilationUnitElement {
   /**
    * An empty array of compilation unit elements.
    */
   static List<CompilationUnitElement> EMPTY_ARRAY = new List<CompilationUnitElement>(0);
 
   /**
    * The source that corresponds to this compilation unit.
    */
   Source source;
 
@@ skipping 22 matching lines @@
    * An array containing all of the types contained in this compilation unit.
    */
   List<ClassElement> _types = ClassElementImpl.EMPTY_ARRAY;
 
   /**
    * An array containing all of the variables contained in this compilation unit.
    */
   List<TopLevelVariableElement> _variables = TopLevelVariableElementImpl.EMPTY_ARRAY;
 
   /**
-   * The URI that is specified by the "part" directive in the enclosing library, or `null` if
-   * this is the defining compilation unit of a library.
-   */
-  String uri;
-
-  /**
    * An array containing all of the Angular views contained in this compilation unit.
    */
   List<AngularViewElement> _angularViews = AngularViewElement.EMPTY_ARRAY;
 
   /**
    * Initialize a newly created compilation unit element to have the given name.
    *
    * @param name the name of this element
    */
   CompilationUnitElementImpl(String name) : super(name, -1);
@@ skipping 1341 matching lines @@
     if (type != null) {
       builder.append(Element.RIGHT_ARROW);
       builder.append(type.returnType);
     }
   }
 }
 
 /**
  * Instances of the class `ExportElementImpl` implement an [ExportElement].
  */
-class ExportElementImpl extends ElementImpl implements ExportElement {
-  /**
-   * The URI that is specified by this directive.
-   */
-  String uri;
-
+class ExportElementImpl extends UriReferencedElementImpl implements ExportElement {
   /**
    * The library that is exported from this library by this export directive.
    */
   LibraryElement exportedLibrary;
 
   /**
    * The combinators that were specified as part of the export directive in the order in which they
    * were specified.
    */
   List<NamespaceCombinator> combinators = NamespaceCombinator.EMPTY_ARRAY;
 
   /**
    * Initialize a newly created export element.
    */
-  ExportElementImpl() : super.forNode(null);
+  ExportElementImpl() : super(null, -1);
 
   @override
   accept(ElementVisitor visitor) => visitor.visitExportElement(this);
 
   @override
   ElementKind get kind => ElementKind.EXPORT;
 
   @override
   void appendTo(JavaStringBuilder builder) {
     builder.append("export ");
@@ skipping 467 matching lines @@
    * Initialize a newly created script element to have the specified tag name and offset.
    *
    * @param node the XML node from which this element is derived (not `null`)
    */
   HtmlScriptElementImpl(XmlTagNode node) : super(node.tag, node.tagToken.offset);
 }
 
 /**
  * Instances of the class `ImportElementImpl` implement an [ImportElement].
  */
-class ImportElementImpl extends ElementImpl implements ImportElement {
-  /**
-   * The offset of the character immediately following the last character of this node's URI, may be
-   * `-1` if synthetic.
-   */
-  int uriEnd = -1;
-
+class ImportElementImpl extends UriReferencedElementImpl implements ImportElement {
   /**
    * The offset of the prefix of this import in the file that contains the this import directive, or
    * `-1` if this import is synthetic.
    */
   int prefixOffset = 0;
 
   /**
-   * The URI that is specified by this directive.
-   */
-  String uri;
-
-  /**
    * The library that is imported into this library by this import directive.
    */
   LibraryElement importedLibrary;
 
   /**
    * The combinators that were specified as part of the import directive in the order in which they
    * were specified.
    */
   List<NamespaceCombinator> combinators = NamespaceCombinator.EMPTY_ARRAY;
 
@@ skipping 1517 matching lines @@
   void appendTo(JavaStringBuilder builder) {
     builder.append(displayName);
     if (bound != null) {
       builder.append(" extends ");
       builder.append(bound);
     }
   }
 }
 
 /**
+ * Instances of the class `UriReferencedElementImpl` implement an [UriReferencedElement]
+ * .
+ */
+abstract class UriReferencedElementImpl extends ElementImpl implements UriReferencedElement {
+  /**
+   * The offset of the URU in the file, may be `-1` if synthetic.
+   */
+  int uriOffset = -1;
+
+  /**
+   * The offset of the character immediately following the last character of this node's URI, may be
+   * `-1` if synthetic.
+   */
+  int uriEnd = -1;
+
+  /**
+   * The URI that is specified by this directive.
+   */
+  String uri;
+
+  /**
+   * Initialize a newly created import element.
+   *
+   * @param name the name of this element
+   * @param offset the directive offset, may be `-1` if synthetic.
+   */
+  UriReferencedElementImpl(String name, int offset) : super(name, offset);
+}
+
+/**
  * Instances of the class `VariableElementImpl` implement a `VariableElement`.
  */
 abstract class VariableElementImpl extends ElementImpl implements VariableElement {
   /**
    * The declared type of this variable.
    */
   DartType type;
 
   /**
    * A synthetic function representing this variable's initializer, or `null` if this variable
@@ skipping 3787 matching lines @@
 }
 
 /**
  * The interface `VoidType` defines the behavior of the unique object representing the type
  * `void`.
  */
 abstract class VoidType implements DartType {
   @override
   VoidType substitute2(List<DartType> argumentTypes, List<DartType> parameterTypes);
 }