Rename ClosureVariable, use separate IR forms for declaration and assignment.

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;
 import '../dart2jslib.dart' as dart2js show invariant;
 import '../elements/elements.dart';
 import '../universe/universe.dart' show Selector, SelectorKind;
 import '../dart_types.dart' show DartType, GenericType;
 import '../cps_ir/optimizers.dart';
-import '../closure.dart' show ClosureClassElement;
 
 abstract class Node {
   /// A pointer to the parent node. Is null until set by optimization passes.
   Node parent;
 
   accept(Visitor visitor);
 }
 
 abstract class Expression extends Node {
   Expression plug(Expression expr) => throw 'impossible';
@@ skipping 74 matching lines @@
     } else {
       previous.next = next;
     }
     if (next != null) next.previous = previous;
   }
 }
 
 /// Binding a value (primitive or constant): 'let val x = V in E'.  The bound
 /// value is in scope in the body.
 /// During one-pass construction a LetVal with an empty body is used to
-/// represent one-level context 'let val x = V in []'.
+/// represent the one-hole context 'let val x = V in []'.
 class LetPrim extends Expression implements InteriorNode {
   final Primitive primitive;
   Expression body;
 
   LetPrim(this.primitive, [this.body = null]);
 
   Expression plug(Expression expr) {
     assert(body == null);
     return body = expr;
   }
 
   accept(Visitor visitor) => visitor.visitLetPrim(this);
 }
 
 
 /// Binding continuations.
 ///
 /// let cont k0(v0 ...) = E0
 ///          k1(v1 ...) = E1
 ///          ...
 ///   in E
 ///
 /// The bound continuations are in scope in the body and the continuation
 /// parameters are in scope in the respective continuation bodies.
 /// During one-pass construction a LetCont whose first continuation has an empty
-/// body is used to represent the one-level context
+/// body is used to represent the one-hole context
 /// 'let cont ... k(v) = [] ... in E'.
 class LetCont extends Expression implements InteriorNode {
   List<Continuation> continuations;
   Expression body;
 
   LetCont(Continuation continuation, this.body)
       : continuations = <Continuation>[continuation];
 
   LetCont.many(this.continuations, this.body);
 
   Expression plug(Expression expr) {
     assert(continuations != null &&
            continuations.isNotEmpty &&
            continuations.first.body == null);
     return continuations.first.body = expr;
   }
 
   accept(Visitor visitor) => visitor.visitLetCont(this);
 }
 
+/// Binding mutable variables.
+///
+/// let mutable v = P in E
+///
+/// [MutableVariable]s can be seen as ref cells that are not first-class
+/// values.  They are therefore not [Primitive]s and not bound by [LetPrim]
+/// to prevent unrestricted use of references to them.  During one-pass

[karlklose, 2015/02/03 09:56:16]

Would it make sense to share the context (maybe on a commen interface that also
contains 'body')?

[Kevin Millikin (Google), 2015/02/03 14:11:48]

It's not always a field named body that gets plugged.  The thing that is common
to all the one-hole contexts is that they have a .plug(Expression) method.

I suppose we could introduce an interface for Expressions that have .plug.  Do
you think it buys us much?

+/// construction, a [LetMutable} with an empty body is use to represent the

[karlklose, 2015/02/03 09:56:16]

'[LetMutable}' -> '[LetMutable]'.

[Kevin Millikin (Google), 2015/02/03 14:11:49]

Done.

+/// one-hole context 'let mutable v = P in []'.
+class LetMutable extends Expression implements InteriorNode {
+  final MutableVariable variable;
+  final Reference<Primitive> value;
+  Expression body;
+
+  LetMutable(this.variable, Primitive value)
+      : this.value = new Reference<Primitive>(value);
+
+  Expression plug(Expression expr) {
+    return body = expr;
+  }
+
+  accept(Visitor visitor) => visitor.visitLetMutable(this);
+}
+
 abstract class Invoke {
   Selector get selector;
   List<Reference<Primitive>> get arguments;
 }
 
 /// Represents a node with a child node, which can be accessed through the
 /// `body` member. A typical usage is when removing a node from the CPS graph:
 ///
 ///     Node child          = node.body;
 ///     InteriorNode parent = node.parent;
@@ skipping 176 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.
+/// Gets the value from a [MutableVariable].
 ///
-/// Closure variables can be seen as ref cells that are not first-class values.
-/// A [LetPrim] with a [GetClosureVariable] can then be seen as:
+/// [MutableVariable]s can be seen as ref cells that are not first-class
+/// values.  A [LetPrim] with a [GetMutableVariable] can then be seen as:
 ///
 ///   let prim p = ![variable] in [body]
 ///
-class GetClosureVariable extends Primitive {
-  final Reference<ClosureVariable> variable;
+class GetMutableVariable extends Primitive {
+  final Reference<MutableVariable> variable;
 
-  GetClosureVariable(ClosureVariable variable)
-      : this.variable = new Reference<ClosureVariable>(variable);
+  GetMutableVariable(MutableVariable variable)
+      : this.variable = new Reference<MutableVariable>(variable);
 
-  accept(Visitor visitor) => visitor.visitGetClosureVariable(this);
+  accept(Visitor visitor) => visitor.visitGetMutableVariable(this);
 }
 
-/// Assign or declare a closure variable.
+/// Assign a [MutableVariable].
 ///
-/// Closure variables can be seen as ref cells that are not first-class values.
-/// If [isDeclaration], this can seen as a let binding:
+/// [MutableVariable]s can be seen as ref cells that are not first-class
+/// values.  This can be seen as a dereferencing assignment:
 ///
-///   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 Reference<ClosureVariable> variable;
+///   { [variable] := [value]; [body] }
+class SetMutableVariable extends Expression implements InteriorNode {
+  final Reference<MutableVariable> 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;
+  SetMutableVariable(MutableVariable variable, Primitive value)
+      : this.variable = new Reference<MutableVariable>(variable),
+        this.value = new Reference<Primitive>(value);
 
-  SetClosureVariable(ClosureVariable variable, Primitive value,
-                     {this.isDeclaration : false })
-      : this.value = new Reference<Primitive>(value),
-        this.variable = new Reference<ClosureVariable>(variable);
-
-  accept(Visitor visitor) => visitor.visitSetClosureVariable(this);
+  accept(Visitor visitor) => visitor.visitSetMutableVariable(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].
+/// Create a potentially recursive function and store it in a [MutableVariable].
+/// The function can access itself using [GetMutableVariable] on [variable].
+/// There must not exist a [SetMutableVariable] to [variable].
 ///
 /// This can be seen as a let rec binding:
 ///
 ///   let rec [variable] = [definition] in [body]
 ///
 class DeclareFunction extends Expression implements InteriorNode {
-  final Reference<ClosureVariable> variable;
+  final MutableVariable variable;
   final FunctionDefinition definition;
   Expression body;
 
-  DeclareFunction(ClosureVariable variable, this.definition)
-      : this.variable = new Reference<ClosureVariable>(variable);
+  DeclareFunction(this.variable, this.definition);
 
   Expression plug(Expression expr) {
     assert(body == null);
     return body = expr;
   }
 
   accept(Visitor visitor) => visitor.visitDeclareFunction(this);
 }
 
 /// Invoke a continuation in tail position.
@@ skipping 263 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.
+/// Identifies a mutable variable.
+class MutableVariable extends Definition {
+  /// Body of source code that declares this mutable variable.
   ExecutableElement host;
   Entity hint;
 
-  ClosureVariable(this.host, this.hint);
+  MutableVariable(this.host, this.hint);
 
-  accept(Visitor v) => v.visitClosureVariable(this);
+  accept(Visitor v) => v.visitMutableVariable(this);
 }
 
 class RunnableBody extends InteriorNode {
   Expression body;
   final Continuation returnContinuation;
   RunnableBody(this.body, this.returnContinuation);
   accept(Visitor visitor) => visitor.visitRunnableBody(this);
 }
 
 /// A function definition, consisting of parameters and a body.  The parameters
 /// include a distinguished continuation parameter (held by the body).
 class FunctionDefinition extends Node
     implements ExecutableDefinition {
   final FunctionElement element;
-  /// Mixed list of [Parameter]s and [ClosureVariable]s.
+  /// Mixed list of [Parameter]s and [MutableVariable]s.
   final List<Definition> parameters;
   final RunnableBody body;
   final List<ConstDeclaration> localConstants;
 
   /// Values for optional parameters.
   final List<ConstantExpression> defaultParameterValues;
 
   FunctionDefinition(this.element,
       this.parameters,
       this.body,
@@ skipping 82 matching lines @@
   }
 
   // Initializers
   T visitInitializer(Initializer node) => visitNode(node);
   T visitFieldInitializer(FieldInitializer node) => visitInitializer(node);
   T visitSuperInitializer(SuperInitializer node) => visitInitializer(node);
 
   // Expressions.
   T visitLetPrim(LetPrim node) => visitExpression(node);
   T visitLetCont(LetCont node) => visitExpression(node);
+  T visitLetMutable(LetMutable node) => visitExpression(node);
   T visitInvokeStatic(InvokeStatic node) => visitExpression(node);
   T visitInvokeContinuation(InvokeContinuation node) => visitExpression(node);
   T visitInvokeMethod(InvokeMethod node) => visitExpression(node);
   T visitInvokeMethodDirectly(InvokeMethodDirectly node) => visitExpression(node);
   T visitInvokeConstructor(InvokeConstructor node) => visitExpression(node);
   T visitConcatenateStrings(ConcatenateStrings node) => visitExpression(node);
   T visitBranch(Branch node) => visitExpression(node);
   T visitTypeOperator(TypeOperator node) => visitExpression(node);
-  T visitSetClosureVariable(SetClosureVariable node) => visitExpression(node);
+  T visitSetMutableVariable(SetMutableVariable node) => visitExpression(node);
   T visitDeclareFunction(DeclareFunction node) => visitExpression(node);
   T visitSetField(SetField node) => visitExpression(node);
 
   // 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 visitGetMutableVariable(GetMutableVariable node) => visitPrimitive(node);
   T visitParameter(Parameter node) => visitPrimitive(node);
   T visitContinuation(Continuation node) => visitDefinition(node);
-  T visitClosureVariable(ClosureVariable node) => visitDefinition(node);
+  T visitMutableVariable(MutableVariable node) => visitDefinition(node);
   T visitGetField(GetField node) => visitDefinition(node);
   T visitCreateBox(CreateBox node) => visitDefinition(node);
   T visitCreateInstance(CreateInstance node) => visitDefinition(node);
 
   // Conditions.
   T visitIsTrue(IsTrue node) => visitCondition(node);
 
   // JavaScript specific nodes.
   T visitIdentical(Identical node) => visitPrimitive(node);
   T visitInterceptor(Interceptor node) => visitPrimitive(node);
@@ skipping 68 matching lines @@
     visit(node.body);
   }
 
   processLetCont(LetCont node) {}
   visitLetCont(LetCont node) {
     processLetCont(node);
     node.continuations.forEach(visit);
     visit(node.body);
   }
 
+  processLetMutable(LetMutable node) {}
+  visitLetMutable(LetMutable node) {
+    processLetMutable(node);
+    visit(node.variable);
+    processReference(node.value);
+    visit(node.body);
+  }
+
   processInvokeStatic(InvokeStatic node) {}
   visitInvokeStatic(InvokeStatic node) {
     processInvokeStatic(node);
     processReference(node.continuation);
     node.arguments.forEach(processReference);
   }
 
   processInvokeContinuation(InvokeContinuation node) {}
   visitInvokeContinuation(InvokeContinuation node) {
     processInvokeContinuation(node);
@@ skipping 39 matching lines @@
     visit(node.condition);
   }
 
   processTypeOperator(TypeOperator node) {}
   visitTypeOperator(TypeOperator node) {
     processTypeOperator(node);
     processReference(node.continuation);
     processReference(node.receiver);
   }
 
-  processSetClosureVariable(SetClosureVariable node) {}
-  visitSetClosureVariable(SetClosureVariable node) {
-    processSetClosureVariable(node);
+  processSetMutableVariable(SetMutableVariable node) {}
+  visitSetMutableVariable(SetMutableVariable node) {
+    processSetMutableVariable(node);
+    processReference(node.variable);
     processReference(node.value);
     visit(node.body);
   }
 
   processDeclareFunction(DeclareFunction node) {}
   visitDeclareFunction(DeclareFunction node) {
     processDeclareFunction(node);
+    visit(node.variable);
     visit(node.definition);
     visit(node.body);
   }
 
   // Definitions.
 
   processLiteralList(LiteralList node) {}
   visitLiteralList(LiteralList node) {
     processLiteralList(node);
     node.values.forEach(processReference);
@@ skipping 16 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);
+  processMutableVariable(node) {}
+  visitMutableVariable(MutableVariable node) {
+    processMutableVariable(node);
   }
 
-  processGetClosureVariable(GetClosureVariable node) {}
-  visitGetClosureVariable(GetClosureVariable node) {
-    processGetClosureVariable(node);
+  processGetMutableVariable(GetMutableVariable node) {}
+  visitGetMutableVariable(GetMutableVariable node) {
+    processGetMutableVariable(node);
   }
 
   processParameter(Parameter node) {}
   visitParameter(Parameter node) => processParameter(node);
 
   processContinuation(Continuation node) {}
   visitContinuation(Continuation node) {
     processContinuation(node);
     node.parameters.forEach(visitParameter);
     if (node.body != null) visit(node.body);
@@ skipping 151 matching lines @@
     visit(node.body);
     release(node.primitive);
     visit(node.primitive);
   }
 
   void visitLetCont(LetCont node) {
     node.continuations.forEach(visit);
     visit(node.body);
   }
 
+  void visitLetMutable(LetMutable node) {
+    visit(node.body);
+    visitReference(node.value);
+  }
+
   void visitInvokeStatic(InvokeStatic node) {
     node.arguments.forEach(visitReference);
   }
 
   void visitInvokeContinuation(InvokeContinuation node) {
     node.arguments.forEach(visitReference);
   }
 
   void visitInvokeMethod(InvokeMethod node) {
     visitReference(node.receiver);
@@ skipping 38 matching lines @@
   void visitThis(This node) {
   }
 
   void visitReifyTypeVar(ReifyTypeVar node) {
   }
 
   void visitCreateFunction(CreateFunction node) {
     new RegisterAllocator().visit(node.definition);
   }
 
-  void visitGetClosureVariable(GetClosureVariable node) {
+  void visitGetMutableVariable(GetMutableVariable node) {
   }
 
-  void visitSetClosureVariable(SetClosureVariable node) {
+  void visitSetMutableVariable(SetMutableVariable node) {
     visit(node.body);
     visitReference(node.value);
   }
 
   void visitDeclareFunction(DeclareFunction node) {
     new RegisterAllocator().visit(node.definition);
     visit(node.body);
   }
 
   void visitParameter(Parameter node) {
@@ skipping 36 matching lines @@
 
   void visitIdentical(Identical node) {
     visitReference(node.left);
     visitReference(node.right);
   }
 
   void visitInterceptor(Interceptor node) {
     visitReference(node.input);
   }
 }