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 1044 matching lines @@
    * </blockquote>
    *
    * @param getterName the name of the getter being looked up
    * @param library the library with respect to which the lookup is being performed
    * @return the result of looking up the given getter in this class with respect to the given
    *         library
    */
   PropertyAccessorElement lookUpGetter(String getterName, LibraryElement library);
 
   /**
+   * Return the element representing the method that results from looking up the given method in the
+   * superclass of this class with respect to the given library, or `null` if the look up
+   * fails. The behavior of this method is defined by the Dart Language Specification in section
+   * 12.15.1: <blockquote> The result of looking up method <i>m</i> in class <i>C</i> with respect
+   * to library <i>L</i> is:
+   * * If <i>C</i> declares an instance method named <i>m</i> that is accessible to <i>L</i>, then
+   * that method is the result of the lookup. Otherwise, if <i>C</i> has a superclass <i>S</i>, then
+   * the result of the lookup is the result of looking up method <i>m</i> in <i>S</i> with respect
+   * to <i>L</i>. Otherwise, we say that the lookup has failed.
+   * </blockquote>
+   *
+   * @param methodName the name of the method being looked up
+   * @param library the library with respect to which the lookup is being performed
+   * @return the result of looking up the given method in the superclass of this class with respect
+   *         to the given library
+   */
+  MethodElement lookUpInheritedMethod(String methodName, LibraryElement library);
+
+  /**
    * Return the element representing the method that results from looking up the given method in
    * this class with respect to the given library, or `null` if the look up fails. The
    * behavior of this method is defined by the Dart Language Specification in section 12.15.1:
    * <blockquote> The result of looking up method <i>m</i> in class <i>C</i> with respect to library
    * <i>L</i> is:
    * * If <i>C</i> declares an instance method named <i>m</i> that is accessible to <i>L</i>, then
    * that method is the result of the lookup. Otherwise, if <i>C</i> has a superclass <i>S</i>, then
    * the result of the lookup is the result of looking up method <i>m</i> in <i>S</i> with respect
    * to <i>L</i>. Otherwise, we say that the lookup has failed.
    * </blockquote>
@@ skipping 333 matching lines @@
       InterfaceType supertype = currentElement.supertype;
       if (supertype == null) {
         return null;
       }
       currentElement = supertype.element;
     }
     return null;
   }
 
   @override
-  MethodElement lookUpMethod(String methodName, LibraryElement library) {
-    Set<ClassElement> visitedClasses = new Set<ClassElement>();
-    ClassElement currentElement = this;
-    while (currentElement != null && !visitedClasses.contains(currentElement)) {
-      visitedClasses.add(currentElement);
-      MethodElement element = currentElement.getMethod(methodName);
-      if (element != null && element.isAccessibleIn(library)) {
-        return element;
-      }
-      for (InterfaceType mixin in currentElement.mixins) {
-        ClassElement mixinElement = mixin.element;
-        if (mixinElement != null) {
-          element = mixinElement.getMethod(methodName);
-          if (element != null && element.isAccessibleIn(library)) {
-            return element;
-          }
-        }
-      }
-      InterfaceType supertype = currentElement.supertype;
-      if (supertype == null) {
-        return null;
-      }
-      currentElement = supertype.element;
-    }
-    return null;
-  }
+  MethodElement lookUpInheritedMethod(String methodName, LibraryElement library) => _internalLookUpMethod(methodName, library, false);
+
+  @override
+  MethodElement lookUpMethod(String methodName, LibraryElement library) => _internalLookUpMethod(methodName, library, true);
 
   @override
   PropertyAccessorElement lookUpSetter(String setterName, LibraryElement library) {
     Set<ClassElement> visitedClasses = new Set<ClassElement>();
     ClassElement currentElement = this;
     while (currentElement != null && !visitedClasses.contains(currentElement)) {
       visitedClasses.add(currentElement);
       PropertyAccessorElement element = currentElement.getSetter(setterName);
       if (element != null && element.isAccessibleIn(library)) {
         return element;
@@ skipping 166 matching lines @@
         for (InterfaceType type in currentElement.mixins) {
           ClassElement element = type.element;
           if (!visitedClasses.contains(element)) {
             supertypes.add(type);
           }
         }
       }
     }
   }
 
+  MethodElement _internalLookUpMethod(String methodName, LibraryElement library, bool includeThisClass) {
+    Set<ClassElement> visitedClasses = new Set<ClassElement>();
+    ClassElement currentElement = this;
+    if (includeThisClass) {
+      MethodElement element = currentElement.getMethod(methodName);
+      if (element != null && element.isAccessibleIn(library)) {
+        return element;
+      }
+    }
+    while (currentElement != null && visitedClasses.add(currentElement)) {
+      for (InterfaceType mixin in currentElement.mixins) {
+        ClassElement mixinElement = mixin.element;
+        if (mixinElement != null) {
+          MethodElement element = mixinElement.getMethod(methodName);
+          if (element != null && element.isAccessibleIn(library)) {
+            return element;
+          }
+        }
+      }
+      InterfaceType supertype = currentElement.supertype;
+      if (supertype == null) {
+        return null;
+      }
+      currentElement = supertype.element;
+      MethodElement element = currentElement.getMethod(methodName);
+      if (element != null && element.isAccessibleIn(library)) {
+        return element;
+      }
+    }
+    return null;
+  }
+
   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 && _safeIsOrInheritsProxy(classElt.supertype.element, visitedClassElts)) {
       return true;
     }
@@ skipping 6163 matching lines @@
    * @return the toolkit objects attached to this variable
    */
   List<ToolkitObjectElement> get toolkitObjects;
 }
 
 /**
  * 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 _potentiallyMutatedInScope = false;
-
-  /**
-   * Is `true` if this variable is potentially mutated somewhere in closure.
-   */
-  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;
 
@@ skipping 26 matching lines @@
 
   @override
   SourceRange get visibleRange {
     if (_visibleRangeLength < 0) {
       return null;
     }
     return new SourceRange(_visibleRangeOffset, _visibleRangeLength);
   }
 
   @override
-  bool get isPotentiallyMutatedInClosure => _potentiallyMutatedInClosure;
+  bool get isPotentiallyMutatedInClosure => hasModifier(Modifier.POTENTIALLY_MUTATED_IN_CONTEXT);
 
   @override
-  bool get isPotentiallyMutatedInScope => _potentiallyMutatedInScope;
+  bool get isPotentiallyMutatedInScope => hasModifier(Modifier.POTENTIALLY_MUTATED_IN_SCOPE);
 
   /**
    * Specifies that this variable is potentially mutated somewhere in closure.
    */
   void markPotentiallyMutatedInClosure() {
-    _potentiallyMutatedInClosure = true;
+    setModifier(Modifier.POTENTIALLY_MUTATED_IN_CONTEXT, true);
   }
 
   /**
    * Specifies that this variable is potentially mutated somewhere in its scope.
    */
   void markPotentiallyMutatedInScope() {
-    _potentiallyMutatedInScope = true;
+    setModifier(Modifier.POTENTIALLY_MUTATED_IN_SCOPE, 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((element) => element is CompilationUnitElementImpl);
     if (unit == null) {
@@ skipping 425 matching lines @@
   static const Modifier GETTER = const Modifier('GETTER', 5);
 
   /**
    * 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 MIXIN = const Modifier('MIXIN', 7);
 
-  static const Modifier REFERENCES_SUPER = const Modifier('REFERENCES_SUPER', 8);
+  /**
+   * 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);
+
+  /**
+   * 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 REFERENCES_SUPER = const Modifier('REFERENCES_SUPER', 10);
 
   /**
    * Indicates that the pseudo-modifier 'set' was applied to the element.
    */
-  static const Modifier SETTER = const Modifier('SETTER', 9);
+  static const Modifier SETTER = const Modifier('SETTER', 11);
 
   /**
    * Indicates that the modifier 'static' was applied to the element.
    */
-  static const Modifier STATIC = const Modifier('STATIC', 10);
+  static const Modifier STATIC = const Modifier('STATIC', 12);
 
   /**
    * 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', 11);
+  static const Modifier SYNTHETIC = const Modifier('SYNTHETIC', 13);
 
-  static const Modifier TYPEDEF = const Modifier('TYPEDEF', 12);
+  static const Modifier TYPEDEF = const Modifier('TYPEDEF', 14);
 
   static const List<Modifier> values = const [
       ABSTRACT,
       CONST,
       DEFERRED,
       FACTORY,
       FINAL,
       GETTER,
       HAS_EXT_URI,
       MIXIN,
+      POTENTIALLY_MUTATED_IN_CONTEXT,
+      POTENTIALLY_MUTATED_IN_SCOPE,
       REFERENCES_SUPER,
       SETTER,
       STATIC,
       SYNTHETIC,
       TYPEDEF];
 
   const Modifier(String name, int ordinal) : super(name, ordinal);
 }
 
 /**
@@ skipping 306 matching lines @@
    * @return `true` if this parameter is an initializing formal parameter
    */
   bool get isInitializingFormal;
 }
 
 /**
  * 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 _potentiallyMutatedInScope = false;
-
-  /**
-   * Is `true` if this variable is potentially mutated somewhere in closure.
-   */
-  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.
    */
   ParameterKind parameterKind;
 
@@ skipping 62 matching lines @@
     if (_visibleRangeLength < 0) {
       return null;
     }
     return new SourceRange(_visibleRangeOffset, _visibleRangeLength);
   }
 
   @override
   bool get isInitializingFormal => false;
 
   @override
-  bool get isPotentiallyMutatedInClosure => _potentiallyMutatedInClosure;
+  bool get isPotentiallyMutatedInClosure => hasModifier(Modifier.POTENTIALLY_MUTATED_IN_CONTEXT);
 
   @override
-  bool get isPotentiallyMutatedInScope => _potentiallyMutatedInScope;
+  bool get isPotentiallyMutatedInScope => hasModifier(Modifier.POTENTIALLY_MUTATED_IN_SCOPE);
 
   /**
    * Specifies that this variable is potentially mutated somewhere in closure.
    */
   void markPotentiallyMutatedInClosure() {
-    _potentiallyMutatedInClosure = true;
+    setModifier(Modifier.POTENTIALLY_MUTATED_IN_CONTEXT, true);
   }
 
   /**
    * Specifies that this variable is potentially mutated somewhere in its scope.
    */
   void markPotentiallyMutatedInScope() {
-    _potentiallyMutatedInScope = true;
+    setModifier(Modifier.POTENTIALLY_MUTATED_IN_SCOPE, 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 2118 matching lines @@
 
   @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);
 }