dart2dart: Support for inner functions in new IR.

sdk/lib/_internal/compiler/implementation/ir/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 '../dart2jslib.dart' as dart2js show Constant, ConstructedConstant,
   StringConstant, ListConstant, MapConstant;
@@ skipping 31 matching lines @@
     do {
       current.definition = this;
       previous = current;
       current = current.nextRef;
     } while (current != null);
     previous.nextRef = firstRef;
     firstRef = other.firstRef;
   }
 }
 
-/// A pure expression that cannot throw or diverge.
+/// An expression that cannot throw or diverge and has no side-effects.
 /// All primitives are named using the identity of the [Primitive] object.
+///
+/// Primitives may allocate objects, this is not considered side-effect here.
+///
+/// Although primitives may not mutate state, they may depend on state.
 abstract class Primitive extends Definition {
   /// The [VariableElement] or [ParameterElement] from which the primitive
   /// binding originated.
-  Element element;
+  Element hint;
 
   /// Register in which the variable binding this primitive can be allocated.
   /// Separate register spaces are used for primitives with different [element].
   /// Assigned by [RegisterAllocator], is null before that phase.
   int registerIndex;
 
   /// Use the given element as a hint for naming this primitive.
   ///
   /// Has no effect if this primitive already has a non-null [element].
   void useElementAsHint(Element hint) {
-    if (element == null) {
-      element = hint;
+    if (this.hint == null) {
+      this.hint = hint;
     }
   }
 }
 
 /// Operands to invocations and primitives are always variables.  They point to
 /// their definition and are linked into a list of occurrences.
 class Reference {
   Definition definition;
   Reference nextRef = null;
 
@@ skipping 169 matching lines @@
   final Reference continuation;
   final List<Reference> arguments;
 
   ConcatenateStrings(Continuation cont, List<Definition> args)
       : continuation = new Reference(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 an [Element].
+///
+/// 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 Element variable;
+
+  GetClosureVariable(this.variable) {
+    assert(variable != null);
+  }
+
+  accept(Visitor visitor) => visitor.visitGetClosureVariable(this);
+}
+
+/// Assign or declare a closure variable. The identity of the variable is
+/// determined by an [Element].
+///
+/// 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 {
+  final Element variable;
+  final Reference 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,
+                      {this.isDeclaration : false })
+      : this.value = new Reference(value) {
+    assert(variable != null);
+  }
+
+  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 may not exist a [SetClosureVariable] to [variable].

[sigurdm, 2014/07/02 14:29:20]

I guess it is clearer to write
/// There must not exist a [SetClosureVariable] to [variable].

[asgerf, 2014/07/02 14:35:32]

You're right, thanks.

+///
+/// This can be seen as a let rec binding:
+///
+///   let rec [variable] = [definition] in [body]
+///
+class DeclareFunction extends Expression {
+  final Element variable;
+  final FunctionDefinition definition;
+  Expression body;
+
+  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.
 class InvokeContinuation extends Expression {
   final Reference continuation;
   final List<Reference> arguments;
 
   // An invocation of a continuation is recursive if it occurs in the body of
   // the continuation itself.
   bool isRecursive;
 
   InvokeContinuation(Continuation cont, List<Definition> args,
@@ skipping 43 matching lines @@
 
 class This extends Primitive {
   This();
 
   accept(Visitor visitor) => visitor.visitThis(this);
 }
 
 /// Reify the given type variable as a [Type].
 /// This depends on the current binding of 'this'.
 class ReifyTypeVar extends Primitive {
-  final TypeVariableElement element;
+  final TypeVariableElement typeVariable;
 
-  ReifyTypeVar(this.element);
+  ReifyTypeVar(this.typeVariable);
 
   dart2js.Constant get constant => null;
 
   accept(Visitor visitor) => visitor.visitReifyTypeVar(this);
 }
 
 class LiteralList extends Primitive {
   /// The List type being created; this is not the type argument.
   final GenericType type;
   final List<Reference> values;
 
   LiteralList(this.type, List<Primitive> values)
       : this.values = _referenceList(values);
 
   accept(Visitor visitor) => visitor.visitLiteralList(this);
 }
 
 class LiteralMap extends Primitive {
   final GenericType type;
   final List<Reference> keys;
   final List<Reference> values;
 
   LiteralMap(this.type, List<Primitive> keys, List<Primitive> values)
       : this.keys = _referenceList(keys),
         this.values = _referenceList(values);
 
   accept(Visitor visitor) => visitor.visitLiteralMap(this);
 }
 
+/// Create a non-recursive function.
+class CreateFunction extends Primitive {
+  final FunctionDefinition definition;
+
+  CreateFunction(this.definition);
+
+  accept(Visitor visitor) => visitor.visitCreateFunction(this);
+}
+
 class IsCheck extends Primitive {
   final Reference receiver;
   final DartType type;
 
   dart2js.Constant get constant => null;
 
   IsCheck(Primitive receiver, this.type)
       : this.receiver = new Reference(receiver);
 
   accept(Visitor visitor) => visitor.visitIsCheck(this);
 }
 
 class Parameter extends Primitive {
   Parameter(Element element) {
-    super.element = element;
+    super.hint = element;
   }
 
   accept(Visitor visitor) => visitor.visitParameter(this);
 }
 
 /// Continuations are normally bound by 'let cont'.  A continuation with no
 /// parameter (or body) is used to represent a function's return continuation.
 /// The return continuation is bound by the Function, not by 'let cont'.
 class Continuation extends Definition {
   final List<Parameter> parameters;
   Expression body = null;
 
   // A continuation is recursive if it has any recursive invocations.
   bool isRecursive = false;
 
   Continuation(this.parameters);
 
   Continuation.retrn() : parameters = null;
 
   accept(Visitor visitor) => visitor.visitContinuation(this);
 }
 
 /// A function definition, consisting of parameters and a body.  The parameters
 /// include a distinguished continuation parameter.
 class FunctionDefinition extends Node {
+  final FunctionElement element;
   final Continuation returnContinuation;
   final List<Parameter> parameters;
   final Expression body;
   final List<ConstDeclaration> localConstants;
 
-  FunctionDefinition(this.returnContinuation, this.parameters, this.body,
-      this.localConstants);
+  FunctionDefinition(this.element, this.returnContinuation,
+      this.parameters, this.body, this.localConstants);
 
   accept(Visitor visitor) => visitor.visitFunctionDefinition(this);
 }
 
 List<Reference> _referenceList(List<Definition> definitions) {
   return definitions.map((e) => new Reference(e)).toList(growable: false);
 }
 
 abstract class Visitor<T> {
   T visit(Node node) => node.accept(this);
@@ skipping 11 matching lines @@
   T visitLetPrim(LetPrim node) => visitExpression(node);
   T visitLetCont(LetCont node) => visitExpression(node);
   T visitInvokeStatic(InvokeStatic node) => visitExpression(node);
   T visitInvokeContinuation(InvokeContinuation node) => visitExpression(node);
   T visitInvokeMethod(InvokeMethod node) => visitExpression(node);
   T visitInvokeSuperMethod(InvokeSuperMethod node) => visitExpression(node);
   T visitInvokeConstructor(InvokeConstructor node) => visitExpression(node);
   T visitConcatenateStrings(ConcatenateStrings node) => visitExpression(node);
   T visitBranch(Branch node) => visitExpression(node);
   T visitAsCast(AsCast node) => visitExpression(node);
+  T visitSetClosureVariable(SetClosureVariable node) => visitExpression(node);
+  T visitDeclareFunction(DeclareFunction node) => visitExpression(node);
 
   // Definitions.
   T visitLiteralList(LiteralList node) => visitPrimitive(node);
   T visitLiteralMap(LiteralMap node) => visitPrimitive(node);
   T visitIsCheck(IsCheck 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);
 
   // Conditions.
   T visitIsTrue(IsTrue node) => visitCondition(node);
 }
 
 /// Generate a Lisp-like S-expression representation of an IR node as a string.
 /// The representation is not pretty-printed, but it can easily be quoted and
 /// dropped into the REPL of one's favorite Lisp or Scheme implementation to be
@@ skipping 106 matching lines @@
 
   String visitConstant(Constant node) {
     return '(Constant ${node.value})';
   }
 
   String visitThis(This node) {
     return '(This)';
   }
 
   String visitReifyTypeVar(ReifyTypeVar node) {
-    return '(ReifyTypeVar ${node.element.name})';
+    return '(ReifyTypeVar ${node.typeVariable.name})';
+  }
+
+  String visitCreateFunction(CreateFunction node) {
+    String function = visit(node.definition);
+    return '(CreateFunction ${node.definition.element} $function)';
   }
 
   String visitParameter(Parameter node) {
     // Parameters are visited directly in visitLetCont.
     return '(Unexpected Parameter)';
   }
 
   String visitContinuation(Continuation node) {
     // Continuations are visited directly in visitLetCont.
     return '(Unexpected Continuation)';
   }
 
+  String visitGetClosureVariable(GetClosureVariable node) {
+    return '(GetClosureVariable ${node.variable.name})';
+  }
+
+  String visitSetClosureVariable(SetClosureVariable node) {
+    String value = names[node.value.definition];
+    String body = visit(node.body);
+    return '(SetClosureVariable ${node.variable.name} $value $body)';
+  }
+
+  String visitDeclareFunction(DeclareFunction node) {
+    String function = visit(node.definition);
+    String body = visit(node.body);
+    return '(DeclareFunction ${node.variable} = $function in $body)';
+  }
+
   String visitIsTrue(IsTrue node) {
     String value = names[node.value.definition];
     return '(IsTrue $value)';
   }
 }
 
 /// Keeps track of currently unused register indices.
 class RegisterArray {
   int nextIndex = 0;
   final List<int> freeStack = <int>[];
@@ skipping 28 matching lines @@
     RegisterArray registers = elementRegisters[element];
     if (registers == null) {
       registers = new RegisterArray();
       elementRegisters[element] = registers;
     }
     return registers;
   }
 
   void allocate(Primitive primitive) {
     if (primitive.registerIndex == null) {
-      primitive.registerIndex = getRegisterArray(primitive.element).makeIndex();
+      primitive.registerIndex = getRegisterArray(primitive.hint).makeIndex();
     }
   }
 
   void release(Primitive primitive) {
     // Do not share indices for temporaries as this may obstruct inlining.
-    if (primitive.element == null) return;
+    if (primitive.hint == null) return;
     if (primitive.registerIndex != null) {
-      getRegisterArray(primitive.element).releaseIndex(primitive.registerIndex);
+      getRegisterArray(primitive.hint).releaseIndex(primitive.registerIndex);
     }
   }
 
   void visitReference(Reference reference) {
     allocate(reference.definition);
   }
 
   void visitFunctionDefinition(FunctionDefinition node) {
     visit(node.body);
     node.parameters.forEach(allocate); // Assign indices to unused parameters.
@@ skipping 61 matching lines @@
 
   void visitConstant(Constant node) {
   }
 
   void visitThis(This node) {
   }
 
   void visitReifyTypeVar(ReifyTypeVar node) {
   }
 
+  void visitCreateFunction(CreateFunction node) {
+    new RegisterAllocator().visit(node.definition);
+  }
+
+  void visitGetClosureVariable(GetClosureVariable node) {
+  }
+
+  void visitSetClosureVariable(SetClosureVariable node) {
+    visit(node.body);
+    visitReference(node.value);
+  }
+
+  void visitDeclareFunction(DeclareFunction node) {
+    new RegisterAllocator().visit(node.definition);
+    visit(node.body);
+  }
+
   void visitParameter(Parameter node) {
     throw "Parameters should not be visited by RegisterAllocator";
   }
 
   void visitContinuation(Continuation node) {
     visit(node.body);
 
     // Arguments get allocated left-to-right, so we release parameters
     // right-to-left. This increases the likelihood that arguments can be
     // transferred without intermediate assignments.
     for (int i = node.parameters.length - 1; i >= 0; --i) {
       release(node.parameters[i]);
     }
   }
 
   void visitIsTrue(IsTrue node) {
     visitReference(node.value);
   }
 
 }