New analyzer_experimental snapshot.

pkg/analyzer_experimental/lib/src/generated/element.dart

 // 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';
 import 'java_core.dart';
 import 'java_engine.dart';
 import 'utilities_collection.dart';
 import 'source.dart';
 import 'scanner.dart' show Keyword;
 import 'ast.dart' show Identifier, LibraryIdentifier;
@@ skipping 955 matching lines @@
    */
   LibraryElement get importedLibrary;
 
   /**
    * Return the prefix that was specified as part of the import directive, or `null` if there
    * was no prefix specified.
    *
    * @return the prefix that was specified as part of the import directive
    */
   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.
  *
  * @coverage dart.engine.element
  */
 abstract class LabelElement implements Element {
 
   /**
@@ skipping 2833 matching lines @@
   HtmlScriptElementImpl(XmlTagNode node) : super.con2(node.tag.lexeme, node.tag.offset);
 }
 /**
  * Instances of the class `ImportElementImpl` implement an [ImportElement].
  *
  * @coverage dart.engine.element
  */
 class ImportElementImpl extends ElementImpl implements ImportElement {
 
   /**
+   * The offset of this directive, may be `-1` if synthetic.
+   */
+  int _offset = -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 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;
 
   /**
@@ skipping 10 matching lines @@
 
   /**
    * Initialize a newly created import element.
    */
   ImportElementImpl() : super.con1(null);
   accept(ElementVisitor visitor) => visitor.visitImportElement(this);
   List<NamespaceCombinator> get combinators => _combinators;
   LibraryElement get importedLibrary => _importedLibrary;
   ElementKind get kind => ElementKind.IMPORT;
   PrefixElement get prefix => _prefix;
+  int get prefixOffset => _prefixOffset;
   String get uri => _uri;
+  int get uriEnd => _uriEnd;
 
   /**
    * Set the combinators that were specified as part of the import directive to the given array of
    * combinators.
    *
    * @param combinators the combinators that were specified as part of the import directive
    */
   void set combinators(List<NamespaceCombinator> combinators) {
     this._combinators = combinators;
   }
 
   /**
    * Set the library that is imported into this library by this import directive to the given
    * library.
    *
    * @param importedLibrary the library that is imported into this library
    */
   void set importedLibrary(LibraryElement importedLibrary) {
     this._importedLibrary = importedLibrary;
   }
 
   /**
+   * Set the offset of this directive.
+   */
+  void set offset(int offset) {
+    this._offset = offset;
+  }
+
+  /**
    * Set the prefix that was specified as part of the import directive to the given prefix.
    *
    * @param prefix the prefix that was specified as part of the import directive
    */
   void set prefix(PrefixElement prefix) {
     this._prefix = prefix;
   }
 
   /**
+   * Set the offset of the prefix of this import in the file that contains the this import
+   * directive.
+   */
+  void set prefixOffset(int prefixOffset) {
+    this._prefixOffset = prefixOffset;
+  }
+
+  /**
    * Set the URI that is specified by this directive.
    *
    * @param uri the URI that is specified by this directive.
    */
   void set uri(String uri) {
     this._uri = uri;
   }
+
+  /**
+   * Set the the offset of the character immediately following the last character of this node's
+   * URI. `-1` for synthetic import.
+   */
+  void set uriEnd(int uriEnd) {
+    this._uriEnd = uriEnd;
+  }
   void visitChildren(ElementVisitor visitor) {
     super.visitChildren(visitor);
     safelyVisitChild(_prefix, visitor);
   }
   void appendTo(JavaStringBuilder builder) {
     builder.append("import ");
     ((_importedLibrary as LibraryElementImpl)).appendTo(builder);
   }
-  String get identifier => ((_importedLibrary as LibraryElementImpl)).identifier;
+  String get identifier => "${((_importedLibrary as LibraryElementImpl)).identifier}@${_offset}";
 }
 /**
  * Instances of the class `LabelElementImpl` implement a `LabelElement`.
  *
  * @coverage dart.engine.element
  */
 class LabelElementImpl extends ElementImpl implements LabelElement {
 
   /**
    * A flag indicating whether this label is associated with a `switch` statement.
@@ skipping 2757 matching lines @@
           return false;
         }
       }
       return true;
     }
     ClassElement element = this.element;
     if (element == null || visitedClasses.contains(element)) {
       return false;
     }
     javaSetAdd(visitedClasses, element);
-    InterfaceType supertype = element.supertype;
+    InterfaceType supertype = superclass;
     if (supertype != null && ((supertype as InterfaceTypeImpl)).isMoreSpecificThan2(s, visitedClasses)) {
       return true;
     }
-    for (InterfaceType interfaceType in element.interfaces) {
+    for (InterfaceType interfaceType in interfaces) {
       if (((interfaceType as InterfaceTypeImpl)).isMoreSpecificThan2(s, visitedClasses)) {
         return true;
       }
     }
-    for (InterfaceType mixinType in element.mixins) {
+    for (InterfaceType mixinType in mixins) {
       if (((mixinType as InterfaceTypeImpl)).isMoreSpecificThan2(s, visitedClasses)) {
         return true;
       }
     }
     return false;
   }
   bool isSubtypeOf2(InterfaceType type, Set<ClassElement> visitedClasses) {
     InterfaceType typeT = this;
     InterfaceType typeS = type;
     ClassElement elementT = element;
@@ skipping 808 matching lines @@
 }
 /**
  * The interface `VoidType` defines the behavior of the unique object representing the type
  * `void`.
  *
  * @coverage dart.engine.type
  */
 abstract class VoidType implements Type2 {
   VoidType substitute2(List<Type2> argumentTypes, List<Type2> parameterTypes);
 }