Safety analysis for JS template placeholders.

pkg/compiler/lib/src/tree_ir/optimization/statement_rewriter.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.optimization.statement_rewriter;
 
 import 'optimization.dart' show Pass;
 import '../tree_ir_nodes.dart';
 import '../../io/source_information.dart';
 import '../../elements/elements.dart';
+import '../../js/placeholder_safety.dart';
 
 /**
  * Translates to direct-style.
  *
  * In addition to the general IR constraints (see [CheckTreeIntegrity]),
  * the input is assumed to satisfy the following criteria:
  *
  * All expressions other than those nested in [Assign] or [ExpressionStatement]
  * must be simple. A [VariableUse] and [This] is a simple expression.
  * The right-hand of an [Assign] may not be an [Assign].
@@ skipping 1112 matching lines @@
 
   Expression makeCondition(Expression e, bool polarity) {
     return polarity ? e : new Not(e);
   }
 
   Statement getBranch(If node, bool polarity) {
     return polarity ? node.thenStatement : node.elseStatement;
   }
 
   void handleForeignCode(ForeignCode node) {
-    // Arguments will get inserted in a JS code template.  The arguments will
-    // not always be evaluated (e.g. if the template is '# && #').
-    // TODO(asgerf): We could analyze the JS AST to see if arguments are
-    //               definitely evaluated left-to-right.
+    // Some arguments will get inserted in a JS code template.  The arguments
+    // will not always be evaluated (e.g. the second placeholder in the template
+    // '# && #').
+
+    // TODO(sra): Find out which tree_ir expressions are not nullable. It helps
+    // a lot with templates like '#.push(#)'.
+    bool isNullable(e) => true;
+
+    int safeArguments =
+      PlaceholderSafetyAnalysis.analyze(node.codeTemplate.ast, isNullable);
     inEmptyEnvironment(() {
-      _rewriteList(node.arguments);
+      for (int i = node.arguments.length - 1; i >= safeArguments; --i) {
+        node.arguments[i] = visitExpression(node.arguments[i]);
+      }
     });
+    for (int i = safeArguments - 1; i >= 0; --i) {
+      node.arguments[i] = visitExpression(node.arguments[i]);
+    }
   }
 
   @override
   Expression visitForeignExpression(ForeignExpression node) {
     handleForeignCode(node);
     return node;
   }
 
   @override
   Statement visitForeignStatement(ForeignStatement node) {
@@ skipping 99 matching lines @@
   VariableUseCallback callback;
 
   VariableUseVisitor(this.callback);
 
   visitVariableUse(VariableUse use) => callback(use);
 
   static void visit(Expression node, VariableUseCallback callback) {
     new VariableUseVisitor(callback).visitExpression(node);
   }
 }