Use closure conversion in new dart2js backend.

pkg/compiler/lib/src/cps_ir/cps_ir_builder_visitor.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.
 
 part of dart2js.ir_builder;
 
 /**
  * This task iterates through all resolved elements and builds [ir.Node]s. The
  * nodes are stored in the [nodes] map and accessible through [hasIr] and
  * [getIr].
@@ skipping 90 matching lines @@
 
 /**
  * A tree visitor that builds [IrNodes]. The visit methods add statements using
  * to the [builder] and return the last added statement for trees that represent
  * an expression.
  */
 class IrBuilderVisitor extends ResolvedVisitor<ir.Primitive>
     with IrBuilderMixin<ast.Node> {
   final Compiler compiler;
   final SourceFile sourceFile;
+  ClosureClassMap closureMap;
 
   // In SSA terms, join-point continuation parameters are the phis and the
   // continuation invocation arguments are the corresponding phi inputs.  To
   // support name introduction and renaming for source level variables, we use
   // nested (delimited) visitors for constructing subparts of the IR that will
   // need renaming.  Each source variable is assigned an index.
   //
   // Each nested visitor maintains a list of free variable uses in the body.
   // These are implemented as a list of parameters, each with their own use
   // list of references.  When the delimited subexpression is plugged into the
   // surrounding context, the free occurrences can be captured or become free
   // occurrences in the next outer delimited subexpression.
   //
   // Each nested visitor maintains a list that maps indexes of variables
   // assigned in the delimited subexpression to their reaching definition ---
   // that is, the definition in effect at the hole in 'current'.  These are
   // used to determine if a join-point continuation needs to be passed
   // arguments, and what the arguments are.
 
   /// Construct a top-level visitor.
   IrBuilderVisitor(TreeElements elements, this.compiler, this.sourceFile)
       : super(elements);
 
+  /// True if using the JavaScript backend; we use this to determine how
+  /// closures should be translated.
+  bool get isJavaScriptBackend => compiler.backend is JavaScriptBackend;
+
   /**
    * Builds the [ir.ExecutableDefinition] for an executable element. In case the
    * function uses features that cannot be expressed in the IR, this element
    * returns `null`.
    */
   ir.ExecutableDefinition buildExecutable(ExecutableElement element) {
     return nullIfGiveup(() {
       if (element is FieldElement) {
         return buildField(element);
       } else if (element is FunctionElement) {
         return buildFunction(element);
       } else {
         compiler.internalError(element, "Unexpected element type $element");
       }
     });
   }
 
+  Map mapValues(Map map, dynamic fn(dynamic)) {
+    Map result = {};
+    map.forEach((key,value) {
+      result[key] = fn(value);
+    });
+    return result;
+  }
+
+  // Converts closure.dart's CapturedVariable into a ClosureLocation.
+  // There is a 1:1 corresponce between these; we do this because the IR builder
+  // should not depend on synthetic elements.
+  ClosureLocation getLocation(CapturedVariable v) {
+    if (v is BoxFieldElement) {
+      return new ClosureLocation(v.box, v);
+    } else {
+      ClosureFieldElement field = v;
+      return new ClosureLocation(null, field);
+    }
+  }
+
+  /// If the current function is a nested function with free variables (or a
+  /// captured reference to `this`), this returns a [ClosureEnvironment]
+  /// indicating how to access these.
+  ClosureEnvironment getClosureEnvironment() {
+    if (closureMap == null) return null; // dart2dart does not use closureMap.
+    if (closureMap.closureElement == null) return null;
+    return new ClosureEnvironment(
+        closureMap.closureElement,
+        closureMap.thisLocal,
+        mapValues(closureMap.freeVariableMap, getLocation));
+  }
+
+  /// If [node] has declarations for variables that should be boxed, this
+  /// returns a [ClosureScope] naming a box to create, and enumerating the
+  /// variables that should be stored in the box.
+  ///
+  /// Also see [ClosureScope].
+  ClosureScope getClosureScope(ast.Node node) {
+    if (closureMap == null) return null; // dart2dart does not use closureMap.
+    closurelib.ClosureScope scope = closureMap.capturingScopes[node];
+    if (scope == null) return null;
+    // We translate a ClosureScope from closure.dart into IR builder's variant
+    // because the IR builder should not depend on the synthetic elements
+    // created in closure.dart.
+    return new ClosureScope(scope.boxElement,
+                            mapValues(scope.capturedVariables, getLocation),
+                            scope.boxedLoopVariables);
+  }
+
+  IrBuilder makeIRBuilder(ast.Node node, ExecutableElement element) {
+    if (isJavaScriptBackend) {
+      closureMap = compiler.closureToClassMapper.computeClosureToClassMapping(
+          element,
+          node,
+          elements);
+      return new JsIrBuilder(compiler.backend.constantSystem, element);
+    } else {
+      DetectClosureVariables closures = new DetectClosureVariables(elements);
+      if (!element.isSynthesized) {
+        closures.visit(node);
+      }
+      return new DartIrBuilder(compiler.backend.constantSystem,
+                               element,
+                               closures);
+    }
+  }
+
   /// Returns a [ir.FieldDefinition] describing the initializer of [element].
-  /// Returns `null` if [element] has no initializer.
   ir.FieldDefinition buildField(FieldElement element) {
     assert(invariant(element, element.isImplementation));
     ast.VariableDefinitions definitions = element.node;
     ast.Node fieldDefinition =
         definitions.definitions.nodes.first;
     if (definitions.modifiers.isConst) {
       // TODO(sigurdm): Just return const value.
     }
     assert(fieldDefinition != null);
     assert(elements[fieldDefinition] != null);
-    DetectClosureVariables closureLocals =
-    new DetectClosureVariables(elements);
-        closureLocals.visit(fieldDefinition);
 
-    IrBuilder builder = new IrBuilder(compiler.backend.constantSystem,
-        element,
-        closureLocals.usedFromClosure);
+    IrBuilder builder = makeIRBuilder(fieldDefinition, element);
+
     return withBuilder(builder, () {
+      builder.buildFieldInitializerHeader(
+          closureScope: getClosureScope(fieldDefinition));
       ir.Primitive initializer;
       if (fieldDefinition is ast.SendSet) {
         ast.SendSet sendSet = fieldDefinition;
         initializer = visit(sendSet.arguments.first);
       }
       return builder.makeFieldDefinition(initializer);
     });
   }
 
   ir.FunctionDefinition _makeFunctionBody(FunctionElement element,
                                           ast.FunctionExpression node) {
     FunctionSignature signature = element.functionSignature;
-    signature.orderedForEachParameter((ParameterElement parameterElement) {
-      irBuilder.createFunctionParameter(parameterElement);
-    });
+    List<ParameterElement> parameters = [];
+    signature.orderedForEachParameter(parameters.add);
+
+    irBuilder.buildFunctionHeader(parameters,
+                                  closureScope: getClosureScope(node),
+                                  closureEnvironment: getClosureEnvironment());
 
     List<ConstantExpression> defaults = new List<ConstantExpression>();
     signature.orderedOptionalParameters.forEach((ParameterElement element) {
       defaults.add(getConstantForVariable(element));
     });
 
     List<ir.Initializer> initializers;
     if (element.isSynthesized) {
       assert(element is ConstructorElement);
       return irBuilder.makeConstructorDefinition(const <ConstantExpression>[],
           const <ir.Initializer>[]);
     } else if (element.isGenerativeConstructor) {
       initializers = buildConstructorInitializers(node, element);
       visit(node.body);
       return irBuilder.makeConstructorDefinition(defaults, initializers);
     } else {
       visit(node.body);
       return irBuilder.makeFunctionDefinition(defaults);
     }
   }
 
   List<ir.Initializer> buildConstructorInitializers(
       ast.FunctionExpression function, ConstructorElement element) {
     List<ir.Initializer> result = <ir.Initializer>[];
     FunctionSignature signature = element.functionSignature;
 
     void tryAddInitializingFormal(ParameterElement parameterElement) {
       if (parameterElement.isInitializingFormal) {
         InitializingFormalElement initializingFormal = parameterElement;
-        withBuilder(new IrBuilder.delimited(irBuilder), () {
+        withBuilder(irBuilder.makeDelimitedBuilder(), () {
           ir.Primitive value = irBuilder.buildLocalGet(parameterElement);
           result.add(irBuilder.makeFieldInitializer(
               initializingFormal.fieldElement,
               irBuilder.makeRunnableBody(value)));
         });
       }
     }
 
     // TODO(sigurdm): Preserve initializing formals as initializing formals.
     signature.orderedForEachParameter(tryAddInitializingFormal);
 
     if (function.initializers == null) return result;
     bool explicitSuperInitializer = false;
     for(ast.Node initializer in function.initializers) {
       if (initializer is ast.SendSet) {
         // Field initializer.
         FieldElement field = elements[initializer];
-        withBuilder(new IrBuilder.delimited(irBuilder), () {
+        withBuilder(irBuilder.makeDelimitedBuilder(), () {
           ir.Primitive value = visit(initializer.arguments.head);
           ir.RunnableBody body = irBuilder.makeRunnableBody(value);
           result.add(irBuilder.makeFieldInitializer(field, body));
         });
       } else if (initializer is ast.Send) {
         // Super or this initializer.
         if (ast.Initializers.isConstructorRedirect(initializer)) {
           giveup(initializer, "constructor redirect (this) initializer");
         }
         ConstructorElement constructor = elements[initializer].implementation;
         Selector selector = elements.getSelector(initializer);
         List<ir.RunnableBody> arguments =
             initializer.arguments.mapToList((ast.Node argument) {
-          return withBuilder(new IrBuilder.delimited(irBuilder), () {
+          return withBuilder(irBuilder.makeDelimitedBuilder(), () {
             ir.Primitive value = visit(argument);
             return irBuilder.makeRunnableBody(value);
           });
         });
         result.add(irBuilder.makeSuperInitializer(constructor,
                                                   arguments,
                                                   selector));
         explicitSuperInitializer = true;
       } else {
         compiler.internalError(initializer,
@@ skipping 23 matching lines @@
   }
 
   ir.FunctionDefinition buildFunction(FunctionElement element) {
     assert(invariant(element, element.isImplementation));
     ast.FunctionExpression node = element.node;
 
     Iterable<Entity> usedFromClosure;
     if (!element.isSynthesized) {
       assert(node != null);
       assert(elements[node] != null);
-
-      // TODO(karlklose): this information should be provided by resolution.
-      DetectClosureVariables closureLocals =
-          new DetectClosureVariables(elements);
-      closureLocals.visit(node);
-      usedFromClosure = closureLocals.usedFromClosure;
     } else {
       SynthesizedConstructorElementX constructor = element;
       if (!constructor.isDefaultConstructor) {
         giveup(null, 'cannot handle synthetic forwarding constructors');
       }
 
       usedFromClosure = <Entity>[];
     }
 
-    IrBuilder builder = new IrBuilder(compiler.backend.constantSystem,
-                                      element,
-                                      usedFromClosure);
+    IrBuilder builder = makeIRBuilder(node, element);
 
     return withBuilder(builder, () => _makeFunctionBody(element, node));
   }
 
   ir.Primitive visit(ast.Node node) => node.accept(this);
 
   // ==== Statements ====
   visitBlock(ast.Block node) {
     irBuilder.buildBlock(node.statements.nodes, build);
   }
@@ skipping 20 matching lines @@
 
   // Build(ExpressionStatement(e), C) = C'
   //   where (C', _) = Build(e, C)
   ir.Primitive visitExpressionStatement(ast.ExpressionStatement node) {
     assert(irBuilder.isOpen);
     visit(node.expression);
     return null;
   }
 
   visitFor(ast.For node) {
-    // TODO(kmillikin,sigurdm): Handle closure variables declared in a for-loop.
-    if (node.initializer is ast.VariableDefinitions) {
+    // TODO(asgerf): Handle closure variables declared in a for-loop.
+    if (!isJavaScriptBackend && node.initializer is ast.VariableDefinitions) {
       ast.VariableDefinitions definitions = node.initializer;
       for (ast.Node definition in definitions.definitions.nodes) {
-        Element element = elements[definition];
-        if (irBuilder.isClosureVariable(element)) {
+        LocalElement element = elements[definition];
+        DartIrBuilder dartIrBuilder = irBuilder;
+        if (dartIrBuilder.isInClosureVariable(element)) {
           return giveup(definition, 'Closure variable in for loop initializer');
         }
       }
     }
 
     JumpTarget target = elements.getTargetDefinition(node);
     irBuilder.buildFor(
         buildInitializer: subbuild(node.initializer),
         buildCondition: subbuild(node.condition),
         buildBody: subbuild(node.body),
         buildUpdate: subbuildSequence(node.update),
+        closureScope: getClosureScope(node),
         target: target);
   }
 
   visitIf(ast.If node) {
     irBuilder.buildIf(
         build(node.condition),
         subbuild(node.thenPart),
         subbuild(node.elsePart));
   }
 
   ir.Primitive visitLabeledStatement(ast.LabeledStatement node) {
     ast.Statement body = node.statement;
     if (body is ast.Loop) return visit(body);
     JumpTarget target = elements.getTargetDefinition(body);
     JumpCollector jumps = new JumpCollector(target);
     irBuilder.state.breakCollectors.add(jumps);
-    IrBuilder innerBuilder = new IrBuilder.delimited(irBuilder);
+    IrBuilder innerBuilder = irBuilder.makeDelimitedBuilder();
     withBuilder(innerBuilder, () {
       visit(body);
     });
     irBuilder.state.breakCollectors.removeLast();
     bool hasBreaks = !jumps.isEmpty;
     ir.Continuation joinContinuation;
     if (hasBreaks) {
       if (innerBuilder.isOpen) {
         jumps.addJump(innerBuilder);
       }
@@ skipping 20 matching lines @@
         irBuilder.environment = innerBuilder.environment;
       }
     }
     return null;
   }
 
   visitWhile(ast.While node) {
     irBuilder.buildWhile(
         buildCondition: subbuild(node.condition),
         buildBody: subbuild(node.body),
-        target: elements.getTargetDefinition(node));
+        target: elements.getTargetDefinition(node),
+        closureScope: getClosureScope(node));
   }
 
   visitForIn(ast.ForIn node) {
     // [node.declaredIdentifier] can be either an [ast.VariableDefinitions]
     // (defining a new local variable) or a send designating some existing
     // variable.
     ast.Node identifier = node.declaredIdentifier;
     ast.VariableDefinitions variableDeclaration =
         identifier.asVariableDefinitions();
     Element variableElement = elements.getForInVariable(node);
     Selector selector = elements.getSelector(identifier);
 
     irBuilder.buildForIn(
         buildExpression: subbuild(node.expression),
         buildVariableDeclaration: subbuild(variableDeclaration),
         variableElement: variableElement,
         variableSelector: selector,
         buildBody: subbuild(node.body),
-        target: elements.getTargetDefinition(node));
+        target: elements.getTargetDefinition(node),
+        closureScope: getClosureScope(node));
   }
 
   ir.Primitive visitVariableDefinitions(ast.VariableDefinitions node) {
     assert(irBuilder.isOpen);
     if (node.modifiers.isConst) {
       for (ast.SendSet definition in node.definitions.nodes) {
         assert(!definition.arguments.isEmpty);
         assert(definition.arguments.tail.isEmpty);
         VariableElement element = elements[definition];
         ConstantExpression value = getConstantForVariable(element);
@@ skipping 490 matching lines @@
   }
 
   ir.Primitive translateConstant(ast.Node node, [ConstantExpression constant]) {
     assert(irBuilder.isOpen);
     if (constant == null) {
       constant = getConstantForNode(node);
     }
     return irBuilder.buildConstantLiteral(constant);
   }
 
-  ir.FunctionDefinition makeSubFunction(ast.FunctionExpression node) {
-    FunctionElement element = elements[node];
-    assert(invariant(element, element.isImplementation));
+  /// Returns the backend-specific representation of an inner function.
+  Object makeSubFunction(ast.FunctionExpression node) {
+    if (isJavaScriptBackend) {
+      ClosureClassMap innerMap =
+          compiler.closureToClassMapper.getMappingForNestedFunction(node);
+      ClosureClassElement closureClass = innerMap.closureClassElement;
+      return closureClass;
+    } else {
+      FunctionElement element = elements[node];
+      assert(invariant(element, element.isImplementation));
 
-    IrBuilder builder = new IrBuilder.innerFunction(irBuilder, element);
+      IrBuilder builder = irBuilder.makeInnerFunctionBuilder(element);
 
-    return withBuilder(builder, () => _makeFunctionBody(element, node));
+      return withBuilder(builder, () => _makeFunctionBody(element, node));
+    }
   }
 
   ir.Primitive visitFunctionExpression(ast.FunctionExpression node) {
     return irBuilder.buildFunctionExpression(makeSubFunction(node));
   }
 
   visitFunctionDeclaration(ast.FunctionDeclaration node) {
     LocalFunctionElement element = elements[node.function];
-    ir.FunctionDefinition inner = makeSubFunction(node.function);
+    Object inner = makeSubFunction(node.function);
     irBuilder.declareLocalFunction(element, inner);
   }
 
   static final String ABORT_IRNODE_BUILDER = "IrNode builder aborted";
 
   dynamic giveup(ast.Node node, [String reason]) {
     throw ABORT_IRNODE_BUILDER;
   }
 
   ir.ExecutableDefinition nullIfGiveup(ir.ExecutableDefinition action()) {
     try {
       return action();
     } catch(e, tr) {
       if (e == ABORT_IRNODE_BUILDER) {
         return null;
       }
       rethrow;
     }
   }
 
   void internalError(String reason, {ast.Node node}) {
     giveup(node);
   }
 }
 
 /// Classifies local variables and local functions as 'closure variables'.
 /// A closure variable is one that is accessed from an inner function nested
 /// one or more levels inside the one that declares it.
-class DetectClosureVariables extends ast.Visitor {
+class DetectClosureVariables extends ast.Visitor
+                             implements ClosureVariableInfo {
   final TreeElements elements;
   DetectClosureVariables(this.elements);
 
   FunctionElement currentFunction;
   bool insideInitializer = false;
-  Set<Local> usedFromClosure = new Set<Local>();
-  Set<FunctionElement> recursiveFunctions = new Set<FunctionElement>();
-
-  bool isClosureVariable(Entity entity) => usedFromClosure.contains(entity);
+  Set<Local> capturedVariables = new Set<Local>();
 
   void markAsClosureVariable(Local local) {
-    usedFromClosure.add(local);
+    capturedVariables.add(local);
   }
 
   visit(ast.Node node) => node.accept(this);
 
   visitNode(ast.Node node) {
     node.visitChildren(this);
   }
 
   void handleSend(ast.Send node) {
     Element element = elements[node];
@@ skipping 34 matching lines @@
     currentFunction = elements[node];
     if (node.initializers != null) {
       insideInitializer = true;
       visit(node.initializers);
       insideInitializer = false;
     }
     visit(node.body);
     currentFunction = oldFunction;
   }
 }