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 991 matching lines @@
   /**
    * 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 is defined by an enum declaration.
+   *
+   * @return `true` if this class is defined by an enum declaration
+   */
+  bool get isEnum;
+
+  /**
    * Return `true` if this class [isProxy], or if it inherits the proxy annotation
    * from a supertype.
    *
    * @return `true` if this class defines or inherits a proxy
    */
   bool get isOrInheritsProxy;
 
   /**
    * Return `true` if this element has an annotation of the form '@proxy'.
    *
@@ skipping 446 matching lines @@
         return true;
       }
     }
     return false;
   }
 
   @override
   bool get isAbstract => hasModifier(Modifier.ABSTRACT);
 
   @override
+  bool get isEnum => hasModifier(Modifier.ENUM);
+
+  @override
   bool get isOrInheritsProxy => _safeIsOrInheritsProxy(this, new HashSet<ClassElement>());
 
   @override
   bool get isProxy {
     for (ElementAnnotation annotation in metadata) {
       if (annotation.isProxy) {
         return true;
       }
     }
     return false;
@@ skipping 56 matching lines @@
    * @param constructors the constructors contained in this class
    */
   void set constructors(List<ConstructorElement> constructors) {
     for (ConstructorElement constructor in constructors) {
       (constructor as ConstructorElementImpl).enclosingElement = this;
     }
     this._constructors = constructors;
   }
 
   /**
+   * Set whether this class is defined by an enum declaration to correspond to the given value.
+   *
+   * @param isEnum `true` if the class is defined by an enum declaration
+   */
+  void set enum2(bool isEnum) {
+    setModifier(Modifier.ENUM, isEnum);
+  }
+
+  /**
    * Set the fields contained in this class to the given fields.
    *
    * @param fields the fields contained in this class
    */
   void set fields(List<FieldElement> fields) {
     for (FieldElement field in fields) {
       (field as FieldElementImpl).enclosingElement = this;
     }
     this._fields = fields;
   }
@@ skipping 1292 matching lines @@
   }
 
   @override
   bool internalEquals(Object object, Set<ElementPair> visitedElementPairs) => identical(object, this);
 
   @override
   bool internalIsMoreSpecificThan(DartType type, bool withDynamic, Set<TypeImpl_TypePair> visitedTypePairs) {
     // T is S
     if (identical(this, type)) {
       return true;
+    } else if (type is UnionType) {
+      throw new NotImplementedException("No known use case");
     }
     // else
     return withDynamic;
   }
 
   @override
   bool internalIsSubtypeOf(DartType type, Set<TypeImpl_TypePair> visitedTypePairs) => true;
 }
 
 /**
@@ skipping 1215 matching lines @@
   DartType get returnType;
 
   /**
    * Return the type of function defined by this executable element.
    *
    * @return the type of function defined by this executable element
    */
   FunctionType get type;
 
   /**
+   * Return `true` if this executable element has body marked as being asynchronous.
+   *
+   * @return `true` if this executable element has body marked as being asynchronous
+   */
+  bool get isAsynchronous;
+
+  /**
+   * Return `true` if this executable element has a body marked as being a generator.
+   *
+   * @return `true` if this executable element has a body marked as being a generator
+   */
+  bool get isGenerator;
+
+  /**
    * Return `true` if this executable element is an operator. The test may be based on the
    * name of the executable element, in which case the result will be correct when the name is
    * legal.
    *
    * @return `true` if this executable element is an operator
    */
   bool get isOperator;
 
   /**
    * Return `true` if this element is a static element. A static element is an element that is
    * not associated with a particular instance, but rather with an entire library or class.
    *
    * @return `true` if this executable element is a static element
    */
   bool get isStatic;
+
+  /**
+   * Return `true` if this executable element has a body marked as being synchronous.
+   *
+   * @return `true` if this executable element has a body marked as being synchronous
+   */
+  bool get isSynchronous;
 }
 
 /**
  * The abstract class `ExecutableElementImpl` implements the behavior common to
  * `ExecutableElement`s.
  */
 abstract class ExecutableElementImpl extends ElementImpl implements ExecutableElement {
   /**
    * An array containing all of the functions defined within this executable element.
    */
@@ skipping 76 matching lines @@
   @override
   List<LabelElement> get labels => _labels;
 
   @override
   List<LocalVariableElement> get localVariables => _localVariables;
 
   @override
   List<ParameterElement> get parameters => _parameters;
 
   @override
+  bool get isAsynchronous => hasModifier(Modifier.ASYNCHRONOUS);
+
+  @override
+  bool get isGenerator => hasModifier(Modifier.GENERATOR);
+
+  @override
   bool get isOperator => false;
 
+  @override
+  bool get isSynchronous => !hasModifier(Modifier.ASYNCHRONOUS);
+
   /**
    * Set the functions defined within this executable element to the given functions.
    *
    * @param functions the functions defined within this executable element
    */
   void set functions(List<FunctionElement> functions) {
     for (FunctionElement function in functions) {
       (function as FunctionElementImpl).enclosingElement = this;
     }
     this._functions = functions;
@@ skipping 137 matching lines @@
     return parameterizedParameters;
   }
 
   @override
   DartType get returnType => substituteFor(baseElement.returnType);
 
   @override
   FunctionType get type => substituteFor(baseElement.type);
 
   @override
+  bool get isAsynchronous => baseElement.isAsynchronous;
+
+  @override
+  bool get isGenerator => baseElement.isGenerator;
+
+  @override
   bool get isOperator => baseElement.isOperator;
 
   @override
   bool get isStatic => baseElement.isStatic;
 
   @override
+  bool get isSynchronous => baseElement.isSynchronous;
+
+  @override
   void visitChildren(ElementVisitor visitor) {
     // TODO(brianwilkerson) We need to finish implementing the accessors used below so that we can
     // safely invoke them.
     super.visitChildren(visitor);
     safelyVisitChildren(baseElement.functions, visitor);
     safelyVisitChildren(labels, visitor);
     safelyVisitChildren(baseElement.localVariables, visitor);
     safelyVisitChildren(parameters, visitor);
   }
 }
@@ skipping 1034 matching lines @@
     return hashCode;
   }
 
   @override
   bool internalIsMoreSpecificThan(DartType type, bool withDynamic, Set<TypeImpl_TypePair> visitedTypePairs) {
     // trivial base cases
     if (type == null) {
       return false;
     } else if (identical(this, type) || type.isDynamic || type.isDartCoreFunction || type.isObject) {
       return true;
+    } else if (type is UnionType) {
+      throw new NotImplementedException("No known use case");
     } else if (type is! FunctionType) {
       return false;
     } else if (this == type) {
       return true;
     }
     FunctionType t = this;
     FunctionType s = type as FunctionType;
     List<DartType> tTypes = t.normalParameterTypes;
     List<DartType> tOpTypes = t.optionalParameterTypes;
     List<DartType> sTypes = s.normalParameterTypes;
@@ skipping 1749 matching lines @@
 
   @override
   bool internalIsMoreSpecificThan(DartType type, bool withDynamic, Set<TypeImpl_TypePair> visitedTypePairs) {
     //
     // S is dynamic.
     // The test to determine whether S is dynamic is done here because dynamic is not an instance of
     // InterfaceType.
     //
     if (identical(type, DynamicTypeImpl.instance)) {
       return true;
+    } else if (type is UnionType) {
+      throw new NotImplementedException("No known use case");
     } else if (type is! InterfaceType) {
       return false;
     }
     return _isMoreSpecificThan(type as InterfaceType, new HashSet<ClassElement>(), withDynamic, visitedTypePairs);
   }
 
   @override
   bool internalIsSubtypeOf(DartType type, Set<TypeImpl_TypePair> visitedTypePairs) {
     //
     // T is a subtype of S, written T <: S, iff [bottom/dynamic]T << S
@@ skipping 1404 matching lines @@
  * The enumeration `Modifier` defines constants for all of the modifiers defined by the Dart
  * language and for a few additional flags that are useful.
  */
 class Modifier extends Enum<Modifier> {
   /**
    * Indicates that the modifier 'abstract' was applied to the element.
    */
   static const Modifier ABSTRACT = const Modifier('ABSTRACT', 0);
 
   /**
+   * Indicates that an executable element has a body marked as being asynchronous.
+   */
+  static const Modifier ASYNCHRONOUS = const Modifier('ASYNCHRONOUS', 1);
+
+  /**
    * Indicates that the modifier 'const' was applied to the element.
    */
-  static const Modifier CONST = const Modifier('CONST', 1);
+  static const Modifier CONST = const Modifier('CONST', 2);
 
   /**
    * Indicates that the import element represents a deferred library.
    */
-  static const Modifier DEFERRED = const Modifier('DEFERRED', 2);
+  static const Modifier DEFERRED = const Modifier('DEFERRED', 3);
+
+  /**
+   * Indicates that a class element was defined by an enum declaration.
+   */
+  static const Modifier ENUM = const Modifier('ENUM', 4);
 
   /**
    * Indicates that the modifier 'factory' was applied to the element.
    */
-  static const Modifier FACTORY = const Modifier('FACTORY', 3);
+  static const Modifier FACTORY = const Modifier('FACTORY', 5);
 
   /**
    * Indicates that the modifier 'final' was applied to the element.
    */
-  static const Modifier FINAL = const Modifier('FINAL', 4);
+  static const Modifier FINAL = const Modifier('FINAL', 6);
+
+  /**
+   * Indicates that an executable element has a body marked as being a generator.
+   */
+  static const Modifier GENERATOR = const Modifier('GENERATOR', 7);
 
   /**
    * Indicates that the pseudo-modifier 'get' was applied to the element.
    */
-  static const Modifier GETTER = const Modifier('GETTER', 5);
+  static const Modifier GETTER = const Modifier('GETTER', 8);
 
   /**
    * A flag used for libraries indicating that the defining compilation unit contains at least one
    * import directive whose URI uses the "dart-ext" scheme.
    */
-  static const Modifier HAS_EXT_URI = const Modifier('HAS_EXT_URI', 6);
+  static const Modifier HAS_EXT_URI = const Modifier('HAS_EXT_URI', 9);
 
-  static const Modifier MIXIN = const Modifier('MIXIN', 7);
+  /**
+   * Indicates that a class can validly be used as a mixin.
+   */
+  static const Modifier MIXIN = const Modifier('MIXIN', 10);
 
   /**
    * Indicates that the value of a parameter or local variable might be mutated within the context.
    */
-  static const Modifier POTENTIALLY_MUTATED_IN_CONTEXT = const Modifier('POTENTIALLY_MUTATED_IN_CONTEXT', 8);
+  static const Modifier POTENTIALLY_MUTATED_IN_CONTEXT = const Modifier('POTENTIALLY_MUTATED_IN_CONTEXT', 11);
 
   /**
    * Indicates that the value of a parameter or local variable might be mutated within the scope.
    */
-  static const Modifier POTENTIALLY_MUTATED_IN_SCOPE = const Modifier('POTENTIALLY_MUTATED_IN_SCOPE', 9);
+  static const Modifier POTENTIALLY_MUTATED_IN_SCOPE = const Modifier('POTENTIALLY_MUTATED_IN_SCOPE', 12);
 
-  static const Modifier REFERENCES_SUPER = const Modifier('REFERENCES_SUPER', 10);
+  /**
+   * Indicates that a class contains an explicit reference to 'super'.
+   */
+  static const Modifier REFERENCES_SUPER = const Modifier('REFERENCES_SUPER', 13);
 
   /**
    * Indicates that the pseudo-modifier 'set' was applied to the element.
    */
-  static const Modifier SETTER = const Modifier('SETTER', 11);
+  static const Modifier SETTER = const Modifier('SETTER', 14);
 
   /**
    * Indicates that the modifier 'static' was applied to the element.
    */
-  static const Modifier STATIC = const Modifier('STATIC', 12);
+  static const Modifier STATIC = const Modifier('STATIC', 15);
 
   /**
    * Indicates that the element does not appear in the source code but was implicitly created. For
    * example, if a class does not define any constructors, an implicit zero-argument constructor
    * will be created and it will be marked as being synthetic.
    */
-  static const Modifier SYNTHETIC = const Modifier('SYNTHETIC', 13);
+  static const Modifier SYNTHETIC = const Modifier('SYNTHETIC', 16);
 
-  static const Modifier TYPEDEF = const Modifier('TYPEDEF', 14);
+  /**
+   * Indicates that a class was defined using an alias. TODO(brianwilkerson) This should be renamed
+   * to 'ALIAS'.
+   */
+  static const Modifier TYPEDEF = const Modifier('TYPEDEF', 17);
 
   static const List<Modifier> values = const [
       ABSTRACT,
+      ASYNCHRONOUS,
       CONST,
       DEFERRED,
+      ENUM,
       FACTORY,
       FINAL,
+      GENERATOR,
       GETTER,
       HAS_EXT_URI,
       MIXIN,
       POTENTIALLY_MUTATED_IN_CONTEXT,
       POTENTIALLY_MUTATED_IN_SCOPE,
       REFERENCES_SUPER,
       SETTER,
       STATIC,
       SYNTHETIC,
       TYPEDEF];
@@ skipping 1040 matching lines @@
   PropertyAccessorElementImpl.forNode(Identifier name) : super.forNode(name);
 
   /**
    * Initialize a newly created synthetic property accessor element to be associated with the given
    * variable.
    *
    * @param variable the variable with which this access is associated
    */
   PropertyAccessorElementImpl.forVariable(PropertyInducingElementImpl variable) : super(variable.name, variable.nameOffset) {
     this.variable = variable;
+    static = variable.isStatic;
     synthetic = true;
   }
 
   @override
   accept(ElementVisitor visitor) => visitor.visitPropertyAccessorElement(this);
 
   @override
   bool operator ==(Object object) => super == object && isGetter == (object as PropertyAccessorElement).isGetter;
 
   @override
@@ skipping 1230 matching lines @@
 /**
  * The interface `UndefinedElement` defines the behavior of pseudo-elements that represent
  * names that are undefined. This situation is not allowed by the language, so objects implementing
  * this interface always represent an error. As a result, most of the normal operations on elements
  * do not make sense and will return useless results.
  */
 abstract class UndefinedElement implements Element {
 }
 
 /**
+ * A flat immutable union of `Type`s. Here "flat" means a union type never contains another
+ * union type.
+ */
+abstract class UnionType implements DartType {
+  /**
+   * @return an immutable view of the types in this union type.
+   */
+  Set<DartType> get elements;
+}
+
+/**
+ * In addition to the methods of the `UnionType` interface we add a factory method
+ * `union` for building unions.
+ */
+class UnionTypeImpl extends TypeImpl implements UnionType {
+  /**
+   * Any unions in the `types` will be flattened in the returned union. If there is only one
+   * type after flattening then it will be returned directly, instead of a singleton union.
+   *
+   * @param types the `Type`s to union
+   * @return a `Type` comprising the `Type`s in `types`
+   */
+  static DartType union(List<DartType> types) {
+    Set<DartType> set = new HashSet<DartType>();
+    for (DartType t in types) {
+      if (t is UnionType) {
+        set.addAll(t.elements);
+      } else {
+        set.add(t);
+      }
+    }
+    if (set.length == 0) {
+      throw new IllegalArgumentException("No known use case for empty unions.");
+    } else if (set.length == 1) {
+      return new JavaIterator(set).next();
+    } else {
+      return new UnionTypeImpl(set);
+    }
+  }
+
+  /**
+   * The types in this union.
+   */
+  final Set<DartType> _types;
+
+  /**
+   * This constructor should only be called by the `union` factory: it does not check that its
+   * argument `types` contains no union types.
+   *
+   * @param types
+   */
+  UnionTypeImpl(this._types) : super(null, null);
+
+  @override
+  bool operator ==(Object other) {
+    if (other == null || other is! UnionType) {
+      return false;
+    } else if (identical(this, other)) {
+      return true;
+    } else {
+      return javaSetEquals(this._types, (other as UnionType).elements);
+    }
+  }
+
+  @override
+  Set<DartType> get elements => _types;
+
+  @override
+  int get hashCode => this._types.hashCode;
+
+  @override
+  DartType substitute2(List<DartType> argumentTypes, List<DartType> parameterTypes) {
+    // I can't think of any reason to substitute into a union type, since
+    // they should only appear at the top level and not be be nested inside
+    // other types.
+    //
+    // If there were a reason, then the implementation is to form a new union type
+    // by mapping the substitution over the elements of this union type.
+    throw new NotImplementedException("No known use case.");
+  }
+
+  @override
+  bool internalEquals(Object object, Set<ElementPair> visitedElementPairs) {
+    // TODO(collinsn): I understand why we have the [visitedElementPairs]
+    // in subtyping definitions: the user code could have inheritance loops, e.g.
+    //
+    //   class A extends B {}
+    //   class B extends A {}
+    //
+    // However, I don't see how a type equality comparison could cause a loop, since type
+    // equality should be structural. For example, we have
+    //
+    //   G<X1,...,Xm> = H<Y1,...,Yn>
+    //
+    // when [G = H /\ m = n /\ for all i. Xi = Yi]. Assuming there is no way to build
+    // loopy generics (which would break [toString()]), each of the equality comparisons
+    // above are on something structurally smaller.
+    throw new NotImplementedException("I don't believe there is any concern about infinite loops in type equality comparisons.");
+  }
+
+  @override
+  bool internalIsMoreSpecificThan(DartType type, bool withDynamic, Set<TypeImpl_TypePair> visitedTypePairs) {
+    // I can't think of any reason to use [isMoreSpecificThan] for union types.
+    throw new NotImplementedException("No known use case.");
+  }
+
+  @override
+  bool internalIsSubtypeOf(DartType type, Set<TypeImpl_TypePair> visitedTypePairs) {
+    // TODO(collinsn): what version of subtyping do we want?
+    //
+    // The more unsound version: any.
+    /*
+    for (Type t : this.types) {
+      if (((TypeImpl) t).internalIsSubtypeOf(type, visitedTypePairs)) {
+        return true;
+      }
+    }
+    return false;
+    */
+    // The less unsound version: all.
+    for (DartType t in this._types) {
+      if (!(t as TypeImpl).internalIsSubtypeOf(type, visitedTypePairs)) {
+        return false;
+      }
+    }
+    return true;
+  }
+
+  /**
+   * The super type test for union types is uniform in non-union subtypes. So, other
+   * `TypeImpl`s can call this method to implement @ internalIsSubtypeOf} for union types.
+   *
+   * @param type
+   * @param visitedTypePairs
+   * @return true if this union type is a super type of `type`
+   */
+  bool internalIsSuperTypeOf(DartType type, Set<TypeImpl_TypePair> visitedTypePairs) {
+    // This implementation does not make sense when [type] is a union type, at least
+    // for the "less unsound" version of [internalIsSubtypeOf] above.
+    if (type is UnionType) {
+      throw new IllegalArgumentException("Only non-union types are supported.");
+    }
+    for (DartType t in this._types) {
+      if ((type as TypeImpl).internalIsSubtypeOf(t, visitedTypePairs)) {
+        return true;
+      }
+    }
+    return false;
+  }
+}
+
+/**
  * 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
    */
@@ skipping 314 matching lines @@
   @override
   VoidTypeImpl substitute2(List<DartType> argumentTypes, List<DartType> parameterTypes) => this;
 
   @override
   bool internalEquals(Object object, Set<ElementPair> visitedElementPairs) => identical(object, this);
 
   @override
   bool internalIsMoreSpecificThan(DartType type, bool withDynamic, Set<TypeImpl_TypePair> visitedTypePairs) => isSubtypeOf(type);
 
   @override
-  bool internalIsSubtypeOf(DartType type, Set<TypeImpl_TypePair> visitedTypePairs) => identical(type, this) || identical(type, DynamicTypeImpl.instance);
+  bool internalIsSubtypeOf(DartType type, Set<TypeImpl_TypePair> visitedTypePairs) {
+    if (type is UnionType) {
+      throw new NotImplementedException("No known use case");
+    }
+    // The only subtype relations that pertain to void are therefore:
+    // void <: void (by reflexivity)
+    // bottom <: void (as bottom is a subtype of all types).
+    // void <: dynamic (as dynamic is a supertype of all types)
+    return identical(type, this) || identical(type, DynamicTypeImpl.instance);
+  }
 }