New analzyer 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 490 matching lines @@
    */
   String computeDocumentationComment();
 
   /**
    * Return the element of the given class that most immediately encloses this element, or
    * `null` if there is no enclosing element of the given class.
    *
    * @param elementClass the class of the element to be returned
    * @return the element that encloses this element
    */
-  Element getAncestor(Type elementClass);
+  Element getAncestor(Predicate<Element> predicate);
 
   /**
    * Return the analysis context in which this element is defined.
    *
    * @return the analysis context in which this element is defined
    */
   AnalysisContext get context;
 
   /**
    * Return the display name of this element, or `null` if this element does not have a name.
@@ skipping 2089 matching lines @@
   ConstructorElement getNamedConstructor(String name) {
     for (ConstructorElement element in constructors) {
       String elementName = element.name;
       if (elementName != null && elementName == name) {
         return element;
       }
     }
     return null;
   }
 
-  ClassDeclaration get node => getNode2(ClassDeclaration);
+  ClassDeclaration get node => getNode2((node) => node is ClassDeclaration);
 
   PropertyAccessorElement getSetter(String setterName) {
     // TODO (jwren) revisit- should we append '=' here or require clients to include it?
     // Do we need the check for isSetter below?
     if (!StringUtilities.endsWithChar(setterName, 0x3D)) {
       setterName += '=';
     }
     for (PropertyAccessorElement accessor in _accessors) {
       if (accessor.isSetter && accessor.name == setterName) {
         return accessor;
@@ skipping 45 matching lines @@
       }
     }
     // not found
     return false;
   }
 
   bool hasReferenceToSuper() => hasModifier(Modifier.REFERENCES_SUPER);
 
   bool get isAbstract => hasModifier(Modifier.ABSTRACT);
 
-  bool get isOrInheritsProxy => isOrInheritsProxy2(this, new Set<ClassElement>());
+  bool get isOrInheritsProxy => safeIsOrInheritsProxy(this, new Set<ClassElement>());
 
   bool get isProxy {
     for (ElementAnnotation annotation in metadata) {
       if (annotation.isProxy) {
         return true;
       }
     }
     return false;
   }
 
@@ skipping 242 matching lines @@
         for (InterfaceType type in currentElement.mixins) {
           ClassElement element = type.element;
           if (!visitedClasses.contains(element)) {
             supertypes.add(type);
           }
         }
       }
     }
   }
 
-  bool isOrInheritsProxy2(ClassElement classElt, Set<ClassElement> visitedClassElts) {
+  bool safeIsOrInheritsProxy(ClassElement classElt, Set<ClassElement> visitedClassElts) {
     if (visitedClassElts.contains(classElt)) {
       return false;
     }
     visitedClassElts.add(classElt);
     if (classElt.isProxy) {
       return true;
-    } else if (classElt.supertype != null && isOrInheritsProxy2(classElt.supertype.element, visitedClassElts)) {
+    } else if (classElt.supertype != null && safeIsOrInheritsProxy(classElt.supertype.element, visitedClassElts)) {
       return true;
     }
     List<InterfaceType> supertypes = classElt.interfaces;
     for (int i = 0; i < supertypes.length; i++) {
-      if (isOrInheritsProxy2(supertypes[i].element, visitedClassElts)) {
+      if (safeIsOrInheritsProxy(supertypes[i].element, visitedClassElts)) {
         return true;
       }
     }
     supertypes = classElt.mixins;
     for (int i = 0; i < supertypes.length; i++) {
-      if (isOrInheritsProxy2(supertypes[i].element, visitedClassElts)) {
+      if (safeIsOrInheritsProxy(supertypes[i].element, visitedClassElts)) {
         return true;
       }
     }
     return false;
   }
 }
 
 /**
  * Instances of the class `CompilationUnitElementImpl` implement a
  * [CompilationUnitElement].
@@ skipping 343 matching lines @@
    *          declaration of this element
    */
   ConstructorElementImpl.con2(String name, int nameOffset) : super.con2(name, nameOffset);
 
   accept(ElementVisitor visitor) => visitor.visitConstructorElement(this);
 
   ClassElement get enclosingElement => super.enclosingElement as ClassElement;
 
   ElementKind get kind => ElementKind.CONSTRUCTOR;
 
-  ConstructorDeclaration get node => getNode2(ConstructorDeclaration);
+  ConstructorDeclaration get node => getNode2((node) => node is ConstructorDeclaration);
 
   bool get isConst => hasModifier(Modifier.CONST);
 
   bool get isDefaultConstructor {
     // unnamed
     String name = this.name;
     if (name != null && name.length != 0) {
       return false;
     }
     // no required parameters
@@ skipping 271 matching lines @@
   bool operator ==(Object object) {
     if (identical(this, object)) {
       return true;
     }
     if (object == null || hashCode != object.hashCode) {
       return false;
     }
     return object.runtimeType == runtimeType && (object as Element).location == location;
   }
 
-  Element getAncestor(Type elementClass) {
+  Element getAncestor(Predicate<Element> predicate) {
     Element ancestor = _enclosingElement;
-    while (ancestor != null && !isInstanceOf(ancestor, elementClass)) {
+    while (ancestor != null && !predicate(ancestor)) {
       ancestor = ancestor.enclosingElement;
     }
     return ancestor;
   }
 
   /**
    * Return the child of this element that is uniquely identified by the given identifier, or
    * `null` if there is no such child.
    *
    * @param identifier the identifier used to select a child
    * @return the child of this element with the given identifier
    */
   ElementImpl getChild(String identifier) => null;
 
   AnalysisContext get context {
     if (_enclosingElement == null) {
       return null;
     }
     return _enclosingElement.context;
   }
 
   String get displayName => _name;
 
   Element get enclosingElement => _enclosingElement;
 
-  LibraryElement get library => getAncestor(LibraryElement);
+  LibraryElement get library => getAncestor((element) => element is LibraryElement);
 
   ElementLocation get location => new ElementLocationImpl.con1(this);
 
   String get name => _name;
 
-  AstNode get node => getNode2(AstNode);
+  AstNode get node => getNode2((node) => node is AstNode);
 
   Source get source {
     if (_enclosingElement == null) {
       return null;
     }
     return _enclosingElement.source;
   }
 
   CompilationUnit get unit => context.resolveCompilationUnit(source, library);
 
@@ skipping 89 matching lines @@
    * Return an identifier that uniquely identifies this element among the children of this element's
    * parent.
    *
    * @return an identifier that uniquely identifies this element relative to its parent
    */
   String get identifier => name;
 
   /**
    * Return the resolved [AstNode] of the given type enclosing [getNameOffset].
    */
-  AstNode getNode2(Type clazz) {
+  AstNode getNode2(Predicate<AstNode> predicate) {
     CompilationUnit unit = this.unit;
     if (unit == null) {
       return null;
     }
     int offset = nameOffset;
     AstNode node = new NodeLocator.con1(offset).searchWithin(unit);
     if (node == null) {
       return null;
     }
-    return node.getAncestor(clazz);
+    return node.getAncestor(predicate);
   }
 
   /**
    * 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) => BooleanArray.get(_modifiers, modifier);
 
@@ skipping 670 matching lines @@
    *
    * @param nameOffset the offset of the name of this element in the file that contains the
    *          declaration of this element
    */
   FunctionElementImpl.con2(int nameOffset) : super.con2("", nameOffset);
 
   accept(ElementVisitor visitor) => visitor.visitFunctionElement(this);
 
   ElementKind get kind => ElementKind.FUNCTION;
 
-  FunctionDeclaration get node => getNode2(FunctionDeclaration);
+  FunctionDeclaration get node => getNode2((node) => node is FunctionDeclaration);
 
   SourceRange get visibleRange {
     if (_visibleRangeLength < 0) {
       return null;
     }
     return new SourceRange(_visibleRangeOffset, _visibleRangeLength);
   }
 
   bool get isStatic => enclosingElement is CompilationUnitElement;
 
@@ skipping 71 matching lines @@
         return typeParameter as TypeParameterElementImpl;
       }
     }
     return null;
   }
 
   CompilationUnitElement get enclosingElement => super.enclosingElement as CompilationUnitElement;
 
   ElementKind get kind => ElementKind.FUNCTION_TYPE_ALIAS;
 
-  FunctionTypeAlias get node => getNode2(FunctionTypeAlias);
+  FunctionTypeAlias get node => getNode2((node) => node is FunctionTypeAlias);
 
   List<ParameterElement> get parameters => _parameters;
 
   List<TypeParameterElement> get typeParameters => _typeParameters;
 
   /**
    * Set the parameters defined by this type alias to the given parameters.
    *
    * @param parameters the parameters defined by this type alias
    */
@@ skipping 665 matching lines @@
   }
 }
 
 /**
  * Instances of the class `LocalVariableElementImpl` implement a `LocalVariableElement`.
  */
 class LocalVariableElementImpl extends VariableElementImpl implements LocalVariableElement {
   /**
    * Is `true` if this variable is potentially mutated somewhere in its scope.
    */
-  bool _isPotentiallyMutatedInScope2 = false;
+  bool _potentiallyMutatedInScope = false;
 
   /**
    * Is `true` if this variable is potentially mutated somewhere in closure.
    */
-  bool _isPotentiallyMutatedInClosure2 = false;
+  bool _potentiallyMutatedInClosure = false;
 
   /**
    * The offset to the beginning of the visible range for this element.
    */
   int _visibleRangeOffset = 0;
 
   /**
    * The length of the visible range for this element, or `-1` if this element does not have a
    * visible range.
    */
   int _visibleRangeLength = -1;
 
   /**
    * An empty array of field elements.
    */
   static List<LocalVariableElement> EMPTY_ARRAY = new List<LocalVariableElement>(0);
 
   /**
    * Initialize a newly created local variable element to have the given name.
    *
    * @param name the name of this element
    */
   LocalVariableElementImpl(Identifier name) : super.con1(name);
 
   accept(ElementVisitor visitor) => visitor.visitLocalVariableElement(this);
 
   ElementKind get kind => ElementKind.LOCAL_VARIABLE;
 
   List<ToolkitObjectElement> get toolkitObjects {
-    CompilationUnitElementImpl unit = getAncestor(CompilationUnitElementImpl);
+    CompilationUnitElementImpl unit = getAncestor((element) => element is CompilationUnitElementImpl);
     if (unit == null) {
       return ToolkitObjectElement.EMPTY_ARRAY;
     }
     return unit.getToolkitObjects(this);
   }
 
   SourceRange get visibleRange {
     if (_visibleRangeLength < 0) {
       return null;
     }
     return new SourceRange(_visibleRangeOffset, _visibleRangeLength);
   }
 
-  bool get isPotentiallyMutatedInClosure => _isPotentiallyMutatedInClosure2;
+  bool get isPotentiallyMutatedInClosure => _potentiallyMutatedInClosure;
 
-  bool get isPotentiallyMutatedInScope => _isPotentiallyMutatedInScope2;
+  bool get isPotentiallyMutatedInScope => _potentiallyMutatedInScope;
 
   /**
    * Specifies that this variable is potentially mutated somewhere in closure.
    */
   void markPotentiallyMutatedInClosure() {
-    _isPotentiallyMutatedInClosure2 = true;
+    _potentiallyMutatedInClosure = true;
   }
 
   /**
    * Specifies that this variable is potentially mutated somewhere in its scope.
    */
   void markPotentiallyMutatedInScope() {
-    _isPotentiallyMutatedInScope2 = true;
+    _potentiallyMutatedInScope = true;
   }
 
   /**
    * Set the toolkit specific information objects attached to this variable.
    *
    * @param toolkitObjects the toolkit objects attached to this variable
    */
   void set toolkitObjects(List<ToolkitObjectElement> toolkitObjects) {
-    CompilationUnitElementImpl unit = getAncestor(CompilationUnitElementImpl);
+    CompilationUnitElementImpl unit = getAncestor((element) => element is CompilationUnitElementImpl);
     if (unit == null) {
       return;
     }
     unit.setToolkitObjects(this, toolkitObjects);
   }
 
   /**
    * Set the visible range for this element to the range starting at the given offset with the given
    * length.
    *
@@ skipping 49 matching lines @@
   String get name {
     String name = super.name;
     if (isOperator && name == "-") {
       if (parameters.length == 0) {
         return "unary-";
       }
     }
     return super.name;
   }
 
-  MethodDeclaration get node => getNode2(MethodDeclaration);
+  MethodDeclaration get node => getNode2((node) => node is MethodDeclaration);
 
   bool get isAbstract => hasModifier(Modifier.ABSTRACT);
 
   bool get isOperator {
     String name = displayName;
     if (name.isEmpty) {
       return false;
     }
     int first = name.codeUnitAt(0);
     return !((0x61 <= first && first <= 0x7A) || (0x41 <= first && first <= 0x5A) || first == 0x5F || first == 0x24);
@@ skipping 181 matching lines @@
    * @param conflictingElements the elements that conflict
    */
   MultiplyDefinedElementImpl(this.context, this.conflictingElements) {
     _name = conflictingElements[0].name;
   }
 
   accept(ElementVisitor visitor) => visitor.visitMultiplyDefinedElement(this);
 
   String computeDocumentationComment() => null;
 
-  Element getAncestor(Type elementClass) => null;
+  Element getAncestor(Predicate<Element> predicate) => null;
 
   String get displayName => _name;
 
   Element get enclosingElement => null;
 
   ElementKind get kind => ElementKind.ERROR;
 
   LibraryElement get library => null;
 
   ElementLocation get location => null;
@@ skipping 99 matching lines @@
   }
 }
 
 /**
  * Instances of the class `ParameterElementImpl` implement a `ParameterElement`.
  */
 class ParameterElementImpl extends VariableElementImpl implements ParameterElement {
   /**
    * Is `true` if this variable is potentially mutated somewhere in its scope.
    */
-  bool _isPotentiallyMutatedInScope3 = false;
+  bool _potentiallyMutatedInScope = false;
 
   /**
    * Is `true` if this variable is potentially mutated somewhere in closure.
    */
-  bool _isPotentiallyMutatedInClosure3 = false;
+  bool _potentiallyMutatedInClosure = false;
 
   /**
    * An array containing all of the parameters defined by this parameter element. There will only be
    * parameters if this parameter is a function typed parameter.
    */
   List<ParameterElement> _parameters = ParameterElementImpl.EMPTY_ARRAY;
 
   /**
    * The kind of this parameter.
    */
@@ skipping 57 matching lines @@
 
   SourceRange get visibleRange {
     if (_visibleRangeLength < 0) {
       return null;
     }
     return new SourceRange(_visibleRangeOffset, _visibleRangeLength);
   }
 
   bool get isInitializingFormal => false;
 
-  bool get isPotentiallyMutatedInClosure => _isPotentiallyMutatedInClosure3;
+  bool get isPotentiallyMutatedInClosure => _potentiallyMutatedInClosure;
 
-  bool get isPotentiallyMutatedInScope => _isPotentiallyMutatedInScope3;
+  bool get isPotentiallyMutatedInScope => _potentiallyMutatedInScope;
 
   /**
    * Specifies that this variable is potentially mutated somewhere in closure.
    */
   void markPotentiallyMutatedInClosure() {
-    _isPotentiallyMutatedInClosure3 = true;
+    _potentiallyMutatedInClosure = true;
   }
 
   /**
    * Specifies that this variable is potentially mutated somewhere in its scope.
    */
   void markPotentiallyMutatedInScope() {
-    _isPotentiallyMutatedInScope3 = true;
+    _potentiallyMutatedInScope = true;
   }
 
   /**
    * Set the range of the default value for this parameter to the range starting at the given offset
    * with the given length.
    *
    * @param offset the offset to the beginning of the default value range for this element
    * @param length the length of the default value range for this element, or `-1` if this
    *          element does not have a default value
    */
@@ skipping 175 matching lines @@
       return "${super.name}=";
     }
     return super.name;
   }
 
   AstNode get node {
     if (isSynthetic) {
       return null;
     }
     if (enclosingElement is ClassElement) {
-      return getNode2(MethodDeclaration);
+      return getNode2((node) => node is MethodDeclaration);
     }
     if (enclosingElement is CompilationUnitElement) {
-      return getNode2(FunctionDeclaration);
+      return getNode2((node) => node is FunctionDeclaration);
     }
     return null;
   }
 
   int get hashCode => ObjectUtilities.combineHashCodes(super.hashCode, isGetter ? 1 : 2);
 
   bool get isAbstract => hasModifier(Modifier.ABSTRACT);
 
   bool get isGetter => hasModifier(Modifier.GETTER);
 
@@ skipping 242 matching lines @@
    * Return the result of evaluating this variable's initializer as a compile-time constant
    * expression, or `null` if this variable is not a 'const' variable, if it does not have an
    * initializer, or if the compilation unit containing the variable has not been resolved.
    *
    * @return the result of evaluating this variable's initializer
    */
   EvaluationResultImpl get evaluationResult => null;
 
   FunctionElement get initializer => _initializer;
 
-  VariableDeclaration get node => getNode2(VariableDeclaration);
+  VariableDeclaration get node => getNode2((node) => node is VariableDeclaration);
 
   bool get isConst => hasModifier(Modifier.CONST);
 
   bool get isFinal => hasModifier(Modifier.FINAL);
 
   /**
    * Return `true` if this variable is potentially mutated somewhere in a closure. This
    * information is only available for local variables (including parameters) and only after the
    * compilation unit containing the variable has been resolved.
    *
@@ skipping 763 matching lines @@
    * @param baseElement the element on which the parameterized element was created
    * @param definingType the type in which the element is defined
    */
   Member(Element baseElement, ParameterizedType definingType) {
     this._baseElement = baseElement;
     this._definingType = definingType;
   }
 
   String computeDocumentationComment() => _baseElement.computeDocumentationComment();
 
-  Element getAncestor(Type elementClass) => baseElement.getAncestor(elementClass);
+  Element getAncestor(Predicate<Element> predicate) => baseElement.getAncestor(predicate);
 
   /**
    * Return the element on which the parameterized element was created.
    *
    * @return the element on which the parameterized element was created
    */
   Element get baseElement => _baseElement;
 
   AnalysisContext get context => _baseElement.context;
 
@@ skipping 213 matching lines @@
   /**
    * Initialize a newly created element to represent a parameter of the given parameterized type.
    *
    * @param baseElement the element on which the parameterized element was created
    * @param definingType the type in which the element is defined
    */
   ParameterMember(ParameterElement baseElement, ParameterizedType definingType) : super(baseElement, definingType);
 
   accept(ElementVisitor visitor) => visitor.visitParameterElement(this);
 
-  Element getAncestor(Type elementClass) {
-    Element element = baseElement.getAncestor(elementClass);
+  Element getAncestor(Predicate<Element> predicate) {
+    Element element = baseElement.getAncestor(predicate);
     ParameterizedType definingType = this.definingType;
     if (definingType is InterfaceType) {
       InterfaceType definingInterfaceType = definingType;
       if (element is ConstructorElement) {
         return ConstructorMember.from(element, definingInterfaceType);
       } else if (element is MethodElement) {
         return MethodMember.from(element, definingInterfaceType);
       } else if (element is PropertyAccessorElement) {
         return PropertyAccessorMember.from(element, definingInterfaceType);
       }
@@ skipping 478 matching lines @@
       return DynamicTypeImpl.instance;
     }
     return baseReturnType.substitute2(typeArguments, TypeParameterTypeImpl.getTypes(typeParameters));
   }
 
   List<TypeParameterElement> get typeParameters {
     Element element = this.element;
     if (element is FunctionTypeAliasElement) {
       return element.typeParameters;
     }
-    ClassElement definingClass = element.getAncestor(ClassElement);
+    ClassElement definingClass = element.getAncestor((element) => element is ClassElement);
     if (definingClass != null) {
       return definingClass.typeParameters;
     }
     return TypeParameterElementImpl.EMPTY_ARRAY;
   }
 
   int get hashCode {
     if (element == null) {
       return 0;
     }
@@ skipping 1996 matching lines @@
   TypeParameterElement get element;
 }
 
 /**
  * The interface `VoidType` defines the behavior of the unique object representing the type
  * `void`.
  */
 abstract class VoidType implements Type2 {
   VoidType substitute2(List<Type2> argumentTypes, List<Type2> parameterTypes);
 }