dart2js cps: Fix bug in liveness analysis.

pkg/compiler/lib/src/tree_ir/optimization/variable_merger.dart

 // Copyright (c) 2015, 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.variable_merger;
 
 import 'optimization.dart' show Pass;
 import '../tree_ir_nodes.dart';
 
 /// Merges variables based on liveness and source variable information.
@@ skipping 115 matching lines @@
     Block block = new Block(catchBlock);
     blocks.add(block);
     return block;
   }
 
   /// Starts a new block after the end of [block].
   void branchFrom(Block block, {Block catchBlock}) {
     _currentBlock = newBlock(catchBlock: catchBlock)..predecessors.add(block);
   }
 
+  /// Starts a new block with the given blocks as predecessors.
+  void joinFrom(Block block1, Block block2) {
+    assert(block1.catchBlock == block2.catchBlock);
+    _currentBlock = newBlock(catchBlock: block1.catchBlock);
+    _currentBlock.predecessors.add(block1);
+    _currentBlock.predecessors.add(block2);
+  }
+
   /// Called when reading from [variable].
   ///
   /// Appends a read operation to the current basic block.
   void read(Variable variable) {
     if (variable.isCaptured) return;
     if (_ignoredVariables.contains(variable)) return;
     _currentBlock.addRead(variable);
   }
 
   /// Called when writing to [variable].
@@ skipping 19 matching lines @@
   visitAssign(Assign node) {
     visitExpression(node.value);
     write(node.variable);
   }
 
   visitIf(If node) {
     visitExpression(node.condition);
     Block afterCondition = _currentBlock;
     branchFrom(afterCondition);
     visitStatement(node.thenStatement);
+    Block afterThen = _currentBlock;
     branchFrom(afterCondition);
     visitStatement(node.elseStatement);
+    joinFrom(_currentBlock, afterThen);
   }
 
   visitLabeledStatement(LabeledStatement node) {
     Block join = _jumpTarget[node.label] = newBlock();
     visitStatement(node.body); // visitBreak will add predecessors to join.
     _currentBlock = join;
     visitStatement(node.next);
   }
 
   visitBreak(Break node) {
@@ skipping 17 matching lines @@
     _currentBlock = join;
     visitExpression(node.condition);
     Block afterCondition = _currentBlock;
     branchFrom(afterCondition);
     visitStatement(node.body); // visitContinue will add predecessors to join.
     branchFrom(afterCondition);
     visitStatement(node.next);
   }
 
   visitTry(Try node) {
-    Block catchBlock = newBlock();
+    Block outerCatchBlock = _currentBlock.catchBlock;
+    Block catchBlock = newBlock(catchBlock: outerCatchBlock);
     branchFrom(_currentBlock, catchBlock: catchBlock);
     visitStatement(node.tryBody);
+    Block afterTry = _currentBlock;
     _currentBlock = catchBlock;
     // Catch parameters cannot be hoisted to the top of the function, so to
     // avoid complications with scoping, we do not attempt to merge them.
     node.catchParameters.forEach(ignoreVariable);
     visitStatement(node.catchBody);
+    Block afterCatch = _currentBlock;
+    _currentBlock = newBlock(catchBlock: outerCatchBlock);
+    _currentBlock.predecessors.add(afterCatch);
+    _currentBlock.predecessors.add(afterTry);
   }
 
   visitConditional(Conditional node) {
     visitExpression(node.condition);
     Block afterCondition = _currentBlock;
     branchFrom(afterCondition);
     visitExpression(node.thenExpression);
+    Block afterThen = _currentBlock;
     branchFrom(afterCondition);
     visitExpression(node.elseExpression);
+    joinFrom(_currentBlock, afterThen);
   }
 
   visitLogicalOperator(LogicalOperator node) {
     visitExpression(node.left);
-    Block afterCondition = _currentBlock;
-    branchFrom(afterCondition);
+    Block afterLeft = _currentBlock;
+    branchFrom(afterLeft);
     visitExpression(node.right);
+    joinFrom(_currentBlock, afterLeft);
   }
 }
 
 /// Computes liveness information of the given control-flow graph.
 ///
 /// The results are stored in [Block.liveIn] and [Block.liveOut].
 void _computeLiveness(List<Block> blocks) {
   // We use a LIFO queue as worklist. Blocks are given in AST order, so by
   // inserting them in this order, we initially visit them backwards, which
   // is a good ordering.
@@ skipping 69 matching lines @@
           pred.inWorklist = true;
         }
       }
     }
   }
 }
 
 /// For testing purposes, this flag can be passed to merge variables that
 /// originated from different source variables.
 ///
-/// Correctness should not depend on the fact that we only merge variable
+/// Correctness should not depend on the fact that we only merge variables
 /// originating from the same source variable. Setting this flag makes a bug
 /// more likely to provoke a test case failure.
 const bool NO_PRESERVE_VARS = const bool.fromEnvironment('NO_PRESERVE_VARS');
 
 /// Based on liveness information, computes a map of variable substitutions to
 /// merge variables.
 ///
 /// Constructs a register interference graph. This is an undirected graph of
 /// variables, with an edge between two variables if they cannot be merged
 /// (because they are live simultaneously).
@@ skipping 81 matching lines @@
     List<Variable> register = registers[group(v1)];
 
     // Optimization: For the first variable in a group, allocate a new color
     // without iterating over its interference edges.
     if (register == null) {
       registers[group(v1)] = <Variable>[v1];
       subst[v1] = v1;
       continue;
     }
 
-    // Optimization: If there are no inteference edges for this variable,
+    // Optimization: If there are no interference edges for this variable,
     // assign it the first color without copying the register list.
     Set<Variable> interferenceSet = interference[v1];
     if (interferenceSet.isEmpty) {
       subst[v1] = register[0];
       continue;
     }
 
     // Find an unused color.
     Set<Variable> potential = new Set<Variable>.from(register);
     for (Variable v2 in interferenceSet) {
@@ skipping 76 matching lines @@
     node.expression = visitExpression(node.expression);
     node.next = visitStatement(node.next);
     if (node.expression is VariableUse) {
       VariableUse use = node.expression;
       --use.variable.readCount;
       return node.next;
     }
     return node;
   }
 }