Support assignment to parameters in the dart2dart backend.

sdk/lib/_internal/compiler/implementation/dart_backend/dart_tree.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 dart_tree;
 
 import '../dart2jslib.dart' as dart2js;
 import '../dart_types.dart';
 import '../util/util.dart';
 import '../elements/elements.dart'
@@ skipping 71 matching lines @@
   accept(Visitor visitor) => visitor.visitSequence(this);
 }
 
 /**
  * A local binding of a [Variable] to an [Expression].
  *
  * In contrast to the CPS-based IR, non-primitive expressions can be named
  * with let.
  */
 class LetVal extends Expression {
+  final bool hasExactlyOneUse;
   final Variable variable;
-  final Expression definition;
-  final Expression body;
+  Expression definition;
+  Expression body;
 
-  LetVal(this.variable, this.definition, this.body);
+  LetVal(this.hasExactlyOneUse, this.variable, this.definition, this.body);

[floitsch, 2014/04/10 17:24:46]

I would put this last. It seems less important than the variable, definition and
the body.

[Kevin Millikin (Google), 2014/04/11 08:31:23]

Good reason, done.

 
   bool get isPure => definition.isPure && body.isPure;
 
   accept(Visitor visitor) => visitor.visitLetVal(this);
 }
 
 /**
  * A call to a static target.
  *
  * In contrast to the CPS-based IR, the arguments can be arbitrary expressions.
@@ skipping 129 matching lines @@
     function = new FunctionDefinition(parameters, node.body.accept(this));
     return null;
   }
 
   Expression visitLetPrim(ir.LetPrim node) {
     // LetPrim is translated to LetVal.
     Expression definition = node.primitive.accept(this);
     if (node.primitive.hasAtLeastOneUse) {
       Variable variable = new Variable(null);
       variables[node.primitive] = variable;
-      return new LetVal(variable, definition, node.body.accept(this));
+      return new LetVal(node.primitive.hasExactlyOneUse, variable,
+          definition, node.body.accept(this));
     } else {
       return new Sequence([definition, node.body.accept(this)]);
     }
   }
 
   Expression visitLetCont(ir.LetCont node) {
     // TODO(kmillikin): Allow continuations to have multiple uses.  This could
     // arise due to the representation of local control flow or due to
     // optimization.
     assert(node.continuation.hasAtMostOneUse);
     return node.body.accept(this);
   }
 
   Expression visitInvokeStatic(ir.InvokeStatic node) {
     // Calls are translated to direct style.
     List<Expression> arguments = translateArguments(node.arguments);
     Expression invoke = new InvokeStatic(node.target, arguments);
     ir.Continuation cont = node.continuation.definition;
     if (cont == returnContinuation) {
       return new Return(invoke);
     } else {
       assert(cont.hasExactlyOneUse);
       if (cont.parameter.hasAtLeastOneUse) {
         Variable variable = new Variable(null);
         variables[cont.parameter] = variable;
-        return new LetVal(variable, invoke, cont.body.accept(this));
+        return new LetVal(cont.parameter.hasExactlyOneUse, variable,
+            invoke, cont.body.accept(this));
       } else {
         return new Sequence([invoke, cont.body.accept(this)]);
       }
     }
   }
 
   Expression visitInvokeContinuation(ir.InvokeContinuation node) {
     // TODO(kmillikin): Support non-return continuations.  These could arise
     // due to local control flow or due to inlining or other optimization.
     assert(node.continuation.definition == returnContinuation);
@@ skipping 63 matching lines @@
 
     // TODO(kmillikin): It's not always beneficial to propagate pure
     // definitions---it can prevent propagation of their inputs.  Implement
     // a heuristic to avoid this.
 
     // TODO(kmillikin): Replace linear search with something faster in
     // practice.
     bool seenImpure = false;
     for (int i = environment.length - 1; i >= 0; --i) {
       if (environment[i].variable == node) {
-        if (!seenImpure || environment[i].definition.isPure) {
+        if ((!seenImpure || environment[i].definition.isPure)
+            && environment[i].hasExactlyOneUse) {
           // Use the definition if it is pure or if it is the first impure
           // definition (i.e., propagating past only pure expressions).
           return environment.removeAt(i).definition.accept(this);
         }
         break;
       } else if (!environment[i].definition.isPure) {
         // Once the first impure definition is seen, impure definitions should
         // no longer be propagated.  Continue searching for a pure definition.
         seenImpure = true;
       }
     }
     // If the definition could not be propagated, leave the variable use.
     return node;
   }
 
   Expression visitSequence(Sequence node) {
     for (int i = 0; i < node.expressions.length; ++i) {
       node.expressions[i] = node.expressions[i].accept(this);
     }
     return node;
   }
 
   Expression visitLetVal(LetVal node) {
     environment.add(node);
     Expression body = node.body.accept(this);
 
-    // TODO(kmillikin): Allow definitions that are not propagated.  Currently,
-    // the only bindings are anonymous intermediate values (which only have one
-    // use in the absence of optimizations) and they are not reordered.
+    if (!environment.isEmpty && environment.last == node) {
+      // The definition could not be propagated.  Residualize the let binding.
+      node.body = body;
+      environment.removeLast();
+      node.definition = node.definition.accept(this);
+      return node;
+    }
     assert(!environment.contains(node));
     return body;
   }
 
   Expression visitInvokeStatic(InvokeStatic node) {
     // Process arguments right-to-left, the opposite of evaluation order.
     for (int i = node.arguments.length - 1; i >= 0; --i) {
       node.arguments[i] = node.arguments[i].accept(this);
     }
     return node;
@@ skipping 349 matching lines @@
   }
 
   ast.Expression visitInterceptor(dart2js.InterceptorConstant constant) {
     return unimplemented();
   }
 
   ast.Expression visitDummy(dart2js.DummyConstant constant) {
     return unimplemented();
   }
 }