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

lib/compiler/implementation/ssa/codegen_helpers.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.
 
 /**
  * Instead of emitting each SSA instruction with a temporary variable
  * mark instructions that can be emitted at their use-site.
  * For example, in:
  *   t0 = 4;
  *   t1 = 3;
@@ skipping 218 matching lines @@
 
     // We check that the structure is the following:
     //         If
     //       /    \
     //      /      \
     //   1 expr    goto
     //    goto     /
     //      \     /
     //       \   /
     // phi(expr, true|false)
+    //
+    // and the same for nested nodes:
+    //
+    //            If
+    //          /    \
+    //         /      \
+    //      1 expr1    \
+    //       If         \
+    //      /  \         \
+    //     /    \         goto
+    //  1 expr2            |
+    //    goto    goto     |
+    //      \     /        |
+    //       \   /         |
+    //   phi1(expr2, true|false)
+    //          \          |
+    //           \         |
+    //             phi(phi1, true|false)
+
     if (end == null) return;
     if (end.phis.isEmpty()) return;
     if (end.phis.first !== end.phis.last) return;
     HBasicBlock elseBlock = startIf.elseBlock;
 
     if (end.predecessors[1] !== elseBlock) return;
     HPhi phi = end.phis.first;
     HInstruction thenInput = phi.inputs[0];
     HInstruction elseInput = phi.inputs[1];
     if (thenInput.isStatement || elseInput.isStatement) return;
 
     if (hasAnyStatement(elseBlock, elseInput)) return;
     assert(elseBlock.successors.length == 1);
     assert(end.predecessors.length == 2);
 
     HBasicBlock thenBlock = startIf.thenBlock;
     // Skip trivial goto blocks.
     while (thenBlock.successors[0] != end && thenBlock.first is HGoto) {
       thenBlock = thenBlock.successors[0];
     }
 
     // If the [thenBlock] is already a control flow operation, and does not
     // have any statement and its join block is [end], we can emit a
     // sequence of control flow operation.
     if (controlFlowOperators.contains(thenBlock.last)) {
       HIf otherIf = thenBlock.last;
-      if (otherIf.joinBlock !== end) return;
+      if (otherIf.joinBlock !== end) {
+        // This could be a join block that just feeds into our join block.
+        HBasicBlock otherJoin = otherIf.joinBlock;
+        if (otherJoin.successors.length != 1) return;
+        if (otherJoin.successors[0] != end) return;
+        if (otherJoin.phis.isEmpty()) return;
+        if (otherJoin.phis.first !== otherJoin.phis.last) return;
+        HPhi otherPhi = otherJoin.phis.first;
+        if (thenInput != otherPhi) return;
+        if (elseInput != otherPhi.inputs[1]) return;
+      }
       if (hasAnyStatement(thenBlock, otherIf)) return;
     } else {
       if (end.predecessors[0] !== thenBlock) return;
       if (hasAnyStatement(thenBlock, thenInput)) return;
       assert(thenBlock.successors.length == 1);
     }
 
     // From now on, we have recognized a control flow operation built from
     // the builder. Mark the if instruction as such.
     controlFlowOperators.add(startIf);
@@ skipping 94 matching lines @@
   };
 }
 
 class JSBinaryOperatorPrecedence {
   final int left;
   final int right;
   const JSBinaryOperatorPrecedence(this.left, this.right);
   // All binary operators (excluding assignment) are left associative.
   int get precedence() => left;
 }