Refactored treatment of closure variables in dart2js CPS.

pkg/compiler/lib/src/cps_ir/cps_ir_nodes.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.
 
 // IrNodes are kept in a separate library to have precise control over their
 // dependencies on other parts of the system.
 library dart2js.ir_nodes;
 
 import '../constants/expressions.dart';
 import '../constants/values.dart' as values show ConstantValue;
@@ skipping 292 matching lines @@
   final Reference<Continuation> continuation;
   final List<Reference<Primitive>> arguments;
 
   ConcatenateStrings(Continuation cont, List<Primitive> args)
       : continuation = new Reference<Continuation>(cont),
         arguments = _referenceList(args);
 
   accept(Visitor visitor) => visitor.visitConcatenateStrings(this);
 }
 
-/// Gets the value from a closure variable. The identity of the variable is
-/// determined by a [Local].
+/// Gets the value from a closure variable.
 ///
 /// Closure variables can be seen as ref cells that are not first-class values.
 /// A [LetPrim] with a [GetClosureVariable] can then be seen as:
 ///
 ///   let prim p = ![variable] in [body]
 ///
 class GetClosureVariable extends Primitive {
-  final Local variable;
+  final Reference<ClosureVariable> variable;
 
-  GetClosureVariable(this.variable) {
-    assert(variable != null);
-  }
+  GetClosureVariable(ClosureVariable variable)
+      : this.variable = new Reference<ClosureVariable>(variable);
 
   accept(Visitor visitor) => visitor.visitGetClosureVariable(this);
 }
 
-/// Assign or declare a closure variable. The identity of the variable is
-/// determined by a [Local].
+/// Assign or declare a closure variable.
 ///
 /// Closure variables can be seen as ref cells that are not first-class values.
 /// If [isDeclaration], this can seen as a let binding:
 ///
 ///   let [variable] = ref [value] in [body]
 ///
 /// And otherwise, it can be seen as a dereferencing assignment:
 ///
 ///   { ![variable] := [value]; [body] }
 ///
 /// Closure variables without a declaring [SetClosureVariable] are implicitly
 /// declared at the entry to the [variable]'s enclosing function.
 class SetClosureVariable extends Expression implements InteriorNode {
-  final Local variable;
+  final Reference<ClosureVariable> variable;
   final Reference<Primitive> value;
   Expression body;
 
   /// If true, this declares a new copy of the closure variable. If so, all
   /// uses of the closure variable must occur in the [body].
   ///
   /// There can be at most one declaration per closure variable. If there is no
   /// declaration, only one copy exists (per function execution). It is best to
   /// avoid declaring closure variables if it is not necessary.
   final bool isDeclaration;
 
-  SetClosureVariable(this.variable, Primitive value,
+  SetClosureVariable(ClosureVariable variable, Primitive value,
                      {this.isDeclaration : false })
-      : this.value = new Reference<Primitive>(value) {
-    assert(variable != null);
-  }
+      : this.value = new Reference<Primitive>(value),
+        this.variable = new Reference<ClosureVariable>(variable);
 
   accept(Visitor visitor) => visitor.visitSetClosureVariable(this);
 
   Expression plug(Expression expr) {
     assert(body == null);
     return body = expr;
   }
 }
 
 /// Create a potentially recursive function and store it in a closure variable.
 /// The function can access itself using [GetClosureVariable] on [variable].
 /// There must not exist a [SetClosureVariable] to [variable].
 ///
 /// This can be seen as a let rec binding:
 ///
 ///   let rec [variable] = [definition] in [body]
 ///
 class DeclareFunction extends Expression implements InteriorNode {
-  final Local variable;
+  final Reference<ClosureVariable> variable;
   final FunctionDefinition definition;
   Expression body;
 
-  DeclareFunction(this.variable, this.definition);
+  DeclareFunction(ClosureVariable variable, this.definition)
+      : this.variable = new Reference<ClosureVariable>(variable);
 
   Expression plug(Expression expr) {
     assert(body == null);
     return body = expr;
   }
 
   accept(Visitor visitor) => visitor.visitDeclareFunction(this);
 }
 
 /// Invoke a continuation in tail position.
@@ skipping 191 matching lines @@
   ///       Class.c();
   ///     }
   ///
   /// If `field` had an initializer, possibly `null`, constructors `Class.a` and
   /// `Class.b` would be invalid, and since `field` has no initializer
   /// constructor `Class.c` is invalid. We therefore need to distinguish the two
   /// cases.
   bool get hasInitializer => body != null;
 }
 
+/// Identifies a closure variable.
+class ClosureVariable extends Definition {
+  /// Body of code that declares this closure variable.
+  ExecutableElement host;
+  Entity hint;
+
+  ClosureVariable(this.host, this.hint);
+
+  accept(Visitor v) => v.visitClosureVariable(this);
+}
+
 /// A function definition, consisting of parameters and a body.  The parameters
 /// include a distinguished continuation parameter.
 class FunctionDefinition extends Node
     implements InteriorNode, ExecutableDefinition {
   final FunctionElement element;
   final Continuation returnContinuation;
-  final List<Parameter> parameters;
+  /// Mixed list of [Parameter]s and [ClosureVariable]s.
+  final List<Definition> parameters;
   Expression body;
   final List<ConstDeclaration> localConstants;
 
   /// Values for optional parameters.
   final List<ConstantExpression> defaultParameterValues;
 
+  /// Closure variables declared by this function.
+  final List<ClosureVariable> closureVariables;
+
   FunctionDefinition(this.element, this.returnContinuation,
       this.parameters, this.body, this.localConstants,
-      this.defaultParameterValues);
+      this.defaultParameterValues, this.closureVariables);
 
   FunctionDefinition.abstract(this.element,
                               this.parameters,
                               this.defaultParameterValues)
       : this.returnContinuation = null,
-        this.localConstants = const <ConstDeclaration>[];
+        this.localConstants = const <ConstDeclaration>[],
+        this.closureVariables = const <ClosureVariable>[];
 
   accept(Visitor visitor) => visitor.visitFunctionDefinition(this);
   applyPass(Pass pass) => pass.rewriteFunctionDefinition(this);
 
   /// Returns `true` if this function is abstract or external.
   ///
   /// If `true`, [body] and [returnContinuation] are `null` and [localConstants]
   /// is empty.
   bool get isAbstract => body == null;
 }
@@ skipping 34 matching lines @@
   // Definitions.
   T visitLiteralList(LiteralList node) => visitPrimitive(node);
   T visitLiteralMap(LiteralMap node) => visitPrimitive(node);
   T visitConstant(Constant node) => visitPrimitive(node);
   T visitThis(This node) => visitPrimitive(node);
   T visitReifyTypeVar(ReifyTypeVar node) => visitPrimitive(node);
   T visitCreateFunction(CreateFunction node) => visitPrimitive(node);
   T visitGetClosureVariable(GetClosureVariable node) => visitPrimitive(node);
   T visitParameter(Parameter node) => visitPrimitive(node);
   T visitContinuation(Continuation node) => visitDefinition(node);
+  T visitClosureVariable(ClosureVariable node) => visitDefinition(node);
 
   // Conditions.
   T visitIsTrue(IsTrue node) => visitCondition(node);
 
   // JavaScript specific nodes.
   T visitIdentical(Identical node) => visitPrimitive(node);
 }
 
 /// Recursively visits the entire CPS term, and calls abstract `process*`
 /// (i.e. `processLetPrim`) functions in pre-order.
@@ skipping 14 matching lines @@
   visitFieldDefinition(FieldDefinition node) {
     processFieldDefinition(node);
     if (node.hasInitializer) {
       visit(node.body);
     }
   }
 
   processFunctionDefinition(FunctionDefinition node) {}
   visitFunctionDefinition(FunctionDefinition node) {
     processFunctionDefinition(node);
-    node.parameters.forEach(visitParameter);
+    node.parameters.forEach(visit);
     if (!node.isAbstract) {
       visit(node.body);
     }
   }
 
   // Expressions.
 
   processLetPrim(LetPrim node) {}
   visitLetPrim(LetPrim node) {
     processLetPrim(node);
@@ skipping 105 matching lines @@
 
   processReifyTypeVar(ReifyTypeVar node) {}
   visitReifyTypeVar(ReifyTypeVar node) => processReifyTypeVar(node);
 
   processCreateFunction(CreateFunction node) {}
   visitCreateFunction(CreateFunction node) {
     processCreateFunction(node);
     visit(node.definition);
   }
 
+  processClosureVariable(node) {}
+  visitClosureVariable(ClosureVariable node) {
+    processClosureVariable(node);
+  }
+
   processGetClosureVariable(GetClosureVariable node) {}
-  visitGetClosureVariable(GetClosureVariable node) =>
-      processGetClosureVariable(node);
+  visitGetClosureVariable(GetClosureVariable node) {
+    processGetClosureVariable(node);
+  }
 
   processParameter(Parameter node) {}
   visitParameter(Parameter node) => processParameter(node);
 
   processContinuation(Continuation node) {}
   visitContinuation(Continuation node) {
     processContinuation(node);
     node.parameters.forEach(visitParameter);
     visit(node.body);
   }
@@ skipping 76 matching lines @@
   void visitFieldDefinition(FieldDefinition node) {
     if (node.hasInitializer) {
       visit(node.body);
     }
   }
 
   void visitFunctionDefinition(FunctionDefinition node) {
     if (!node.isAbstract) {
       visit(node.body);
     }
-    node.parameters.forEach(allocate); // Assign indices to unused parameters.
+    // Assign indices to unused parameters.
+    for (Definition param in node.parameters) {
+      if (param is Primitive) {
+        allocate(param);
+      }
+    }
   }
 
   void visitLetPrim(LetPrim node) {
     visit(node.body);
     release(node.primitive);
     visit(node.primitive);
   }
 
   void visitLetCont(LetCont node) {
     visit(node.continuation);
@@ skipping 90 matching lines @@
   }
 
   // JavaScript specific nodes.
 
   void visitIdentical(Identical node) {
     visitReference(node.left);
     visitReference(node.right);
   }
 }