Add data structures to AST to indicate potentially mutated variables.

pkg/analyzer/lib/src/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.
 
 library analyzer.src.dart.ast.ast;
 
 import 'dart:collection';
 
 import 'package:analyzer/dart/ast/ast.dart';
 import 'package:analyzer/dart/ast/token.dart';
@@ skipping 4704 matching lines @@
 /**
  * A node representing the body of a function or method.
  *
  * > functionBody ::=
  * >     [BlockFunctionBody]
  * >   | [EmptyFunctionBody]
  * >   | [ExpressionFunctionBody]
  */
 abstract class FunctionBodyImpl extends AstNodeImpl implements FunctionBody {
   /**
+   * Additional information about local variables and parameters that are
+   * declared within this function body or any enclosing function body.  `null`
+   * if resolution has not yet been performed.
+   */
+  LocalVariableInfo localVariableInfo;
+
+  /**
    * Return `true` if this function body is asynchronous.
    */
   bool get isAsynchronous => false;
 
   /**
    * Return `true` if this function body is a generator.
    */
   bool get isGenerator => false;
 
   /**
    * Return `true` if this function body is synchronous.
    */
   bool get isSynchronous => true;
 
   /**
    * Return the token representing the 'async' or 'sync' keyword, or `null` if
    * there is no such keyword.
    */
   Token get keyword => null;
 
   /**
    * Return the star following the 'async' or 'sync' keyword, or `null` if there
    * is no star.
    */
   Token get star => null;
+
+  @override
+  bool isPotentiallyMutatedInClosure(VariableElement variable) {
+    if (localVariableInfo == null) {
+      throw new StateError('Resolution has not yet been performed');
+    }
+    return localVariableInfo.potentiallyMutatedInClosure.contains(variable);
+  }
+
+  @override
+  bool isPotentiallyMutatedInScope(VariableElement variable) {
+    if (localVariableInfo == null) {
+      throw new StateError('Resolution has not yet been performed');
+    }
+    return localVariableInfo.potentiallyMutatedInScope.contains(variable);
+  }
 }
 
 /**
  * A top-level declaration.
  *
  * > functionDeclaration ::=
  * >     'external' functionSignature
  * >   | functionSignature [FunctionBody]
  * >
  * > functionSignature ::=
@@ skipping 1790 matching lines @@
  * >   | [MapLiteral]
  * >   | [NullLiteral]
  * >   | [StringLiteral]
  */
 abstract class LiteralImpl extends ExpressionImpl implements Literal {
   @override
   int get precedence => 16;
 }
 
 /**
+ * Additional information about local variables within a function or method
+ * produced at resolution time.
+ */
+class LocalVariableInfo {
+  /**
+   * The set of local variables and parameters that are potentially mutated
+   * within a local function other than the function in which they are declared.
+   */
+  final Set<VariableElement> potentiallyMutatedInClosure =
+      new Set<VariableElement>();
+
+  /**
+   * The set of local variables and parameters that are potentiall mutated
+   * within the scope of their declarations.
+   */
+  final Set<VariableElement> potentiallyMutatedInScope =
+      new Set<VariableElement>();
+}
+
+/**
  * A single key/value pair in a map literal.
  *
  * > mapLiteralEntry ::=
  * >     [Expression] ':' [Expression]
  */
 class MapLiteralEntryImpl extends AstNodeImpl implements MapLiteralEntry {
   /**
    * The expression computing the key with which the value will be associated.
    */
   Expression _key;
@@ skipping 4235 matching lines @@
   }
 
   @override
   accept(AstVisitor visitor) => visitor.visitYieldStatement(this);
 
   @override
   void visitChildren(AstVisitor visitor) {
     _safelyVisitChild(_expression, visitor);
   }
 }