Make two getters public

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 10253 matching lines @@
   bool get isConst;
 
   /**
    * Return `true` if this variable was declared with the 'final' modifier.
    * Variables that are declared with the 'const' modifier will return `false`
    * even though they are implicitly final.
    */
   bool get isFinal;
 
   /**
+   * 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.
+   */
+  bool get isPotentiallyMutatedInClosure;
+
+  /**
+   * Return `true` if this variable is potentially mutated somewhere in its
+   * scope. This information is only available for local variables (including
+   * parameters) and only after the compilation unit containing the variable has
+   * been resolved.
+   */
+  bool get isPotentiallyMutatedInScope;
+
+  /**
    * Return the resolved [VariableDeclaration] node that declares this
    * [VariableElement].
    *
    * This method is expensive, because resolved AST might be evicted from cache,
    * so parsing and resolving will be performed.
    */
   @override
   VariableDeclaration get node;
 
   /**
@@ skipping 80 matching lines @@
     }
     this._initializer = function;
   }
 
   @override
   bool get isConst => hasModifier(Modifier.CONST);
 
   @override
   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.
-   */
+  @override
   bool get isPotentiallyMutatedInClosure => false;
 
-  /**
-   * Return `true` if this variable is potentially mutated somewhere in its
-   * scope. This information is only available for local variables (including
-   * parameters) and only after the compilation unit containing the variable has
-   * been resolved.
-   */
+  @override
   bool get isPotentiallyMutatedInScope => false;
 
   @override
   VariableDeclaration get node =>
       getNodeMatching((node) => node is VariableDeclaration);
 
   @override
   void appendTo(StringBuffer buffer) {
     buffer.write(type);
     buffer.write(" ");
@@ skipping 32 matching lines @@
     //    return getBaseElement().getInitializer();
   }
 
   @override
   bool get isConst => baseElement.isConst;
 
   @override
   bool get isFinal => baseElement.isFinal;
 
   @override
+  bool get isPotentiallyMutatedInClosure =>
+      baseElement.isPotentiallyMutatedInClosure;
+
+  @override
+  bool get isPotentiallyMutatedInScope =>
+      baseElement.isPotentiallyMutatedInScope;
+
+  @override
   VariableDeclaration get node => baseElement.node;
 
   @override
   DartType get type => substituteFor(baseElement.type);
 
   @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);
@@ skipping 60 matching lines @@
     // 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) || type.isDynamic;
   }
 
   @override
   VoidTypeImpl substitute2(
       List<DartType> argumentTypes, List<DartType> parameterTypes) => this;
 }