Make the mutable variables local to an IR builder instead of global.

pkg/compiler/lib/src/cps_ir/cps_ir_builder.dart

 // Copyright (c) 2013, 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 dart2js.ir_builder;
 
 import '../constants/expressions.dart';
 import '../constants/values.dart' show PrimitiveConstantValue;
 import '../dart_types.dart';
 import '../dart2jslib.dart';
@@ skipping 357 matching lines @@
   // TODO(johnniwinther): Type [nodes] as `Iterable<N>` when `NodeList` uses
   // `List` instead of `Link`.
   SubbuildFunction subbuildSequence(/*Iterable<N>*/ nodes) {
     return (IrBuilder builder) {
       return withBuilder(builder, () => builder.buildSequence(nodes, build));
     };
   }
 }
 
 /// Shared state between delimited IrBuilders within the same function.
-class IrBuilderDelimitedState {
+class IrBuilderSharedState {
   final ConstantSystem constantSystem;
 
   /// A stack of collectors for breaks.
   final List<JumpCollector> breakCollectors = <JumpCollector>[];
 
   /// A stack of collectors for continues.
   final List<JumpCollector> continueCollectors = <JumpCollector>[];
 
   final List<ConstDeclaration> localConstants = <ConstDeclaration>[];
 
   final ExecutableElement currentElement;
 
   final ir.Continuation returnContinuation = new ir.Continuation.retrn();
   ir.Parameter _thisParameter;
   ir.Parameter enclosingMethodThisParameter;
 
   final List<ir.Definition> functionParameters = <ir.Definition>[];
 
-  IrBuilderDelimitedState(this.constantSystem, this.currentElement);
+  IrBuilderSharedState(this.constantSystem, this.currentElement);
 
   ir.Parameter get thisParameter => _thisParameter;
   void set thisParameter(ir.Parameter value) {
     assert(_thisParameter == null);
     _thisParameter = value;
   }
 }
 
 class ThisParameterLocal implements Local {
   final ExecutableElement executableContext;
   ThisParameterLocal(this.executableContext);
   String get name => 'this';
   toString() => 'ThisParameterLocal($executableContext)';
 }
 
 /// A factory for building the cps IR.
 ///
 /// [DartIrBuilder] and [JsIrBuilder] implement nested functions and captured
 /// variables in different ways.
 abstract class IrBuilder {
   IrBuilder _makeInstance();
 
-  /// True if [local] should currently be accessed from a [ir.MutableVariable].
-  bool isInMutableVariable(Local local);
-
-  /// Creates a [ir.MutableVariable] for the given local.
-  void makeMutableVariable(Local local);
-
-  /// Remove an [ir.MutableVariable] for a local.
-  ///
-  /// Subsequent access to the local will be direct rather than through the
-  /// mutable variable.  This is used for variables that do not spend their
-  /// entire lifetime as mutable variables (e.g., variables that are boxed
-  /// in mutable variables for a try block).
-  void removeMutableVariable(Local local);
-
   void declareLocalVariable(LocalVariableElement element,
                             {ir.Primitive initialValue});
 
   /// Called when entering a nested function with free variables.
   ///
   /// The free variables must subsequently be accessible using [buildLocalGet]
   /// and [buildLocalSet].
   void _enterClosureEnvironment(ClosureEnvironment env);
 
   /// Called when entering a function body or loop body.
@@ skipping 30 matching lines @@
   ///
   /// If inside a closure class, [buildThis] will redirect access through
   /// closure fields in order to access the receiver from the enclosing method.
   ir.Primitive buildThis();
 
   // TODO(johnniwinther): Make these field final and remove the default values
   // when [IrBuilder] is a property of [IrBuilderVisitor] instead of a mixin.
 
   final List<ir.Parameter> _parameters = <ir.Parameter>[];
 
-  IrBuilderDelimitedState state;
+  IrBuilderSharedState state;
 
   /// A map from variable indexes to their values.
   ///
   /// [BoxLocal]s map to their box. [LocalElement]s that are boxed are not
   /// in the map; look up their [BoxLocal] instead.
   Environment environment;
 
+  /// A map from mutable local variables to their [ir.MutableVariable]s.
+  ///
+  /// Mutable variables are treated as boxed.  Writes to them are observable
+  /// side effects.
+  Map<Local, ir.MutableVariable> mutableVariables;
+
+  /// True if [local] should currently be accessed from a [ir.MutableVariable].
+  bool isInMutableVariable(Local local) {
+    return mutableVariables.containsKey(local);
+  }
+
+  /// Creates a [ir.MutableVariable] for the given local.
+  void makeMutableVariable(Local local) {
+    mutableVariables[local] =
+        new ir.MutableVariable(local.executableContext, local);
+  }
+
+  /// Remove an [ir.MutableVariable] for a local.
+  ///
+  /// Subsequent access to the local will be direct rather than through the
+  /// mutable variable.
+  void removeMutableVariable(Local local) {
+    mutableVariables.remove(local);
+  }
+
+  /// Gets the [MutableVariable] containing the value of [local].
+  ir.MutableVariable getMutableVariable(Local local) {
+    return mutableVariables[local];
+  }
+
   // The IR builder maintains a context, which is an expression with a hole in
   // it.  The hole represents the focus where new expressions can be added.
   // The context is implemented by 'root' which is the root of the expression
   // and 'current' which is the expression that immediately contains the hole.
   // Not all expressions have a hole (e.g., invocations, which always occur in
   // tail position, do not have a hole).  Expressions with a hole have a plug
   // method.
   //
   // Conceptually, visiting a statement takes a context as input and returns
   // either a new context or else an expression without a hole if all
   // control-flow paths through the statement have exited.  An expression
   // without a hole is represented by a (root, current) pair where root is the
   // expression and current is null.
   //
   // Conceptually again, visiting an expression takes a context as input and
   // returns either a pair of a new context and a definition denoting
   // the expression's value, or else an expression without a hole if all
   // control-flow paths through the expression have exited.
   //
   // We do not pass contexts as arguments or return them.  Rather we use the
   // current context (root, current) as the visitor state and mutate current.
   // Visiting a statement returns null; visiting an expression returns the
   // primitive denoting its value.
 
   ir.Expression _root = null;
   ir.Expression _current = null;
 
   /// Initialize a new top-level IR builder.
   void _init(ConstantSystem constantSystem, ExecutableElement currentElement) {
-    state = new IrBuilderDelimitedState(constantSystem, currentElement);
+    state = new IrBuilderSharedState(constantSystem, currentElement);
     environment = new Environment.empty();
+    mutableVariables = <Local, ir.MutableVariable>{};
   }
 
   /// Construct a delimited visitor for visiting a subtree.
   ///
   /// Build a subterm that is not (yet) connected to the CPS term.  The
   /// delimited visitor has its own has its own context for building an IR
   /// expression, so the built expression is not plugged into the parent's
   /// context.  It has its own compile-time environment mapping local
   /// variables to their values.  If an optional environment argument is
   /// supplied, it is used as the builder's initial environment.  Otherwise
   /// the environment is initially a copy of the parent builder's environment.
   IrBuilder makeDelimitedBuilder([Environment env = null]) {
     return _makeInstance()
         ..state = state
-        ..environment = env != null ? env : new Environment.from(environment);
+        ..environment = env != null ? env : new Environment.from(environment)
+        ..mutableVariables = mutableVariables;
   }
 
   /// Construct a builder for making constructor field initializers.
   IrBuilder makeInitializerBuilder() {
     return _makeInstance()
-        ..state = new IrBuilderDelimitedState(state.constantSystem,
-                                              state.currentElement)
-        ..environment = new Environment.from(environment);
+        ..state = new IrBuilderSharedState(state.constantSystem,
+                                           state.currentElement)
+        ..environment = new Environment.from(environment)
+        ..mutableVariables = mutableVariables;
   }
 
   /// Construct a builder for an inner function.
   IrBuilder makeInnerFunctionBuilder(ExecutableElement currentElement) {
-    IrBuilderDelimitedState innerState =
-        new IrBuilderDelimitedState(state.constantSystem, currentElement)
+    IrBuilderSharedState innerState =
+        new IrBuilderSharedState(state.constantSystem, currentElement)
           ..enclosingMethodThisParameter = state.enclosingMethodThisParameter;
     return _makeInstance()
         ..state = innerState
-        ..environment = new Environment.empty();
+        ..environment = new Environment.empty()
+        ..mutableVariables = <Local, ir.MutableVariable>{};
   }
 
   bool get isOpen => _root == null || _current != null;
 
 
   void buildFieldInitializerHeader({ClosureScope closureScope}) {
     _enterScope(closureScope);
   }
 
   List<ir.Primitive> buildFunctionHeader(Iterable<Local> parameters,
@@ skipping 1141 matching lines @@
     // of mutable bindings for the variables assigned in the try.  The join-
     // point continuation is not in the scope of these mutable bindings.
     // The tryBlock is in the scope of a binding for the catch handler.  Each
     // instruction (specifically, each call) in the tryBlock is in the dynamic
     // scope of the handler.  The mutable bindings are dereferenced at the end
     // of the try block and at the beginning of the catch block, so the
     // variables are unboxed in the catch block and at the join point.
     JumpCollector join = new ForwardJumpCollector(environment);
     IrBuilder tryCatchBuilder = makeDelimitedBuilder();
 
-    // Variables that are boxed due to being captured in a closure are boxed
-    // for their entire lifetime, and so they do not need to be boxed on
-    // entry to any try block.  They are not filtered out before this because
-    // we can not identify all of them in the same pass where we identify the
-    // variables assigned in the try (they may be captured by a closure after
-    // the try statement).
+    // Variables treated as mutable in a try are not mutable outside of it.
+    // Work with a copy of the outer builder's mutable variables.
+    tryCatchBuilder.mutableVariables =
+        new Map<Local, ir.MutableVariable>.from(mutableVariables);
     for (LocalVariableElement variable in tryStatementInfo.boxedOnEntry) {
       assert(!tryCatchBuilder.isInMutableVariable(variable));
       ir.Primitive value = tryCatchBuilder.buildLocalVariableGet(variable);
       tryCatchBuilder.makeMutableVariable(variable);
       tryCatchBuilder.declareLocalVariable(variable, initialValue: value);
     }
 
     IrBuilder tryBuilder = tryCatchBuilder.makeDelimitedBuilder();
 
     void interceptJumps(JumpCollector collector) {
@@ skipping 10 matching lines @@
       tryBuilder.jumpTo(join);
       restoreJumps(join);
     }
     tryBuilder.state.breakCollectors.forEach(restoreJumps);
     tryBuilder.state.continueCollectors.forEach(restoreJumps);
 
     IrBuilder catchBuilder = tryCatchBuilder.makeDelimitedBuilder();
     for (LocalVariableElement variable in tryStatementInfo.boxedOnEntry) {
       assert(catchBuilder.isInMutableVariable(variable));
       ir.Primitive value = catchBuilder.buildLocalVariableGet(variable);
-      // Note that we remove the variable from the set of mutable variables
-      // here (and not above for the try body).  This is because the set of
-      // mutable variables is global for the whole function and not local to
-      // a delimited builder.
+      // After this point, the variables that were boxed on entry to the try
+      // are no longer treated as mutable.
       catchBuilder.removeMutableVariable(variable);
       catchBuilder.environment.update(variable, value);
     }
 
     // TODO(kmillikin): Handle multiple catch clauses.
     assert(catchClauseInfos.length == 1);
     for (CatchClauseInfo catchClauseInfo in catchClauseInfos) {
       LocalVariableElement exceptionVariable =
           catchClauseInfo.exceptionVariable;
       ir.Parameter exceptionParameter = new ir.Parameter(exceptionVariable);
@@ skipping 266 matching lines @@
     environment = join.environment;
     environment.discard(1);
     // There is always a join parameter for the result value, because it
     // is different on at least two paths.
     return join.continuation.parameters.last;
   }
 }
 
 /// Shared state between DartIrBuilders within the same method.
 class DartIrBuilderSharedState {
-  /// Maps local variables to their corresponding [MutableVariable] object.
-  final Map<Local, ir.MutableVariable> local2mutable =
-      <Local, ir.MutableVariable>{};
-
-  /// Creates a [MutableVariable] for the given local.
-  void makeMutableVariable(Local local) {
-    ir.MutableVariable variable =
-        new ir.MutableVariable(local.executableContext, local);
-    local2mutable[local] = variable;
-  }
-
   /// [MutableVariable]s that should temporarily be treated as registers.
   final Set<Local> registerizedMutableVariables = new Set<Local>();
-
-  DartIrBuilderSharedState(Set<Local> capturedVariables) {
-    capturedVariables.forEach(makeMutableVariable);
-  }
 }
 
 /// Dart-specific subclass of [IrBuilder].
 ///
 /// Inner functions are represented by a [FunctionDefinition] with the
 /// IR for the inner function nested inside.
 ///
 /// Captured variables are translated to ref cells (see [MutableVariable])
 /// using [GetMutableVariable] and [SetMutableVariable].
 class DartIrBuilder extends IrBuilder {
-  final DartIrBuilderSharedState dartState;
+  final DartIrBuilderSharedState dartState = new DartIrBuilderSharedState();
 
   IrBuilder _makeInstance() => new DartIrBuilder._blank(dartState);
   DartIrBuilder._blank(this.dartState);
 
   DartIrBuilder(ConstantSystem constantSystem,
                 ExecutableElement currentElement,
-                Set<Local> capturedVariables)
-      : dartState = new DartIrBuilderSharedState(capturedVariables) {
+                Set<Local> capturedVariables) {
     _init(constantSystem, currentElement);
+    capturedVariables.forEach(makeMutableVariable);
   }
 
+  @override
   bool isInMutableVariable(Local local) {
-    return dartState.local2mutable.containsKey(local) &&
+    return mutableVariables.containsKey(local) &&
            !dartState.registerizedMutableVariables.contains(local);
   }
 
-  void makeMutableVariable(Local local) {
-    dartState.makeMutableVariable(local);
-  }
-
-  void removeMutableVariable(Local local) {
-    dartState.local2mutable.remove(local);
-  }
-
-  /// Gets the [MutableVariable] containing the value of [local].
-  ir.MutableVariable getMutableVariable(Local local) {
-    return dartState.local2mutable[local];
-  }
-
   void _enterScope(ClosureScope scope) {
     assert(scope == null);
   }
 
   void _enterClosureEnvironment(ClosureEnvironment env) {
     assert(env == null);
   }
 
   void _enterForLoopInitializer(ClosureScope scope,
                                 List<LocalElement> loopVariables) {
@@ skipping 27 matching lines @@
     // Move captured loop variables back into the local environment.
     // The update expression will use the values we put in the environment,
     // and then the environments for the initializer and update will be
     // joined at the head of the body.
     for (LocalElement loopVariable in loopVariables) {
       if (isInMutableVariable(loopVariable)) {
         ir.MutableVariable mutableVariable = getMutableVariable(loopVariable);
         ir.Primitive value =
             addPrimitive(new ir.GetMutableVariable(mutableVariable));
         environment.update(loopVariable, value);
         dartState.registerizedMutableVariables.add(loopVariable);

[asgerf, 2015/04/20 08:46:10]

We should be able to get rid of registerizedMutableVariables now. I never liked
it anyway. But it's low priority so I'm fine with doing that later.

       }
     }
   }
 
   void _createFunctionParameter(Local parameterElement) {
     ir.Parameter parameter = new ir.Parameter(parameterElement);
     _parameters.add(parameter);
     if (isInMutableVariable(parameterElement)) {
       state.functionParameters.add(getMutableVariable(parameterElement));
     } else {
@@ skipping 126 matching lines @@
 
   IrBuilder _makeInstance() => new JsIrBuilder._blank(program, jsState);
   JsIrBuilder._blank(this.program, this.jsState);
 
   JsIrBuilder(this.program, ConstantSystem constantSystem,
       ExecutableElement currentElement)
       : jsState = new JsIrBuilderSharedState() {
     _init(constantSystem, currentElement);
   }
 
-  Map<ast.TryStatement, TryStatementInfo> get tryStatements => null;
-  Set<Local> get mutableCapturedVariables => null;
-  bool isInMutableVariable(Local local) => false;
-  void makeMutableVariable(Local local) {}
-  void removeMutableVariable(Local local) {}
-
   void enterInitializers() {
     assert(jsState.inInitializers == false);
     jsState.inInitializers = true;
   }
 
   void leaveInitializers() {
     assert(jsState.inInitializers == true);
     jsState.inInitializers = false;
   }
 
@@ skipping 73 matching lines @@
                             {ir.Primitive initialValue}) {
     assert(isOpen);
     if (initialValue == null) {
       initialValue = buildNullLiteral();
     }
     ClosureLocation location = jsState.boxedVariables[variableElement];
     if (location != null) {
       add(new ir.SetField(environment.lookup(location.box),
                           location.field,
                           initialValue));
+    } else if (isInMutableVariable(variableElement)) {
+      add(new ir.LetMutable(getMutableVariable(variableElement),
+                            initialValue));
     } else {
       initialValue.useElementAsHint(variableElement);
       environment.extend(variableElement, initialValue);
     }
   }
 
   /// Add [functionElement] to the environment with provided [definition].
   void declareLocalFunction(LocalFunctionElement functionElement,
                             ClosureClassElement classElement) {
     ir.Primitive closure = buildFunctionExpression(classElement);
@@ skipping 256 matching lines @@
 }
 
 /// Synthetic parameter to a JavaScript factory method that takes the type
 /// argument given for the type variable [variable].
 class TypeInformationParameter implements Local {
   final TypeVariableElement variable;
   final ExecutableElement executableContext;
   TypeInformationParameter(this.variable, this.executableContext);
   String get name => variable.name;
 }