Add data structures to AST to indicate potentially mutated variables.

pkg/analyzer/lib/dart/ast/ast.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.
 
 /**
  * Defines the AST model. The AST (Abstract Syntax Tree) model describes the
  * syntactic (as opposed to semantic) structure of Dart code. The semantic
  * structure of the code is modeled by the
  * [element model](../element/element.dart).
  *
@@ skipping 518 matching lines @@
   /**
    * Return the first token included in this node's source range.
    */
   Token get beginToken;
 
   /**
    * Return an iterator that can be used to iterate through all the entities
    * (either AST nodes or tokens) that make up the contents of this node,
    * including doc comments but excluding other comments.
    */
-  Iterable/*<AstNode | Token>*/ get childEntities;
+  Iterable /*<AstNode | Token>*/ get childEntities;
 
   /**
    * Return the offset of the character immediately following the last character
    * of this node's source range. This is equivalent to
    * `node.getOffset() + node.getLength()`. For a compilation unit this will be
    * equal to the length of the unit's source. For synthetic nodes this will be
    * equivalent to the node's offset (because the length is zero (0) by
    * definition).
    */
   int get end;
@@ skipping 34 matching lines @@
    * Return the node at the root of this node's AST structure. Note that this
    * method's performance is linear with respect to the depth of the node in the
    * AST structure (O(depth)).
    */
   AstNode get root;
 
   /**
    * Use the given [visitor] to visit this node. Return the value returned by
    * the visitor as a result of visiting this node.
    */
-  dynamic /* =E */ accept/*<E>*/(AstVisitor/*<E>*/ visitor);
+  dynamic /* =E */ accept /*<E>*/ (AstVisitor /*<E>*/ visitor);
 
   /**
    * Return the most immediate ancestor of this node for which the [predicate]
    * returns `true`, or `null` if there is no such ancestor. Note that this node
    * will never be returned.
    */
   AstNode getAncestor(Predicate<AstNode> predicate);
 
   /**
    * Return the value of the property with the given [name], or `null` if this
@@ skipping 3164 matching lines @@
    */
   bool get isSynchronous;
 
   /**
    * Return the token representing the 'async' or 'sync' keyword, or `null` if
    * there is no such keyword.
    */
   Token get keyword;
 
   /**
+   * Return additional information about local variables and parameters that
+   * are declared within this function body or any enclosing function body.
+   * Returns `null` if resolution has not yet been performed.
+   */
+  LocalVariableInfo get localVariableInfo;

[Brian Wilkerson, 2016/02/16 21:13:39]

I'm wondering whether it might not be better to avoid adding another class to
the API and to simply have a pair of methods added to FunctionBody:

bool isPotentiallyMutatedInClosure(VariableElement element)
bool isPotentiallyMutatedInScope(VariableElement element)

That would leave open the possibility of not pre-computing the whole list of
mutated elements.

[Paul Berry, 2016/02/16 21:49:47]

Good idea.  Not only does this keep the API smaller, it also prevents clients
from accidentally modifying data structures they shouldn't touch.  PTAL.

+
+  /**
    * Return the star following the 'async' or 'sync' keyword, or `null` if there
    * is no star.
    */
   Token get star;
 }
 
 /**
  * A top-level declaration.
  *
  * > functionDeclaration ::=
@@ skipping 1419 matching lines @@
  * >   | [ListLiteral]
  * >   | [MapLiteral]
  * >   | [NullLiteral]
  * >   | [StringLiteral]
  *
  * Clients may not extend, implement or mix-in this class.
  */
 abstract class Literal extends Expression {}
 
 /**
+ * Additional information about local variables within a function or method
+ * produced at resolution time.
+ *
+ * Clients may not extend, implement or mix-in this class.
+ */
+abstract class LocalVariableInfo {
+  /**
+   * Return the set of local variables and parameters that are potentially
+   * mutated within a local function other than the function in which they are
+   * declared.
+   */
+  Set<VariableElement> get potentiallyMutatedInClosure;
+
+  /**
+   * Return the set of local variables and parameters that are potentially
+   * mutated within the scope of their declarations.
+   */
+  Set<VariableElement> get potentiallyMutatedInScope;
+}
+
+/**
  * A literal map.
  *
  * > mapLiteral ::=
  * >     'const'? ('<' [TypeName] (',' [TypeName])* '>')?
  * >     '{' ([MapLiteralEntry] (',' [MapLiteralEntry])* ','?)? '}'
  *
  * Clients may not extend, implement or mix-in this class.
  */
 abstract class MapLiteral extends TypedLiteral {
   /**
@@ skipping 2782 matching lines @@
   /**
    * Return the 'yield' keyword.
    */
   Token get yieldKeyword;
 
   /**
    * Return the 'yield' keyword to the given [token].
    */
   void set yieldKeyword(Token token);
 }