Avoid generating empty else.

lib/compiler/implementation/ssa/codegen.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 SsaCodeGeneratorTask extends CompilerTask {
   final JavaScriptBackend backend;
   SsaCodeGeneratorTask(JavaScriptBackend backend)
       : this.backend = backend,
         super(backend.compiler);
   String get name() => 'SSA code generator';
@@ skipping 531 matching lines @@
       }
     } else {
       generateStatements(info.condition);
       addIndented("if (");
       use(condition, JSPrecedence.EXPRESSION_PRECEDENCE);
       buffer.add(") {\n");
       indent++;
       generateStatements(info.thenGraph);
       indent--;
       addIndented("}");
-      if (info.elseGraph !== null) {
+      HSubGraphBlockInformation elseGraph = info.elseGraph;
+      if (elseGraph !== null && !isEmptyElse(elseGraph.start, elseGraph.end)) {
         buffer.add(" else {\n");
         indent++;
-        generateStatements(info.elseGraph);
+        generateStatements(elseGraph);
         indent--;
         addIndented("}");
       }
       buffer.add("\n");
     }
     return true;
   }
 
   bool visitSequenceInfo(HStatementSequenceInformation info) {
     return false;
@@ skipping 678 matching lines @@
     }
   }
 
   visitTry(HTry node) {
     // We should never get here. Try/catch/finally is always handled using block
     // information in [visitTryInfo], or not at all, in the case of the bailout
     // generator.
     compiler.internalError('visitTry should not be called', instruction: node);
   }
 
+  bool isEmptyElse(HBasicBlock start, HBasicBlock end) {
+    if (start !== end) return false;
+    if (start.last is !HGoto
+        || start.last is HBreak
+        || start.last is HContinue) {
+      return false;
+    }
+    HInstruction instruction = start.first;
+    for (HInstruction instruction = start.first;
+         instruction != start.last;
+         instruction = instruction.next) {
+      // Instructions generated at use site are okay because they do
+      // not generate code in this else block.
+      if (!isGenerateAtUseSite(instruction)) return false;
+    }
+    CopyHandler handler = variableNames.getCopyHandler(start);
+    if (handler == null || handler.isEmpty()) return true;
+    if (!handler.assignments.isEmpty()) return false;
+    // If the block has a copy where the destination and source are
+    // different, we will emit that copy, and therefore the block is
+    // not empty.
+    for (Copy copy in handler.copies) {
+      String sourceName = variableNames.getName(copy.source);
+      String destinationName = variableNames.getName(copy.destination);
+      if (sourceName != destinationName) return false;
+    }
+    return true;
+  }
+
   visitIf(HIf node) {
     if (subGraph !== null && node.block === subGraph.end) {
       if (isGeneratingExpression()) {
         use(node.inputs[0], JSPrecedence.EXPRESSION_PRECEDENCE);
       }
       return;
     }
     HInstruction condition = node.inputs[0];
     int preVisitedBlocks = 0;
     List<HBasicBlock> dominated = node.block.dominatedBlocks;
     HIfBlockInformation info = node.blockInformation.body;
+    HBasicBlock joinBlock = node.joinBlock;
     if (condition.isConstant()) {
       HConstant constant = condition;
       if (constant.constant.isTrue()) {
         generateStatements(info.thenGraph);
       } else if (node.hasElse) {
         generateStatements(info.elseGraph);
       }
       // We ignore the other branch, even if it isn't visited.
       preVisitedBlocks = node.hasElse ? 2 : 1;
     } else {
       startIf(node);
       assert(!isGenerateAtUseSite(node));
       startThen(node);
       assert(node.thenBlock === dominated[0]);
       generateStatements(info.thenGraph);
       preVisitedBlocks++;
       endThen(node);
-      if (node.hasElse) {
+      HBasicBlock endBlock =
+          (joinBlock == null || joinBlock.predecessors.length != 2)
+              ? null
+              : joinBlock.predecessors[1];
+      if (node.hasElse && !isEmptyElse(node.elseBlock, endBlock)) {
         startElse(node);
         assert(node.elseBlock === dominated[1]);
         generateStatements(info.elseGraph);
         preVisitedBlocks++;
         endElse(node);
       }
       endIf(node);
     }
-    HBasicBlock joinBlock = node.joinBlock;
     if (joinBlock !== null && joinBlock.dominator !== node.block) {
       // The join block is dominated by a block in one of the branches.
       // The subgraph traversal never reached it, so we visit it here
       // instead.
       visitBasicBlock(joinBlock);
     }
 
     // Visit all the dominated blocks that are not part of the then or else
     // branches, and is not the join block.
     // Depending on how the then/else branches terminate
@@ skipping 1167 matching lines @@
       startBailoutSwitch();
     }
   }
 
   void endLabeledBlock(HLabeledBlockInformation labeledBlockInfo) {
     if (labeledBlockInfo.body.start.hasGuards()) {
       endBailoutSwitch();
     }
   }
 }