Revert r8800 some web tests are failing.

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 105 matching lines @@
   static final int STATE_EXPRESSION = 3;
   static final int STATE_DECLARATION = 4;
 
   /**
    * When analyzing a [HStatementGraph] we try to recognize if it has
    * the following properties.
    */
   static final int ONE_STATEMENT = 0;
   static final int ONE_EXPRESSION = 1;
   static final int EMPTY = 2;
-  static final int IF_STATEMENT = 3;
-  static final int MULTIPLE_STATEMENTS = 4;
+  static final int MULTIPLE_STATEMENTS = 3;
 
   /**
    * Returned by [expressionType] to tell how code can be generated for
    * a subgraph.
    * - [TYPE_STATEMENT] means that the graph must be generated as a statement,
    * which is always possible.
    * - [TYPE_EXPRESSION] means that the graph can be generated as an expression,
    * or possibly several comma-separated expressions.
    * - [TYPE_DECLARATION] means that the graph can be generated as an
    * expression, and that it only generates expressions of the form
@@ skipping 31 matching lines @@
    * Set of variables that have already been declared.
    */
   final Set<String> declaredVariables;
 
   Element equalsNullElement;
   Element boolifiedEqualsNullElement;
   int indent = 0;
   int expectedPrecedence = JSPrecedence.STATEMENT_PRECEDENCE;
   JSBinaryOperatorPrecedence unsignedShiftPrecedences;
   HGraph currentGraph;
-
   /**
    * Whether the code-generation should try to generate an expression
    * instead of a sequence of statements.
    */
   int generationState = STATE_STATEMENT;
-
-  /**
-   * Whether we are generating a statement that does not need
-   * indentation (e.g. an 'if' in an 'else if').
-   */
-  bool generatingInlineStatement = false;
-
   HBasicBlock currentBlock;
 
   // Records a block-information that is being handled specially.
   // Used to break bad recursion.
   HBlockInformation currentBlockInformation;
   // The subgraph is used to delimit traversal for some constructions, e.g.,
   // if branches.
   SubGraph subGraph;
 
   LibraryElement get currentLibrary() => work.element.getLibrary();
@@ skipping 1128 matching lines @@
     // information in [visitTryInfo], or not at all, in the case of the bailout
     // generator.
     compiler.internalError('visitTry should not be called', instruction: node);
   }
 
   /**
    * Analyzes the given [graph] to know whether it is empty, or
    * contains one statement, one expression, or multiple statements.
    */
   int analyzeGraphForCodegen(HStatementInformation graph) {
-    return analyzeBlocksForCodegen(graph.start, graph.end);
-  }
+    HBasicBlock start = graph.start;
+    HBasicBlock end = graph.end;
+    // Only deal with single blocks for now. TODO(ngeoffray): analyze
+    // all blocks.
+    if (start !== end) return MULTIPLE_STATEMENTS;
 
-  int analyzeBlocksForCodegen(HBasicBlock start, HBasicBlock end) {
     int kind = EMPTY;
     bool updateKind(int newKind) {
       if (kind != EMPTY) return false;
       kind = newKind;
       return true;
     }
 
     for (HInstruction instruction = start.first;
          instruction != start.last;
          instruction = instruction.next) {
       if (instruction.isStatement()) {
         if (!updateKind(ONE_STATEMENT)) return MULTIPLE_STATEMENTS;
       } else if (!isGenerateAtUseSite(instruction)) {
         if (!updateKind(ONE_EXPRESSION)) return MULTIPLE_STATEMENTS;
       }
     }
 
     HInstruction last = start.last;
-    if (last is HGoto) {
-      if (start !== end) {
-        int nextKind = analyzeBlocksForCodegen(start.successors[0], end);
-        if (!updateKind(nextKind)) return MULTIPLE_STATEMENTS;
-      }
-    } else if (last is HIf) {
-      HIf ifInstruction = last;
-      if (ifInstruction.joinBlock !== null
-          && analyzeBlocksForCodegen(ifInstruction.joinBlock, end) != EMPTY) {
+    if (last is !HGoto) {
+      if (!updateKind(last.isStatement() ? ONE_STATEMENT : ONE_EXPRESSION)) {
         return MULTIPLE_STATEMENTS;
       }
-      int ifKind = controlFlowOperators.contains(ifInstruction)
-          ? ONE_EXPRESSION
-          : IF_STATEMENT;
-      if (!updateKind(ifKind)) return MULTIPLE_STATEMENTS;
-    } else if (start !== end) {
-      return MULTIPLE_STATEMENTS;
-    } else if (!updateKind(
-                  last.isStatement() ? ONE_STATEMENT : ONE_EXPRESSION)) {
-      return MULTIPLE_STATEMENTS;
     }
 
     CopyHandler handler = variableNames.getCopyHandler(start);
     if (handler !== null && !handler.isEmpty()) {
       if (handler.assignments.length > 1) return MULTIPLE_STATEMENTS;
       if (handler.assignments.length == 1) {
         if (!updateKind(ONE_STATEMENT)) return MULTIPLE_STATEMENTS;
       }
       // If the block has a copy where the destination and source are
       // different, we will emit that copy, and therefore the block is
@@ skipping 13 matching lines @@
     if (!controlFlowOperators.contains(node)) return false;
     HPhi phi = node.joinBlock.phis.first;
     bool atUseSite = isGenerateAtUseSite(phi);
     // Don't generate a conditional operator in this situation:
     // i = condition ? bar() : i;
     // But generate this instead:
     // if (condition) i = bar();
     // Usually, the variable name is longer than 'if' and it takes up
     // more space to duplicate the name.
     if (!atUseSite
-        && !generatingInlineStatement
         && variableNames.getName(phi) == variableNames.getName(phi.inputs[1])) {
       return false;
     }
     if (!atUseSite) define(phi);
     visitBasicBlock(node.joinBlock);
     return true;
   }
 
   void generateIf(HIf node, HIfBlockInformation info) {
     HStatementInformation thenGraph = info.thenGraph;
     HStatementInformation elseGraph = info.elseGraph;
     int thenKind = analyzeGraphForCodegen(thenGraph);
     int elseKind = analyzeGraphForCodegen(elseGraph);
 
     void visitWithoutIndent(HStatementInformation toVisit) {
-      generatingInlineStatement = true;
-      visitSubGraph(new SubGraph(toVisit.start, toVisit.end));
+      int oldIndent = indent;
+      indent = 0;
+      generateStatements(toVisit);
+      indent = oldIndent;
     }
 
     void visitWithIndent(HStatementInformation toVisit) {
       buffer.add('{\n');
       indent++;
-      visitSubGraph(new SubGraph(toVisit.start, toVisit.end));
+      generateStatements(toVisit);
       indent--;
       addIndented('}');
     }
 
     void emitIf() {
       addIndented('if (');
       use(node.inputs[0], JSPrecedence.EXPRESSION_PRECEDENCE);
       buffer.add(') ');
     }
 
@@ skipping 23 matching lines @@
               use(node.inputs[0], JSPrecedence.STATEMENT_PRECEDENCE);
               buffer.add(';\n');
             }
             break;
 
           case ONE_EXPRESSION:
             generateAnd(elseGraph, () { generateNot(node.inputs[0]); });
             break;
 
           case ONE_STATEMENT:
-          case IF_STATEMENT:
             addIndented('if (');
             generateNot(node.inputs[0]);
             buffer.add(') ');
             visitWithoutIndent(elseGraph);
             break;
 
           case MULTIPLE_STATEMENTS:
             addIndented('if (');
             generateNot(node.inputs[0]);
             buffer.add(') ');
@@ skipping 12 matching lines @@
               int precedence = operatorPrecedence.left;
               generateAnd(thenGraph, () { use(node.inputs[0], precedence); });
             } else {
               emitIf();
               visitWithoutIndent(thenGraph);
             }
             break;
 
           case ONE_EXPRESSION:
           case ONE_STATEMENT:
-          case IF_STATEMENT:
             // TODO(ngeoffray): Generate a conditional.
             emitIf();
             visitWithoutIndent(thenGraph);
             if (thenGraphHasSuccessor) {
               addIndented('else ');
               visitWithoutIndent(elseGraph);
             } else {
               generateStatements(elseGraph);
             }
             break;
 
           case MULTIPLE_STATEMENTS:
             emitIf();
             visitWithoutIndent(thenGraph);
             if (thenGraphHasSuccessor) {
               addIndented('else ');
               visitWithIndent(elseGraph);
               buffer.add('\n');
             } else {
               generateStatements(elseGraph);
             }
             break;
         }
         break;
 
       case MULTIPLE_STATEMENTS:
-      case IF_STATEMENT:
         emitIf();
         visitWithIndent(thenGraph);
 
         switch (elseKind) {
           case EMPTY:
             buffer.add('\n');
             break;
 
           case ONE_EXPRESSION:
           case ONE_STATEMENT:
-          case IF_STATEMENT:
             if (thenGraphHasSuccessor) {
               buffer.add(' else ');
               visitWithoutIndent(elseGraph);
             } else {
               buffer.add('\n');
               generateStatements(elseGraph);
             }
             break;
 
           case MULTIPLE_STATEMENTS:
             if (thenGraphHasSuccessor) {
               buffer.add(' else ');
               visitWithIndent(elseGraph);
               buffer.add('\n');
             } else {
               buffer.add('\n');
               generateStatements(elseGraph);
             }
             break;
         }
         break;
     }
   }
 
+
   visitIf(HIf node) {
     if (tryControlFlowOperation(node)) return;
 
     if (subGraph !== null && node.block === subGraph.end) {
       if (isGeneratingExpression()) {
         use(node.inputs[0], JSPrecedence.EXPRESSION_PRECEDENCE);
       }
       return;
     }
 
     HInstruction condition = node.inputs[0];
     HIfBlockInformation info = node.blockInformation.body;
 
     if (condition.isConstant()) {
       HConstant constant = condition;
       if (constant.constant.isTrue()) {
         generateStatements(info.thenGraph);
-        int thenKind = analyzeGraphForCodegen(info.thenGraph);
-        if (thenKind == EMPTY && generatingInlineStatement) {
-          // If we are generating an inline statement, but that
-          // statement is actually empty, still emit a ';' (one
-          // statement) to emit valid syntax (e.g. 'else;').
-          generatingInlineStatement = false;
-          buffer.add(';\n');
-        }
       } else {
         generateStatements(info.elseGraph);
-        int elseKind = analyzeGraphForCodegen(info.elseGraph);
-        if (elseKind == EMPTY && generatingInlineStatement) {
-          generatingInlineStatement = false;
-          buffer.add(';\n');
-        }
       }
     } else {
       generateIf(node, info);
     }
 
     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.
@@ skipping 440 matching lines @@
     buffer.add('throw ');
     beginExpression(JSPrecedence.EXPRESSION_PRECEDENCE);
     beginExpression(JSPrecedence.CALL_PRECEDENCE);
     buffer.add(compiler.namer.isolateAccess(helper));
     visitArguments([null, argument]);
     endExpression(JSPrecedence.CALL_PRECEDENCE);
     endExpression(JSPrecedence.EXPRESSION_PRECEDENCE);
   }
 
   void addIndentation() {
-    if (generatingInlineStatement) {
-      generatingInlineStatement = false;
-    } else {
-      for (int i = 0; i < indent; i++) {
-        buffer.add('  ');
-      }
+    for (int i = 0; i < indent; i++) {
+      buffer.add('  ');
     }
   }
 
   void addIndented(String text) {
     addIndentation();
     buffer.add(text);
   }
 
   void visitSwitch(HSwitch node) {
     // Switches are handled using [visitSwitchInfo].
@@ skipping 864 matching lines @@
       startBailoutSwitch();
     }
   }
 
   void endLabeledBlock(HLabeledBlockInformation labeledBlockInfo) {
     if (labeledBlockInfo.body.start.hasGuards()) {
       endBailoutSwitch();
     }
   }
 }