Refactored treatment of closure variables in dart2js CPS.

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_backend/dart_backend.dart' show DartBackend;
 import '../dart_types.dart';
@@ skipping 159 matching lines @@
   /// [nodes] in its context using [build].
   // 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 nested builders.
+/// Shared state between IrBuilders of nested functions.
+class IrBuilderClosureState {
+  final Iterable<Entity> closureLocals;
+
+  final Map<Local, ir.ClosureVariable> local2closure =

[Johnni Winther, 2014/12/08 13:15:13]

Document the members.

[asgerf, 2014/12/08 13:44:00]

Done.

+      <Local, ir.ClosureVariable>{};
+
+  final Map<ExecutableElement, List<ir.ClosureVariable>> function2closures =
+      <ExecutableElement, List<ir.ClosureVariable>>{};
+
+  List<ir.ClosureVariable> getClosureList(ExecutableElement element) {
+    return function2closures.putIfAbsent(element, () => <ir.ClosureVariable>[]);
+  }
+
+  IrBuilderClosureState(this.closureLocals) {
+    for (Local local in closureLocals) {
+      ExecutableElement context = local.executableContext;
+      ir.ClosureVariable variable = new ir.ClosureVariable(context, local);
+      local2closure[local] = variable;
+      getClosureList(context).add(variable);
+    }
+  }
+}
+
+/// Shared state between delimited IrBuilders within the same function.
 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 Iterable<Entity> closureLocals;
-
   final ExecutableElement currentElement;
 
   final ir.Continuation returnContinuation = new ir.Continuation.retrn();
 
-  IrBuilderSharedState(this.constantSystem,
-                       this.currentElement,
-                       this.closureLocals);
+  final List<ir.Definition> functionParameters = <ir.Definition>[];
+
+  IrBuilderSharedState(this.constantSystem, this.currentElement);
 }
 
 /// A factory for building the cps IR.
 class IrBuilder {
   // 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>[];
 
   final IrBuilderSharedState state;
 
+  final IrBuilderClosureState closure;
+
   /// A map from variable indexes to their values.
   Environment environment;
 
   // 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.
@@ skipping 13 matching lines @@
   // 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;
 
   IrBuilder(ConstantSystem constantSystem,
             ExecutableElement currentElement,
             Iterable<Entity> closureLocals)
-      : this.state = new IrBuilderSharedState(
-            constantSystem, currentElement, closureLocals),
+      : this.state = new IrBuilderSharedState(constantSystem, currentElement),
+        this.closure = new IrBuilderClosureState(closureLocals),
         this.environment = new Environment.empty();
 
   /// Construct a delimited visitor for visiting a subtree.
   ///
   /// The delimited visitor has its own compile-time environment mapping
   /// local variables to their values, which is initially a copy of the parent
   /// environment.  It has its own context for building an IR expression, so
   /// the built expression is not plugged into the parent's context.
   IrBuilder.delimited(IrBuilder parent)
       : this.state = parent.state,
+        this.closure = parent.closure,
         this.environment = new Environment.from(parent.environment);
 
   /// Construct a visitor for a recursive continuation.
   ///
   /// The recursive continuation builder has fresh parameters (i.e. SSA phis)
   /// for all the local variables in the parent, because the invocation sites
   /// of the continuation are not all known when the builder is created.  The
   /// recursive invocations will be passed values for all the local variables,
   /// which may be eliminated later if they are redundant---if they take on
   /// the same value at all invocation sites.
   IrBuilder.recursive(IrBuilder parent)
       : this.state = parent.state,
+        this.closure = parent.closure,
         this.environment = new Environment.empty() {
-    parent.environment.index2variable.forEach(createParameter);
+    parent.environment.index2variable.forEach(createLocalParameter);
   }
 
+  /// Construct a builder for an inner function.
+  IrBuilder.innerFunction(IrBuilder parent,
+                          ExecutableElement currentElement)
+      : this.state = new IrBuilderSharedState(parent.state.constantSystem,
+                                              currentElement),
+        this.closure = parent.closure,
+        this.environment = new Environment.empty();
+
 
   bool get isOpen => _root == null || _current != null;
 
   /// True if [element] is a local variable, local function, or parameter that
   /// is accessed from an inner function. Recursive self-references in a local
   /// function count as closure accesses.
   ///
   /// If `true`, [element] is a [LocalElement].
   bool isClosureVariable(Element element) {
-    return state.closureLocals.contains(element);
+    return closure.closureLocals.contains(element);
+  }
+
+  ir.ClosureVariable getClosureVariable(LocalElement element) {

[Johnni Winther, 2014/12/08 13:15:13]

Document this.

[asgerf, 2014/12/08 13:44:00]

Done.

+    return closure.local2closure[element];
+  }
+
+  void createFunctionParameter(ParameterElement parameterElement) {

[Johnni Winther, 2014/12/08 13:15:13]

Ditto.

[asgerf, 2014/12/08 13:44:00]

Done.

+    if (isClosureVariable(parameterElement)) {
+      state.functionParameters.add(getClosureVariable(parameterElement));
+    } else {
+      state.functionParameters.add(createLocalParameter(parameterElement));
+    }
   }
 
   /// Create a parameter for [parameterElement] and add it to the current
   /// environment.
-  ///
-  /// [isClosureVariable] marks whether [parameterElement] is accessed from an
-  /// inner function.
-  void createParameter(LocalElement parameterElement) {
+  ir.Parameter createLocalParameter(LocalElement parameterElement) {
     ir.Parameter parameter = new ir.Parameter(parameterElement);
     _parameters.add(parameter);
-    if (isClosureVariable(parameterElement)) {
-      add(new ir.SetClosureVariable(parameterElement, parameter));
-    } else {
-      environment.extend(parameterElement, parameter);
-    }
+    environment.extend(parameterElement, parameter);
+    return parameter;
   }
 
   /// Add the constant [variableElement] to the environment with [value] as its
   /// constant value.
   void declareLocalConstant(LocalVariableElement variableElement,
                             ConstantExpression value) {
     state.localConstants.add(new ConstDeclaration(variableElement, value));
   }
 
   /// Add [variableElement] to the environment with [initialValue] as its
   /// initial value.
   void declareLocalVariable(LocalVariableElement variableElement,
                             {ir.Primitive initialValue}) {
     assert(isOpen);
     if (initialValue == null) {
       // TODO(kmillikin): Consider pooling constants.
       // The initial value is null.
       initialValue = buildNullLiteral();
     }
     if (isClosureVariable(variableElement)) {
-      add(new ir.SetClosureVariable(variableElement,
+      add(new ir.SetClosureVariable(getClosureVariable(variableElement),
                                     initialValue,
                                     isDeclaration: true));
     } else {
       // In case a primitive was introduced for the initializer expression,
       // use this variable element to help derive a good name for it.
       initialValue.useElementAsHint(variableElement);
       environment.extend(variableElement, initialValue);
     }
   }
 
   /// Add [functionElement] to the environment with provided [definition].
   void declareLocalFunction(LocalFunctionElement functionElement,
                             ir.FunctionDefinition definition) {
     assert(isOpen);
     if (isClosureVariable(functionElement)) {
-      add(new ir.DeclareFunction(functionElement, definition));
+      ir.ClosureVariable variable = getClosureVariable(functionElement);
+      add(new ir.DeclareFunction(variable, definition));
     } else {
       ir.CreateFunction prim = new ir.CreateFunction(definition);
       add(new ir.LetPrim(prim));
       environment.extend(functionElement, prim);
       prim.useElementAsHint(functionElement);
     }
   }
 
   // Plug an expression into the 'hole' in the context being accumulated.  The
   // empty context (just a hole) is represented by root (and current) being
@@ skipping 197 matching lines @@
       buildReturn(initializer);
       return new ir.FieldDefinition(state.currentElement,
                                     state.returnContinuation,
                                     _root);
     }
   }
 
   /// Create a [ir.FunctionDefinition] for [element] using [_root] as the body.
   ///
   /// Parameters must be created before the construction of the body using
-  /// [createParameter].
+  /// [createFunctionParameter].
   ir.FunctionDefinition makeFunctionDefinition(
       List<ConstantExpression> defaults) {
     FunctionElement element = state.currentElement;
     if (element.isAbstract || element.isExternal) {
       assert(invariant(element, _root == null,
           message: "Non-empty body for abstract method $element: $_root"));
       assert(invariant(element, state.localConstants.isEmpty,
           message: "Local constants for abstract method $element: "
                    "${state.localConstants}"));
       return new ir.FunctionDefinition.abstract(
-                element, _parameters, defaults);
+                element, state.functionParameters, defaults);
     } else {
       _ensureReturn();
       return new ir.FunctionDefinition(
-          element, state.returnContinuation, _parameters, _root,
-          state.localConstants, defaults);
+          element, state.returnContinuation, state.functionParameters, _root,
+          state.localConstants, defaults, closure.getClosureList(element));
     }
   }
 
   /// Create a super invocation where the method name and the argument structure
   /// are defined by [selector] and the argument values are defined by
   /// [arguments].
   ir.Primitive buildSuperInvocation(Selector selector,
                                     List<ir.Primitive> arguments) {
     return _buildInvokeSuper(selector, arguments);
   }
@@ skipping 98 matching lines @@
   ir.Primitive buildStringConcatenation(List<ir.Primitive> arguments) {
     assert(isOpen);
     return _continueWithExpression(
         (k) => new ir.ConcatenateStrings(k, arguments));
   }
 
   /// Create a read access of [local].
   ir.Primitive buildLocalGet(LocalElement local) {
     assert(isOpen);
     if (isClosureVariable(local)) {
-      ir.Primitive result = new ir.GetClosureVariable(local);
+      ir.Primitive result =
+          new ir.GetClosureVariable(getClosureVariable(local));
       add(new ir.LetPrim(result));
       return result;
     } else {
       return environment.lookup(local);
     }
   }
 
   /// Create a write access to [local] with the provided [value].
   ir.Primitive buildLocalSet(LocalElement local, ir.Primitive value) {
     assert(isOpen);
     if (isClosureVariable(local)) {
-      add(new ir.SetClosureVariable(local, value));
+      add(new ir.SetClosureVariable(getClosureVariable(local), value));
     } else {
       value.useElementAsHint(local);
       environment.update(local, value);
     }
     return value;
   }
 
   /// Create an invocation of [local] where the argument structure is defined
   /// by [selector] and the argument values are defined by [arguments].
   ir.Primitive buildLocalInvocation(LocalElement local,
                                     Selector selector,
                                     List<ir.Definition> arguments) {
     ir.Primitive receiver;
     if (isClosureVariable(local)) {
-      receiver = new ir.GetClosureVariable(local);
+      receiver = new ir.GetClosureVariable(getClosureVariable(local));
       add(new ir.LetPrim(receiver));
     } else {
       receiver = environment.lookup(local);
     }
     return _buildInvokeCall(receiver, selector, arguments);
   }
 
   /// Create an invocation of the [functionExpression] where the argument
   /// structure are defined by [selector] and the argument values are defined by
   /// [arguments].
@@ skipping 742 matching lines @@
     index = 0;
     for (int i = 0; i < environment.length; ++i) {
       if (common[i] == null) {
         environment.index2value[i] = parameters[index++];
       }
     }
 
     return join;
   }
 }