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;
 import 'sdk.dart' show DartSdk;
 import 'html.dart' show XmlTagNode;
 import 'engine.dart' show AnalysisContext;
 import 'constant.dart' show EvaluationResultImpl;
 import 'utilities_dart.dart';
 /**
  * The interface `ClassElement` defines the behavior of elements that represent a class.
@@ skipping 537 matching lines @@
    *
    * @return the field, variable, or constructor being used as an annotation
    */
   Element get element;
 }
 /**
  * The enumeration `ElementKind` defines the various kinds of elements in the element model.
  *
  * @coverage dart.engine.element
  */
-class ElementKind implements Comparable<ElementKind> {
+class ElementKind implements Enum<ElementKind> {
   static final ElementKind CLASS = new ElementKind('CLASS', 0, "class");
   static final ElementKind COMPILATION_UNIT = new ElementKind('COMPILATION_UNIT', 1, "compilation unit");
   static final ElementKind CONSTRUCTOR = new ElementKind('CONSTRUCTOR', 2, "constructor");
   static final ElementKind DYNAMIC = new ElementKind('DYNAMIC', 3, "<dynamic>");
   static final ElementKind EMBEDDED_HTML_SCRIPT = new ElementKind('EMBEDDED_HTML_SCRIPT', 4, "embedded html script");
   static final ElementKind ERROR = new ElementKind('ERROR', 5, "<error>");
   static final ElementKind EXPORT = new ElementKind('EXPORT', 6, "export directive");
   static final ElementKind EXTERNAL_HTML_SCRIPT = new ElementKind('EXTERNAL_HTML_SCRIPT', 7, "external html script");
   static final ElementKind FIELD = new ElementKind('FIELD', 8, "field");
   static final ElementKind FUNCTION = new ElementKind('FUNCTION', 9, "function");
@@ skipping 585 matching lines @@
  */
 abstract class MultiplyDefinedElement implements Element {
 
   /**
    * Return an array containing all of the elements that were defined within the scope to have the
    * same name.
    *
    * @return the elements that were defined with the same name
    */
   List<Element> get conflictingElements;
+
+  /**
+   * Return the type of this element as the dynamic type.
+   *
+   * @return the type of this element as the dynamic type
+   */
+  Type2 get type;
 }
 /**
  * The interface `NamespaceCombinator` defines the behavior common to objects that control how
  * namespaces are combined.
  *
  * @coverage dart.engine.element
  */
 abstract class NamespaceCombinator {
 
   /**
@@ skipping 1481 matching lines @@
 
   /**
    * The offset of the name of this element in the file that contains the declaration of this
    * element.
    */
   int _nameOffset = 0;
 
   /**
    * A bit-encoded form of the modifiers associated with this element.
    */
-  Set<Modifier> _modifiers;
+  int _modifiers = 0;
 
   /**
    * An array containing all of the metadata associated with this element.
    */
   List<ElementAnnotation> _metadata = ElementAnnotationImpl.EMPTY_ARRAY;
 
   /**
    * A cached copy of the calculated hashCode for this element.
    */
   int _cachedHashCode = 0;
@@ skipping 131 matching lines @@
    * @return an identifier that uniquely identifies this element relative to its parent
    */
   String get identifier => name;
 
   /**
    * Return `true` if this element has the given modifier associated with it.
    *
    * @param modifier the modifier being tested for
    * @return `true` if this element has the given modifier associated with it
    */
-  bool hasModifier(Modifier modifier) => _modifiers != null && _modifiers.contains(modifier);
+  bool hasModifier(Modifier modifier) => BooleanArray.get(_modifiers, modifier);
 
   /**
    * If the given child is not `null`, use the given visitor to visit it.
    *
    * @param child the child to be visited
    * @param visitor the visitor to be used to visit the child
    */
   void safelyVisitChild(Element child, ElementVisitor<Object> visitor) {
     if (child != null) {
       child.accept(visitor);
@@ skipping 24 matching lines @@
   }
 
   /**
    * Set whether the given modifier is associated with this element to correspond to the given
    * value.
    *
    * @param modifier the modifier to be set
    * @param value `true` if the modifier is to be associated with this element
    */
   void setModifier(Modifier modifier, bool value) {
-    if (value) {
-      if (_modifiers == null) {
-        _modifiers = new Set();
-      }
-      _modifiers.add(modifier);
-    } else {
-      if (_modifiers != null) {
-        _modifiers.remove(modifier);
-        if (_modifiers.isEmpty) {
-          _modifiers = null;
-        }
-      }
-    }
+    _modifiers = BooleanArray.set(_modifiers, modifier, value);
   }
 }
 /**
  * Instances of the class `ElementLocationImpl` implement an [ElementLocation].
  *
  * @coverage dart.engine.element
  */
 class ElementLocationImpl implements ElementLocation {
 
   /**
@@ skipping 63 matching lines @@
     JavaStringBuilder builder = new JavaStringBuilder();
     int length = _components.length;
     for (int i = 0; i < length; i++) {
       if (i > 0) {
         builder.appendChar(_SEPARATOR_CHAR);
       }
       encode(builder, _components[i]);
     }
     return builder.toString();
   }
-  int get hashCode => JavaArrays.makeHashCode(_components);
+  int get hashCode {
+    int result = 1;
+    for (int i = 0; i < _components.length; i++) {
+      String component = _components[i];
+      int componentHash;
+      if (i <= 1) {
+        componentHash = hashSourceComponent(component);
+      } else {
+        componentHash = component.hashCode;
+      }
+      result = 31 * result + componentHash;
+    }
+    return result;
+  }
   String toString() => encoding;
 
   /**
    * Decode the encoded form of a location into an array of components.
    *
    * @param encoding the encoded form of a location
    * @return the components that were encoded
    */
   List<String> decode(String encoding) {
     List<String> components = new List<String>();
@@ skipping 51 matching lines @@
     if (left == null) {
       return right == null;
     } else if (right == null) {
       return false;
     }
     if (left.length <= 1 || right.length <= 1) {
       return left == right;
     }
     return left.substring(1) == right.substring(1);
   }
+
+  /**
+   * Return the hash code of the given encoded source component, ignoring the source type indicator.
+   *
+   * @param sourceComponent the component to compute a hash code
+   * @return the hash code of the given encoded source component
+   */
+  int hashSourceComponent(String sourceComponent) {
+    if (sourceComponent.length <= 1) {
+      return sourceComponent.hashCode;
+    }
+    return sourceComponent.substring(1).hashCode;
+  }
 }
 /**
  * Instances of the class `EmbeddedHtmlScriptElementImpl` implement an
  * [EmbeddedHtmlScriptElement].
  *
  * @coverage dart.engine.element
  */
 class EmbeddedHtmlScriptElementImpl extends HtmlScriptElementImpl implements EmbeddedHtmlScriptElement {
 
   /**
@@ skipping 544 matching lines @@
    * Set the type variables defined for this type to the given variables.
    *
    * @param typeVariables the type variables defined for this type
    */
   void set typeVariables(List<TypeVariableElement> typeVariables2) {
     for (TypeVariableElement variable in typeVariables2) {
       ((variable as TypeVariableElementImpl)).enclosingElement = this;
     }
     this._typeVariables = typeVariables2;
   }
+
+  /**
+   * Set the parameters defined by this type alias to the given parameters without becoming the
+   * parent of the parameters. This should only be used by the [TypeResolverVisitor] when
+   * creating a synthetic type alias.
+   *
+   * @param parameters the parameters defined by this type alias
+   */
+  void shareParameters(List<ParameterElement> parameters2) {
+    this._parameters = parameters2;
+  }
+
+  /**
+   * Set the type variables defined for this type to the given variables without becoming the parent
+   * of the variables. This should only be used by the [TypeResolverVisitor] when creating a
+   * synthetic type alias.
+   *
+   * @param typeVariables the type variables defined for this type
+   */
+  void shareTypeVariables(List<TypeVariableElement> typeVariables2) {
+    this._typeVariables = typeVariables2;
+  }
   void visitChildren(ElementVisitor<Object> visitor) {
     super.visitChildren(visitor);
     safelyVisitChildren(_parameters, visitor);
     safelyVisitChildren(_typeVariables, visitor);
   }
   void appendTo(JavaStringBuilder builder) {
     builder.append("typedef ");
     builder.append(displayName);
     int variableCount = _typeVariables.length;
     if (variableCount > 0) {
@@ skipping 696 matching lines @@
     builder.append(displayName);
     super.appendTo(builder);
   }
 }
 /**
  * The enumeration `Modifier` defines constants for all of the modifiers defined by the Dart
  * language and for a few additional flags that are useful.
  *
  * @coverage dart.engine.element
  */
-class Modifier implements Comparable<Modifier> {
+class Modifier implements Enum<Modifier> {
   static final Modifier ABSTRACT = new Modifier('ABSTRACT', 0);
   static final Modifier CONST = new Modifier('CONST', 1);
   static final Modifier FACTORY = new Modifier('FACTORY', 2);
   static final Modifier FINAL = new Modifier('FINAL', 3);
   static final Modifier GETTER = new Modifier('GETTER', 4);
   static final Modifier MIXIN = new Modifier('MIXIN', 5);
   static final Modifier REFERENCES_SUPER = new Modifier('REFERENCES_SUPER', 6);
   static final Modifier SETTER = new Modifier('SETTER', 7);
   static final Modifier STATIC = new Modifier('STATIC', 8);
   static final Modifier SYNTHETIC = new Modifier('SYNTHETIC', 9);
@@ skipping 62 matching lines @@
   AnalysisContext get context => _context;
   String get displayName => _name;
   Element get enclosingElement => null;
   ElementKind get kind => ElementKind.ERROR;
   LibraryElement get library => null;
   ElementLocation get location => null;
   List<ElementAnnotation> get metadata => ElementAnnotationImpl.EMPTY_ARRAY;
   String get name => _name;
   int get nameOffset => -1;
   Source get source => null;
+  Type2 get type => DynamicTypeImpl.instance;
   bool isAccessibleIn(LibraryElement library) {
     for (Element element in _conflictingElements) {
       if (element.isAccessibleIn(library)) {
         return true;
       }
     }
     return false;
   }
   bool get isSynthetic => true;
   String toString() {
@@ skipping 665 matching lines @@
    * @param baseConstructor the base constructor for which a member might be created
    * @param definingType the type defining the parameters and arguments to be used in the
    *          substitution
    * @return the constructor element that will return the correctly substituted types
    */
   static ConstructorElement from(ConstructorElement baseConstructor, InterfaceType definingType) {
     if (baseConstructor == null || definingType.typeArguments.length == 0) {
       return baseConstructor;
     }
     FunctionType baseType = baseConstructor.type;
+    if (baseType == null) {
+      return baseConstructor;
+    }
     List<Type2> argumentTypes = definingType.typeArguments;
     List<Type2> parameterTypes = definingType.element.type.typeArguments;
     FunctionType substitutedType = baseType.substitute2(argumentTypes, parameterTypes);
     if (baseType == substitutedType) {
       return baseConstructor;
     }
     return new ConstructorMember(baseConstructor, definingType);
   }
 
   /**
@@ skipping 2350 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);
 }