Generate nested else if

dart/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 MULTIPLE_STATEMENTS = 3;
+  static final int IF_STATEMENT = 3;
+  static final int MULTIPLE_STATEMENTS = 4;
 
   /**
    * 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').

[Lasse Reichstein Nielsen, 2012/06/19 09:10:44]

Thanks for the explanation.
Nitpick: "," after "e.g." :)

+   */
+  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) {
-    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;
+    return analyzeBlocksForCodegen(graph.start, graph.end);
+  }
 
+  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 (!updateKind(last.isStatement() ? ONE_STATEMENT : ONE_EXPRESSION)) {
+    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) {
         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) {
-      int oldIndent = indent;
-      indent = 0;
-      generateStatements(toVisit);
-      indent = oldIndent;
+      generatingInlineStatement = true;
+      visitSubGraph(new SubGraph(toVisit.start, toVisit.end));
     }
 
     void visitWithIndent(HStatementInformation toVisit) {
       buffer.add('{\n');
       indent++;
-      generateStatements(toVisit);
+      visitSubGraph(new SubGraph(toVisit.start, toVisit.end));
       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() {
-    for (int i = 0; i < indent; i++) {
-      buffer.add('  ');
+    if (generatingInlineStatement) {

[Lasse Reichstein Nielsen, 2012/06/19 09:10:44]

I understand the variable now.
Maybe it could be called "skipNextIndentation" instead. That's pretty clear and
this method would be even more readable.

+      generatingInlineStatement = false;
+    } else {
+      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();
     }
   }
 }