Assignment expressions in tree IR.

pkg/compiler/lib/src/tree_ir/tree_ir_builder.dart

 // Copyright (c) 2014, 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 tree_ir_builder;
 
 import '../dart2jslib.dart' as dart2js;
 import '../dart_types.dart';
 import '../elements/elements.dart';
 import '../cps_ir/cps_ir_nodes.dart' as cps_ir;
@@ skipping 51 matching lines @@
   /// This is not safe if the code is moved inside the scope of an exception
   /// handler (i.e., into a try block).  We keep a stack of singly-referenced
   /// continuations that are in scope without crossing a binding for a handler.
   List<cps_ir.Continuation> safeForInlining = <cps_ir.Continuation>[];
 
   ExecutableElement currentElement;
   /// The 'this' Parameter for currentElement or the enclosing method.
   cps_ir.Parameter thisParameter;
   cps_ir.Continuation returnContinuation;
 
+  /// Number of loops enclosing the currently visited node.
+  int enclosingLoops = 0;
+
   Builder parent;
 
   Builder(this.internalError, [this.parent]);
 
   Builder createInnerBuilder() {
     return new Builder(internalError, this);
   }
 
   /// Variable used in [buildPhiAssignments] as a temporary when swapping
   /// variables.
@@ skipping 125 matching lines @@
   List<Expression> translateArguments(List<cps_ir.Reference> args) {
     return new List<Expression>.generate(args.length,
          (int index) => getVariableUse(args[index]),
          growable: false);
   }
 
   Statement buildContinuationAssignment(
       cps_ir.Parameter parameter,
       Expression argument,
       Statement buildRest()) {
-    Statement assignment;
+    Expression expr;
     if (parameter.hasAtLeastOneUse) {
-      Variable variable = getVariable(parameter);
-      assignment = new Assign(variable, argument, null);
+      expr = new Assign(getVariable(parameter), argument);
     } else {
-      assignment = new ExpressionStatement(argument, null);
+      expr = argument;
     }
-    assignment.next = buildRest();
-    return assignment;
+    return new ExpressionStatement(expr, buildRest());
   }
 
   /// Simultaneously assigns each argument to the corresponding parameter,
   /// then continues at the statement created by [buildRest].
   Statement buildPhiAssignments(
       List<cps_ir.Parameter> parameters,
       List<Expression> arguments,
       Statement buildRest()) {
     assert(parameters.length == arguments.length);
     // We want a parallel assignment to all parameters simultaneously.
@@ skipping 21 matching lines @@
         }
         list.add(i);
       } else {
         // v1 = this;
       }
     }
 
     Statement first, current;
     void addAssignment(Variable dst, Expression src) {
       if (first == null) {
-        first = current = new Assign(dst, src, null);
+        first = current = Assign.makeStatement(dst, src);
       } else {
-        current = current.next = new Assign(dst, src, null);
+        current = current.next = Assign.makeStatement(dst, src);
       }
     }
 
     List<Expression> assignmentSrc = new List<Expression>(parameters.length);
     List<bool> done = new List<bool>.filled(parameters.length, false);
     void visitAssignment(int i) {
       if (done[i]) {
         return;
       }
       Variable param = getVariable(parameters[i]);
@@ skipping 84 matching lines @@
     if (variable == null) return visit(node.body);
 
     Node definition = visit(node.primitive);
 
     // visitPrimitive returns a Statement without successor if it cannot occur
     // in expression context (currently only the case for FunctionDeclarations).
     if (definition is Statement) {
       definition.next = visit(node.body);
       return definition;
     } else {
-      return new Assign(variable, definition, visit(node.body));
+      return Assign.makeStatement(variable, definition, visit(node.body));
     }
   }
 
   Statement visitBody(cps_ir.Body node) {
     return visit(node.body);
   }
 
   Statement visitLetCont(cps_ir.LetCont node) {
     // Introduce labels for continuations that need them.
     int safeForInliningLengthOnEntry = safeForInlining.length;
@@ skipping 82 matching lines @@
           nextBuilder);
     }
   }
 
   Statement visitLetMutable(cps_ir.LetMutable node) {
     Variable variable = addMutableVariable(node.variable);
     Expression value = getVariableUse(node.value);
     Statement body = visit(node.body);
     // If the variable was captured by an inner function in the body, this
     // must be declared here so we assign to a fresh copy of the variable.
-    bool needsDeclaration = variable.isCaptured;
-    return new Assign(variable, value, body, isDeclaration: needsDeclaration);
+    if (variable.isCaptured && enclosingLoops > 0) {
+      return new VariableDeclaration(variable, value, body);
+    }
+    return Assign.makeStatement(variable, value, body);
   }
 
   Expression visitGetMutableVariable(cps_ir.GetMutableVariable node) {
     return getMutableVariableUse(node.variable);
   }
 
   Statement visitSetMutableVariable(cps_ir.SetMutableVariable node) {
     Variable variable = getMutableVariable(node.variable.definition);
     Expression value = getVariableUse(node.value);
-    return new Assign(variable, value, visit(node.body));
+    return Assign.makeStatement(variable, value, visit(node.body));
   }
 
   Statement visitDeclareFunction(cps_ir.DeclareFunction node) {
     Variable variable = addMutableVariable(node.variable);
     FunctionDefinition function = makeSubFunction(node.definition);
     return new FunctionDeclaration(variable, function, visit(node.body));
   }
 
   Statement visitTypeOperator(cps_ir.TypeOperator node) {
     Expression receiver = getVariableUse(node.receiver);
@@ skipping 33 matching lines @@
             //       inline at the invocation site.
             //     - If there are multiple uses, translate to Break.
             //   * Recursive continuations
             //     - There is a single non-recursive invocation.  Translate
             //       the continuation body inline as a labeled loop at the
             //       invocation site.
             //     - Translate the recursive invocations to Continue.
             if (cont.isRecursive) {
               return node.isRecursive
                   ? new Continue(labels[cont])
-                  : new WhileTrue(labels[cont], visit(cont.body));
+                  : new WhileTrue(labels[cont], makeLoopBody(cont.body));
             } else {
               if (cont.hasExactlyOneUse) {
                 if (safeForInlining.contains(cont)) {
                   return visit(cont.body);
                 }
                 labels[cont] = new Label();
               }
               return new Break(labels[cont]);
             }
           });
     }
   }
 
+  Statement makeLoopBody(cps_ir.Expression body) {
+    ++enclosingLoops;
+    Statement result = visit(body);
+    --enclosingLoops;
+    return result;
+  }
+
   Statement visitBranch(cps_ir.Branch node) {
     Expression condition = visit(node.condition);
     Statement thenStatement, elseStatement;
     cps_ir.Continuation cont = node.trueContinuation.definition;
     assert(cont.parameters.isEmpty);
     thenStatement =
         cont.hasExactlyOneUse ? visit(cont.body) : new Break(labels[cont]);
     cont = node.falseContinuation.definition;
     assert(cont.parameters.isEmpty);
     elseStatement =
@@ skipping 74 matching lines @@
   }
 
   @override
   Node visitTypeExpression(cps_ir.TypeExpression node) {
     return new TypeExpression(
         node.dartType,
         node.arguments.map(getVariableUse).toList());
   }
 }