Transform (x && y) && z into x && (y && z).

lib/compiler/implementation/ssa/builder.dart

 // Copyright (c) 2012, 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.
 
 class Interceptors {
   Compiler compiler;
   Interceptors(Compiler this.compiler);
 
   SourceString mapOperatorToMethodName(Operator op) {
     String name = op.source.stringValue;
@@ skipping 1556 matching lines @@
   }
 
   void handleIf(Node diagnosticNode,
                 void visitCondition(), void visitThen(), void visitElse()) {
     SsaBranchBuilder branchBuilder = new SsaBranchBuilder(this, diagnosticNode);
     branchBuilder.handleIf(visitCondition, visitThen, visitElse);
   }
 
   void visitLogicalAndOr(Send node, Operator op) {
     SsaBranchBuilder branchBuilder = new SsaBranchBuilder(this, node);
-    branchBuilder.handleLogicalAndOr(
-        () { visit(node.receiver); },
+    branchBuilder.handleLogicalAndOrWithLeftNode(
+        node.receiver,
         () { visit(node.argumentsNode); },
         isAnd: (const SourceString("&&") == op.source));
   }
 
 
   void visitLogicalNot(Send node) {
     assert(node.argumentsNode is Prefix);
     visit(node.receiver);
     HNot not = new HNot(popBoolified());
     push(not);
@@ skipping 1860 matching lines @@
     }
 
     _handleDiamondBranch(visitCondition, visitThen, visitElse, false);
   }
 
   handleConditional(void visitCondition(), void visitThen(), void visitElse()) {
     assert(visitElse != null);
     _handleDiamondBranch(visitCondition, visitThen, visitElse, true);
   }
 
-  void handleLogicalAndOr(void left(), void right(), [bool isAnd = true]) {
+  void handleLogicalAndOr(void left(), void right(), [bool isAnd]) {
     // x && y is transformed into:
     //   t0 = boolify(x);
     //   if (t0) {
     //     t1 = boolify(y);
-    //   } else {
-    //     t2 = t0;
     //   }
     //   result = phi(t1, false);
     //
     // x || y is transformed into:
     //   t0 = boolify(x);
     //   if (not(t0)) {
     //     t1 = boolify(y);
-    //   } else {
-    //     t2 = t0;
     //   }
     //   result = phi(t1, true);
     HInstruction boolifiedLeft;
     HInstruction boolifiedRight;
 
     void visitCondition() {
       left();
       boolifiedLeft = builder.popBoolified();
-      HInstruction condition;
-      if (isAnd) {
-        condition = boolifiedLeft;
-      } else {
-        condition = new HNot(boolifiedLeft);
-        builder.add(condition);
+      builder.stack.add(boolifiedLeft);
+      if (!isAnd) {
+        builder.push(new HNot(builder.pop()));
       }
-      builder.stack.add(condition);
     }
 
     void visitThen() {
       right();
       boolifiedRight = builder.popBoolified();
     }
 
     handleIf(visitCondition, visitThen, null);
     HPhi result = new HPhi.manyInputs(null,
         <HInstruction>[boolifiedRight, builder.graph.addConstantBool(!isAnd)]);
     builder.current.addPhi(result);
     builder.stack.add(result);
   }
 
+  void handleLogicalAndOrWithLeftNode(Node left,
+                                      void visitRight(),
+                                      [bool isAnd]) {
+    // This method is similar to [handleLogicalAndOr] but optimizes the case
+    // where left is a logical "and" or logical "or".
+    //
+    // For example (x && y) && z is transformed into x && (y && z):
+    //   t0 = boolify(x);
+    //   if (t0) {
+    //     t1 = boolify(y);
+    //     if (t1) {
+    //       t2 = boolify(z);
+    //     }
+    //     t3 = phi(t2, false);
+    //   }
+    //   result = phi(t3, false);
+
+    Send send = left.asSend();
+    if (send !== null &&
+        (isAnd ? send.isLogicalAnd : send.isLogicalOr)) {
+      Node newLeft = send.receiver;
+      Link<Node> link = send.argumentsNode.nodes;
+      assert(link.tail.isEmpty());
+      Node middle = link.head;
+      handleLogicalAndOrWithLeftNode(
+          newLeft,
+          () => handleLogicalAndOrWithLeftNode(middle, visitRight, isAnd),
+          isAnd: isAnd);
+    } else {
+      handleLogicalAndOr(() => builder.visit(left), visitRight, isAnd);
+    }
+  }
+
   void _handleDiamondBranch(void visitCondition(),
                             void visitThen(),
                             void visitElse(),
                             bool isExpression) {
     SsaBranch conditionBranch = new SsaBranch(this);
     SsaBranch thenBranch = new SsaBranch(this);
     SsaBranch elseBranch = new SsaBranch(this);
     SsaBranch joinBranch = new SsaBranch(this);
 
     conditionBranch.startLocals = builder.localsHandler;
@@ skipping 29 matching lines @@
           new HSubGraphBlockInformation(elseBranch.graph));
 
     HBasicBlock conditionStartBlock = conditionBranch.block;
     conditionStartBlock.setBlockFlow(info, joinBlock);
     SubGraph conditionGraph = conditionBranch.graph;
     HIf branch = conditionGraph.end.last;
     assert(branch is HIf);
     branch.blockInformation = conditionStartBlock.blockFlow;
   }
 }