Revert "Generate JS operators using helper functions with thunks for operands." because of buildbot…

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 255 matching lines @@
       buffer.add('(');
     }
   }
 
   void endExpression(int precedence) {
     if (precedence < expectedPrecedence) {
       buffer.add(')');
     }
   }
 
-  /**
-   * Adds parenthes around the code generated by [body] if necessary.
-   * The precedence level of the body is assumed to be [precedence].
-   */
-  void parenthesize(int precedence, void body()) {
+  void withPrecedence(int precedence, void action()) {
     int oldPrecedence = expectedPrecedence;
     beginExpression(precedence);
-    // Raise the expected precedence-level to what the body expects.
     expectedPrecedence = precedence;
-    body();
+    action();
     expectedPrecedence = oldPrecedence;
     endExpression(precedence);
   }
 
-  void withPrecedence(int precedence, void action()) {
-    int oldPrecedence = expectedPrecedence;
-    expectedPrecedence = precedence;
-    action();
-    expectedPrecedence = oldPrecedence;
-  }
-
-  /**
-   * Generates code for a JavaScript binary operator.
-   * The code is parenthesized if necessary, and the expected
-   * precedence level of the left- and right-hand sides is set,
-   * based on the operator.
-   */
-  void binary(String operator, void lhs(), void rhs()) {
-    JSBinaryOperatorPrecedence op = JSPrecedence.binary[operator];
-    beginExpression(op.precedence);
-    withPrecedence(op.left, lhs);
-    buffer.add(' ');
-    buffer.add(operator);
-    buffer.add(' ');
-    withPrecedence(op.right, rhs);
-    endExpression(op.precedence);
-  }
-
-  /**
-   * Generate code for a JavaScript postfix operator (only -- and ++
-   * exist).
-   */
-  void PostfixExpression(String operator, void body()) {
-    // Corresponds to a JavaScript production of the form (ES5 11.3):
-    //   PostfixExpression ::= LeftHandSideExpression <operator>
-    beginExpression(JSPrecedence.POSTFIX_PRECEDENCE);
-    withPrecedence(JSPrecedence.CALL_PRECEDENCE, body);
-    buffer.add(operator);
-    endExpression(JSPrecedence.PSOTFIX_PRECEDENCE);
-  }
-
-  /**
-   * Generate code for a JavaScript prefix operator.
-   * There are no validation on the operator text. If it is a "word"
-   * operator (e.g., "typeof" or "void") the caller should put in a
-   * trailing space if necessary to delimit it from the following
-   * expression.
-   */
-  void prefix(String operator, void body()) {
-    // Corresponds to a JavaScript production of the form (ES5 11.4):
-    //   UnaryExpression ::= <operator> UnaryExpression
-    beginExpression(JSPrecedence.PREFIX_PRECEDENCE);
-    buffer.add(operator);
-    withPrecedence(JSPrecedence.PREFIX_PRECEDENCE, body);
-    endExpression(JSPrecedence.PREFIX_PRECEDENCE);
-  }
-
-  void conditional(void condition(), [void ifTrue(), void ifFalse()]) {
-    beginExpression(JSPrecedence.CONDITIONAL_PRECEDENCE);
-    withPrecedence(JSPrecedence.LOGICAL_OR_PRECEDENCE, condition);
-    buffer.add(" ? ");
-    withPrecedence(JSPrecedence.ASSIGNMENT_PRECEDENCE, ifTrue);
-    buffer.add(" : ");
-    withPrecedence(JSPrecedence.ASSIGNMENT_PRECEDENCE, ifFalse);
-    endExpression(JSPrecedence.CONDITIONAL_PRECEDENCE);
-  }
-
-  void literal(String text) {
-    buffer.add(text);
-  }
-
   void preGenerateMethod(HGraph graph) {
     new SsaInstructionMerger(generateAtUseSite).visitGraph(graph);
     new SsaConditionMerger(generateAtUseSite,
                            controlFlowOperators).visitGraph(graph);
     SsaLiveIntervalBuilder intervalBuilder =
         new SsaLiveIntervalBuilder(compiler, generateAtUseSite);
     intervalBuilder.visitGraph(graph);
     SsaVariableAllocator allocator = new SsaVariableAllocator(
         compiler,
         intervalBuilder.liveInstructions,
@@ skipping 268 matching lines @@
       // the short update definition if it is.
       if (variableNames.getName(left) == name) {
         // Check if the right operand is constant one.
         bool rightIsOne = false;
         if (right.isConstantNumber()) {
           HConstant rightConstant = right;
           NumConstant numConstant = rightConstant.constant;
           rightIsOne = (numConstant.value == 1);
         }
         if (binaryInstruction is HAdd && rightIsOne) {
-          prefix('++', () => declareVariable(name));
+          beginExpression(JSPrecedence.PREFIX_PRECEDENCE);
+          buffer.add('++');
+          declareVariable(name);
+          endExpression(JSPrecedence.PREFIX_PRECEDENCE);
         } else if (binaryInstruction is HSubtract && rightIsOne) {
-          prefix("--", () => declareVariable(name));
+          beginExpression(JSPrecedence.PREFIX_PRECEDENCE);
+          buffer.add('--');
+          declareVariable(name);
+          endExpression(JSPrecedence.PREFIX_PRECEDENCE);
         } else {
           var operation = binaryInstruction.operation.name;
-          binary('$operation=',
-                 () => declareVariable(name),
-                 () => use(right, expectedPrecedence));
+          beginExpression(JSPrecedence.ASSIGNMENT_PRECEDENCE);
+          declareVariable(name);
+          buffer.add(' ${operation}= ');
+          use(right, JSPrecedence.ASSIGNMENT_PRECEDENCE);
+          endExpression(JSPrecedence.ASSIGNMENT_PRECEDENCE);
         }
         return true;
       }
     }
     return false;
   }
 
   // For simple type checks like i = intTypeCheck(i), we don't have to
   // emit an assignment, because the intTypeCheck just returns its
   // argument.
   bool handleTypeConversion(instruction, name) {
     if (instruction is !HTypeConversion) return false;
     String inputName = variableNames.getName(instruction.checkedInput);
     if (name != inputName) return false;
     visit(instruction, JSPrecedence.STATEMENT_PRECEDENCE);
     return true;
   }
 
   void define(HInstruction instruction) {
     if (isGeneratingExpression()) {
       addExpressionSeparator();
     } else {
       assert(expectedPrecedence == JSPrecedence.STATEMENT_PRECEDENCE);
       addIndentation();
     }
     if (!instruction.isControlFlow() && variableNames.hasName(instruction)) {
       var name = variableNames.getName(instruction);
       if (!handleSimpleUpdateDefinition(instruction, name)
           && !handleTypeConversion(instruction, name)) {
-        binary("=",
-               () => declareInstruction(instruction),
-               () => visit(instruction, expectedPrecedence));
+        withPrecedence(JSPrecedence.ASSIGNMENT_PRECEDENCE, () {
+          declareInstruction(instruction);
+          buffer.add(" = ");
+          visit(instruction, JSPrecedence.ASSIGNMENT_PRECEDENCE);
+        });
       }
     } else {
       visit(instruction, expectedPrecedence);
     }
     if (!isGeneratingExpression()) buffer.add(';\n');
   }
 
   void use(HInstruction argument, int expectedPrecedenceForArgument) {
     if (isGenerateAtUseSite(argument)) {
       visit(argument, expectedPrecedenceForArgument);
@@ skipping 525 matching lines @@
     }
     assignPhisOfSuccessors(node);
     if (instruction is HLoopBranch && isGeneratingExpression()) {
       addExpressionSeparator();
     }
     visit(instruction, JSPrecedence.STATEMENT_PRECEDENCE);
   }
 
   visitInvokeBinary(HInvokeBinary node, String op) {
     if (node.builtin) {
-      binary(op,
-             () => use(node.left, expectedPrecedence),
-             () => use(node.right, expectedPrecedence));
+      JSBinaryOperatorPrecedence operatorPrecedences = JSPrecedence.binary[op];
+      beginExpression(operatorPrecedences.precedence);
+      use(node.left, operatorPrecedences.left);
+      buffer.add(' $op ');
+      use(node.right, operatorPrecedences.right);
+      endExpression(operatorPrecedences.precedence);
     } else {
       visitInvokeStatic(node);
     }
   }
 
   // We want the outcome of bit-operations to be positive. We use the unsigned
   // shift operator to achieve this.
   visitBitInvokeBinary(HBinaryBitOp node, String op) {
     if (node.builtin && requiresUintConversion(node)) {
-      binary(">>>",
-             () => visitInvokeBinary(node, op),
-             () => literal("0"));
+      beginExpression(unsignedShiftPrecedences.precedence);
+      int oldPrecedence = this.expectedPrecedence;
+      this.expectedPrecedence = JSPrecedence.SHIFT_PRECEDENCE;
+      visitInvokeBinary(node, op);
+      buffer.add(' >>> 0');
+      this.expectedPrecedence = oldPrecedence;
+      endExpression(unsignedShiftPrecedences.precedence);
     } else {
       visitInvokeBinary(node, op);
     }
   }
 
   visitInvokeUnary(HInvokeUnary node, String op) {
     if (node.builtin) {
-      prefix(op, () => use(node.operand, expectedPrecedence));
+      beginExpression(JSPrecedence.PREFIX_PRECEDENCE);
+      buffer.add('$op');
+      use(node.operand, JSPrecedence.PREFIX_PRECEDENCE);
+      endExpression(JSPrecedence.PREFIX_PRECEDENCE);
     } else {
       visitInvokeStatic(node);
     }
   }
 
   // We want the outcome of bit-operations to be positive. We use the unsigned
   // shift operator to achieve this.
   visitBitInvokeUnary(HInvokeUnary node, String op) {
-    if (node.builtin && requiresUintConversion(node)){
-      binary(">>>",
-             () => visitInvokeUnary(node, op),
-             () => literal("0"));
+    if (node.builtin && requiresUintConversion(node)) {
+      beginExpression(unsignedShiftPrecedences.precedence);
+      int oldPrecedence = this.expectedPrecedence;
+      this.expectedPrecedence = JSPrecedence.SHIFT_PRECEDENCE;
+      visitInvokeUnary(node, op);
+      buffer.add(' >>> 0');
+      this.expectedPrecedence = oldPrecedence;
+      endExpression(unsignedShiftPrecedences.precedence);
     } else {
       visitInvokeUnary(node, op);
     }
   }
 
   void emitIdentityComparison(HInstruction left, HInstruction right) {
     HType leftType = left.propagatedType;
     HType rightType = right.propagatedType;
     if (leftType.canBeNull() && rightType.canBeNull()) {
       if (left.isConstantNull() || right.isConstantNull() ||
           (leftType.isPrimitive() && leftType == rightType)) {
-        binary("==",
-               () => use(left, expectedPrecedence),
-               () => use(right, expectedPrecedence));
+        beginExpression(JSPrecedence.EQUALITY_PRECEDENCE);
+        use(left, JSPrecedence.EQUALITY_PRECEDENCE);
+        buffer.add(' == ');
+        use(right, JSPrecedence.RELATIONAL_PRECEDENCE);
+        endExpression(JSPrecedence.EQUALITY_PRECEDENCE);
       } else {
         assert(NullConstant.JsNull == 'null');
-        void condition() {
-          binary("==",
-                 () => use(left, expectedPrecedence),
-                 () => literal("null"));
-        }
-        void ifTrue() {
-          binary("==",
-                 () => use(right, expectedPrecedence),
-                 () => literal("null"));
-        }
-        void ifFalse() {
-          binary("===",
-                 () => use(left, expectedPrecedence),
-                 () => use(right, expectedPrecedence));
-        }
-        conditional(condition, ifTrue, ifFalse);
+        withPrecedence(JSPrecedence.CONDITIONAL_PRECEDENCE, () {
+          beginExpression(JSPrecedence.EQUALITY_PRECEDENCE);
+          use(left, JSPrecedence.EQUALITY_PRECEDENCE);
+          buffer.add(' == null');
+          endExpression(JSPrecedence.EQUALITY_PRECEDENCE);
+          buffer.add(' ? ');
+          this.expectedPrecedence = JSPrecedence.ASSIGNMENT_PRECEDENCE;
+          withPrecedence(JSPrecedence.LOGICAL_AND_PRECEDENCE, () {
+            beginExpression(JSPrecedence.EQUALITY_PRECEDENCE);
+            use(right, JSPrecedence.EQUALITY_PRECEDENCE);
+            buffer.add(' == null');
+            endExpression(JSPrecedence.EQUALITY_PRECEDENCE);
+            buffer.add(" : ");
+            beginExpression(JSPrecedence.EQUALITY_PRECEDENCE);
+            use(left, JSPrecedence.EQUALITY_PRECEDENCE);
+            buffer.add(' === ');
+            use(right, JSPrecedence.EQUALITY_PRECEDENCE);
+            endExpression(JSPrecedence.EQUALITY_PRECEDENCE);
+          });
+        });
       }
     } else {
-      binary("===",
-             () => use(left, expectedPrecedence),
-             () => use(right, expectedPrecedence));
+      beginExpression(JSPrecedence.EQUALITY_PRECEDENCE);
+      use(left, JSPrecedence.EQUALITY_PRECEDENCE);
+      buffer.add(' === ');
+      use(right, JSPrecedence.RELATIONAL_PRECEDENCE);
+      endExpression(JSPrecedence.EQUALITY_PRECEDENCE);
     }
   }
 
   visitEquals(HEquals node) {
     if (node.builtin) {
       emitIdentityComparison(node.left, node.right);
     } else if (node.element === equalsNullElement ||
                node.element === boolifiedEqualsNullElement) {
       beginExpression(JSPrecedence.CALL_PRECEDENCE);
       use(node.target, JSPrecedence.CALL_PRECEDENCE);
@@ skipping 259 matching lines @@
       indent--;
       addIndented('}');
     }
 
     void emitIf() {
       addIndented('if (');
       use(node.inputs[0], JSPrecedence.EXPRESSION_PRECEDENCE);
       buffer.add(') ');
     }
 
+    JSBinaryOperatorPrecedence operatorPrecedence = JSPrecedence.binary['&&'];
     void generateAnd(HStatementInformation toVisit, Function condition) {
       addIndentation();
-      binary("&&", condition, () => visitExpression(toVisit));
+      beginExpression(operatorPrecedence.precedence);
+      var oldPrecedence = expectedPrecedence;
+      expectedPrecedence = operatorPrecedence.left;
+      condition();
+      buffer.add(" && ");
+      expectedPrecedence = operatorPrecedence.right;
+      visitExpression(toVisit);
+      expectedPrecedence = oldPrecedence;
+      endExpression(operatorPrecedence.precedence);
       buffer.add(";\n");
     }
 
     List<HBasicBlock> thenSuccessors = thenGraph.end.successors;
     bool thenGraphHasSuccessor = thenSuccessors.length != 0
         && thenSuccessors[0] !== currentGraph.exit;
 
     switch (thenKind) {
       case EMPTY:
         switch (elseKind) {
@@ skipping 25 matching lines @@
             break;
         }
 
         break;
 
       case ONE_EXPRESSION:
       case ONE_STATEMENT:
         switch (elseKind) {
           case EMPTY:
             if (thenKind == ONE_EXPRESSION) {
-              generateAnd(thenGraph,
-                          () => use(node.inputs[0], expectedPrecedence));
+              int precedence = operatorPrecedence.left;
+              generateAnd(thenGraph, () { use(node.inputs[0], precedence); });
             } else {
               emitIf();
               visitWithoutIndent(thenGraph);
             }
             break;
 
           case ONE_EXPRESSION:
           case ONE_STATEMENT:
             // TODO(ngeoffray): Generate a conditional.
             emitIf();
@@ skipping 235 matching lines @@
 
   visitFieldSet(HFieldSet node) {
     if (work.element.isGenerativeConstructorBody() &&
         node.element.enclosingElement.isClass() &&
         node.value.hasGuaranteedType() &&
         node.block.dominates(currentGraph.exit)) {
       backend.updateFieldConstructorSetters(node.element,
                                             node.value.guaranteedType);
     }
     String name = compiler.namer.getName(node.element);
-    binary("=", () {
-      use(node.receiver, JSPrecedence.MEMBER_PRECEDENCE);
-      buffer.add('.');
-      buffer.add(name);
-      Type type = node.receiver.propagatedType.computeType(compiler);
-      if (type != null) {
-        world.registerFieldSetter(node.element.name, type);
-        backend.updateFieldIntegerSetters(node.element,
-                                          node.value.isInteger());
-      }
-    }, () {
-      use(node.value, expectedPrecedence);
-    });
+    beginExpression(JSPrecedence.ASSIGNMENT_PRECEDENCE);
+    use(node.receiver, JSPrecedence.MEMBER_PRECEDENCE);
+    buffer.add('.');
+    buffer.add(name);
+    Type type = node.receiver.propagatedType.computeType(compiler);
+    if (type != null) {
+      world.registerFieldSetter(node.element.name, type);
+      backend.updateFieldIntegerSetters(node.element,
+                                        node.value.isInteger());
+    }
+    buffer.add(' = ');
+    use(node.value, JSPrecedence.ASSIGNMENT_PRECEDENCE);
+    endExpression(JSPrecedence.ASSIGNMENT_PRECEDENCE);
   }
 
   visitLocalGet(HLocalGet node) {
     use(node.receiver, JSPrecedence.EXPRESSION_PRECEDENCE);
   }
 
   visitLocalSet(HLocalSet node) {
-    binary("=",
-           () => declareInstruction(node.receiver),
-           () => use(node.value, expectedPrecedence));
+    declareInstruction(node.receiver);
+    buffer.add(' = ');
+    use(node.value, JSPrecedence.ASSIGNMENT_PRECEDENCE);
   }
 
   visitForeign(HForeign node) {
     String code = node.code.slowToString();
     List<HInstruction> inputs = node.inputs;
     List<String> parts = code.split('#');
     if (parts.length != inputs.length + 1) {
       compiler.internalError(
           'Wrong number of arguments for JS', instruction: node);
     }
@@ skipping 103 matching lines @@
 
 
   void generateNot(HInstruction input) {
     bool isBuiltinRelational(HInstruction instruction) {
       if (instruction is !HRelational) return false;
       HRelational relational = instruction;
       return relational.builtin;
     }
 
     if (input is HBoolify && isGenerateAtUseSite(input)) {
-      binary("!==",
-             () => use(input.inputs[0], JSPrecedence.EQUALITY_PRECEDENCE),
-             () => literal("true"));
+      beginExpression(JSPrecedence.EQUALITY_PRECEDENCE);
+      use(input.inputs[0], JSPrecedence.EQUALITY_PRECEDENCE);
+      buffer.add(' !== true');
+      endExpression(JSPrecedence.EQUALITY_PRECEDENCE);
     } else if (isBuiltinRelational(input) &&
                isGenerateAtUseSite(input) &&
                input.inputs[0].propagatedType.isUseful() &&
                !input.inputs[0].isDouble() &&
                input.inputs[1].propagatedType.isUseful() &&
                !input.inputs[1].isDouble()) {
       // This optimization doesn't work for NaN, so we only do it if the
       // type is known to be non-Double.
       Map<String, String> inverseOperator = const <String>{
         "==" : "!=",
         "!=" : "==",
         "===": "!==",
         "!==": "===",
         "<"  : ">=",
         "<=" : ">",
         ">"  : "<=",
         ">=" : "<"
       };
       HRelational relational = input;
       visitInvokeBinary(input,
                         inverseOperator[relational.operation.name.stringValue]);
     } else {
-      prefix("!", () => use(input, JSPrecedence.PREFIX_PRECEDENCE));
+      beginExpression(JSPrecedence.PREFIX_PRECEDENCE);
+      buffer.add('!');
+      use(input, JSPrecedence.PREFIX_PRECEDENCE);
+      endExpression(JSPrecedence.PREFIX_PRECEDENCE);
     }
   }
 
   visitParameterValue(HParameterValue node) => visitLocalValue(node);
 
   visitLocalValue(HLocalValue node) {
     assert(isGenerateAtUseSite(node));
     buffer.add(variableNames.getName(node));
   }
 
   visitPhi(HPhi node) {
     // This method is only called for phis that are generated at use
     // site. A phi can be generated at use site only if it is the
     // result of a control flow operation.
     HBasicBlock ifBlock = node.block.dominator;
     assert(controlFlowOperators.contains(ifBlock.last));
     HInstruction input = ifBlock.last.inputs[0];
     if (input.isConstantFalse()) {
       use(node.inputs[1], expectedPrecedence);
     } else if (input.isConstantTrue()) {
       use(node.inputs[0], expectedPrecedence);
     } else if (node.inputs[1].isConstantBoolean()) {
       String operation = node.inputs[1].isConstantFalse() ? '&&' : '||';
-      binary(operation, () {
-        if (operation == '||') {
-          if (input is HNot) {
-            use(input.inputs[0], expectedPrecedence);
-          } else {
-            generateNot(input);
-          }
+      JSBinaryOperatorPrecedence operatorPrecedence =
+          JSPrecedence.binary[operation];
+      beginExpression(operatorPrecedence.precedence);
+      if (operation == '||') {
+        if (input is HNot) {
+          use(input.inputs[0], operatorPrecedence.left);
         } else {
-          use(input, expectedPrecedence);
+          generateNot(input);
         }
-      }, () {
-        use(node.inputs[0], expectedPrecedence);
-      });
+      } else {
+        use(input, operatorPrecedence.left);
+      }
+      buffer.add(" $operation ");
+      use(node.inputs[0], operatorPrecedence.right);
+      endExpression(operatorPrecedence.precedence);
     } else {
-      conditional(
-        () => use(input, expectedPrecedence),
-        ifTrue: () => use(node.inputs[0], expectedPrecedence),
-        ifFalse: () => use(node.inputs[1], expectedPrecedence));
+      beginExpression(JSPrecedence.CONDITIONAL_PRECEDENCE);
+      use(input, JSPrecedence.LOGICAL_OR_PRECEDENCE);
+      buffer.add(' ? ');
+      use(node.inputs[0], JSPrecedence.ASSIGNMENT_PRECEDENCE);
+      buffer.add(' : ');
+      use(node.inputs[1], JSPrecedence.ASSIGNMENT_PRECEDENCE);
+      endExpression(JSPrecedence.CONDITIONAL_PRECEDENCE);
     }
   }
 
   visitReturn(HReturn node) {
     addIndentation();
     assert(node.inputs.length == 1);
     HInstruction input = node.inputs[0];
     if (input.isConstantNull()) {
       buffer.add('return;\n');
     } else {
@@ skipping 19 matching lines @@
   }
 
   visitBoundsCheck(HBoundsCheck node) {
     // TODO(ngeoffray): Separate the two checks of the bounds check, so,
     // e.g., the zero checks can be shared if possible.
 
     // If the checks always succeede, we would have removed the bounds check
     // completely.
     assert(node.staticChecks != HBoundsCheck.ALWAYS_TRUE);
     if (node.staticChecks != HBoundsCheck.ALWAYS_FALSE) {
-      void checkUpperBound() {
-        binary(">=",
-               () => use(node.index, expectedPrecedence),
-               () => use(node.length, expectedPrecedence));
-      }
       buffer.add('if (');
       if (node.staticChecks != HBoundsCheck.ALWAYS_ABOVE_ZERO) {
         assert(node.staticChecks == HBoundsCheck.FULL_CHECK);
-        binary("||",
-               () => binary("<",
-                            () => use(node.index, expectedPrecedence),
-                            () => literal("0")),
-               checkUpperBound);
-      } else {
-        checkUpperBound();
+        use(node.index, JSPrecedence.RELATIONAL_PRECEDENCE);
+        buffer.add(' < 0 || ');
       }
+      use(node.index, JSPrecedence.RELATIONAL_PRECEDENCE);
+      buffer.add(' >= ');
+      use(node.length, JSPrecedence.SHIFT_PRECEDENCE);
       buffer.add(") ");
     }
     generateThrowWithHelper('ioore', node.index);
   }
 
   visitIntegerCheck(HIntegerCheck node) {
     if (!node.alwaysFalse) {
       buffer.add('if (');
       checkInt(node.value, '!==');
       buffer.add(') ');
@@ skipping 41 matching lines @@
     use(node.inputs[0], JSPrecedence.ASSIGNMENT_PRECEDENCE);
     endExpression(JSPrecedence.ASSIGNMENT_PRECEDENCE);
   }
 
   void visitStringConcat(HStringConcat node) {
     if (isEmptyString(node.left)) {
       useStringified(node.right, expectedPrecedence);
    } else if (isEmptyString(node.right)) {
       useStringified(node.left, expectedPrecedence);
     } else {
+      JSBinaryOperatorPrecedence operatorPrecedences = JSPrecedence.binary['+'];
+      beginExpression(operatorPrecedences.precedence);
+      useStringified(node.left, operatorPrecedences.left);
+      buffer.add(' + ');
       // If the right hand side is a string concatenation itself it is
-      // safe to make it left associative by omitting parentheses.
-      bool useAdditivePrecedence = node.right is HStringConcat;
-      binary("+",
-             () => useStringified(node.left, expectedPrecedence),
-             () => useStringified(node.right,
-                                  useAdditivePrecedence
-                                      ? JSPrecedence.ADDITIVE_PRECEDENCE
-                                      : expectedPrecedence));
+      // safe to make it left associative.
+      int rightPrecedence = (node.right is HStringConcat)
+          ? JSPrecedence.ADDITIVE_PRECEDENCE
+          : operatorPrecedences.right;
+      useStringified(node.right, rightPrecedence);
+      endExpression(operatorPrecedences.precedence);
     }
   }
 
   bool isEmptyString(HInstruction node) {
     if (!node.isConstantString()) return false;
     HConstant constant = node;
     StringConstant string = constant.constant;
     return string.value.length == 0;
   }
 
@@ skipping 75 matching lines @@
       }
     }
 
     return null;
   }
 
   void visitInvokeInterceptor(HInvokeInterceptor node) {
     String builtin = builtinJsName(node);
     if (builtin !== null) {
       if (builtin == '+') {
-        binary('+',
-               () => use(node.inputs[1], expectedPrecedence),
-               () => use(node.inputs[2], expectedPrecedence));
+        beginExpression(JSPrecedence.ADDITIVE_PRECEDENCE);
+        use(node.inputs[1], JSPrecedence.ADDITIVE_PRECEDENCE);
+        buffer.add(' + ');
+        use(node.inputs[2], JSPrecedence.MULTIPLICATIVE_PRECEDENCE);
+        endExpression(JSPrecedence.ADDITIVE_PRECEDENCE);
       } else {
         beginExpression(JSPrecedence.CALL_PRECEDENCE);
         use(node.inputs[1], JSPrecedence.MEMBER_PRECEDENCE);
         buffer.add('.');
         buffer.add(builtin);
         if (node.getter) return;
         buffer.add('(');
         for (int i = 2; i < node.inputs.length; i++) {
           if (i != 2) buffer.add(', ');
           use(node.inputs[i], JSPrecedence.ASSIGNMENT_PRECEDENCE);
         }
         buffer.add(")");
         endExpression(JSPrecedence.CALL_PRECEDENCE);
       }
     } else {
       return visitInvokeStatic(node);
     }
   }
 
   void checkInt(HInstruction input, String cmp) {
-    binary(cmp,
-           () => use(input, expectedPrecedence),
-           () => binary("|",
-                        () => use(input, expectedPrecedence),
-                        () => literal("0")));
-  }
-
-  void checkJSType(HInstruction input, String cmp, String type) {
-    binary(cmp,
-           () => prefix("typeof ", () => use(input, expectedPrecedence)),
-           () => literal("'$type'"));
+    beginExpression(JSPrecedence.EQUALITY_PRECEDENCE);
+    use(input, JSPrecedence.EQUALITY_PRECEDENCE);
+    buffer.add(' $cmp (');
+    use(input, JSPrecedence.BITWISE_OR_PRECEDENCE);
+    buffer.add(' | 0)');
+    endExpression(JSPrecedence.EQUALITY_PRECEDENCE);
   }
 
   void checkNum(HInstruction input, String cmp) {
-    checkJSType(input, cmp, "number");
+    beginExpression(JSPrecedence.EQUALITY_PRECEDENCE);
+    buffer.add('typeof ');
+    use(input, JSPrecedence.PREFIX_PRECEDENCE);
+    buffer.add(" $cmp 'number'");
+    endExpression(JSPrecedence.EQUALITY_PRECEDENCE);
   }
 
   void checkDouble(HInstruction input, String cmp) {
     checkNum(input, cmp);
   }
 
   void checkString(HInstruction input, String cmp) {
-    checkJSType(input, cmp, "string");
+    beginExpression(JSPrecedence.EQUALITY_PRECEDENCE);
+    buffer.add('typeof ');
+    use(input, JSPrecedence.PREFIX_PRECEDENCE);
+    buffer.add(" $cmp 'string'");
+    endExpression(JSPrecedence.EQUALITY_PRECEDENCE);
   }
 
   void checkBool(HInstruction input, String cmp) {
-    checkJSType(input, cmp, "boolean");
+    beginExpression(JSPrecedence.EQUALITY_PRECEDENCE);
+    buffer.add('typeof ');
+    use(input, JSPrecedence.PREFIX_PRECEDENCE);
+    buffer.add(" $cmp 'boolean'");
+    endExpression(JSPrecedence.EQUALITY_PRECEDENCE);
   }
 
   void checkObject(HInstruction input, String cmp) {
     assert(NullConstant.JsNull == 'null');
     if (cmp == "===") {
-      binary("&&",
-             () => checkJSType(input, "===", "object"),
-             () => binary("!==",
-                          () => use(input, expectedPrecedence),
-                          () => literal("null")));
+      withPrecedence(JSPrecedence.LOGICAL_AND_PRECEDENCE, () {
+        beginExpression(JSPrecedence.EQUALITY_PRECEDENCE);
+        buffer.add('typeof ');
+        use(input, JSPrecedence.PREFIX_PRECEDENCE);
+        buffer.add(" === 'object'");
+        endExpression(JSPrecedence.EQUALITY_PRECEDENCE);
+        buffer.add(" && ");
+        beginExpression(JSPrecedence.EQUALITY_PRECEDENCE);
+        use(input, JSPrecedence.PREFIX_PRECEDENCE);
+        buffer.add(" !== null");
+        endExpression(JSPrecedence.EQUALITY_PRECEDENCE);
+      });
     } else {
       assert(cmp == "!==");
-      binary("||",
-             () => checkJSType(input, "!==", "object"),
-             () => binary("===",
-                          () => use(input, expectedPrecedence),
-                          () => literal("null")));
+      withPrecedence(JSPrecedence.LOGICAL_OR_PRECEDENCE, () {
+        beginExpression(JSPrecedence.EQUALITY_PRECEDENCE);
+        buffer.add('typeof ');
+        use(input, JSPrecedence.PREFIX_PRECEDENCE);
+        buffer.add(" !== 'object'");
+        endExpression(JSPrecedence.EQUALITY_PRECEDENCE);
+        buffer.add(" || ");
+        beginExpression(JSPrecedence.EQUALITY_PRECEDENCE);
+        use(input, JSPrecedence.PREFIX_PRECEDENCE);
+        buffer.add(" === null");
+        endExpression(JSPrecedence.EQUALITY_PRECEDENCE);
+      });
     }
   }
 
   void checkArray(HInstruction input, String cmp) {
-    binary(cmp,
-           () {
-             use(input, JSPrecedence.MEMBER_PRECEDENCE);
-             buffer.add('.constructor');
-           },
-           () => literal("Array"));
+    beginExpression(JSPrecedence.EQUALITY_PRECEDENCE);
+    use(input, JSPrecedence.MEMBER_PRECEDENCE);
+    buffer.add('.constructor $cmp Array');
+    endExpression(JSPrecedence.EQUALITY_PRECEDENCE);
   }
 
   void checkImmutableArray(HInstruction input) {
-    prefix("!!", () {
-      use(input, JSPrecedence.MEMBER_PRECEDENCE);
-      buffer.add('.immutable\$list');
-    });
+    beginExpression(JSPrecedence.PREFIX_PRECEDENCE);
+    buffer.add('!!');
+    use(input, JSPrecedence.MEMBER_PRECEDENCE);
+    buffer.add('.immutable\$list');
+    endExpression(JSPrecedence.PREFIX_PRECEDENCE);
   }
 
   void checkExtendableArray(HInstruction input) {
-    prefix("!!" , () {
-      use(input, JSPrecedence.MEMBER_PRECEDENCE);
-      buffer.add('.fixed\$length');
-    });
+    beginExpression(JSPrecedence.PREFIX_PRECEDENCE);
+    buffer.add('!!');
+    use(input, JSPrecedence.MEMBER_PRECEDENCE);
+    buffer.add('.fixed\$length');
+    endExpression(JSPrecedence.PREFIX_PRECEDENCE);
   }
 
   void checkFixedArray(HInstruction input) {
-    parenthesize(JSPrecedence.MEMBER_PRECEDENCE, () {
-      use(input, JSPrecedence.MEMBER_PRECEDENCE);
-      buffer.add('.fixed\$length');
-    });
+    beginExpression(JSPrecedence.PREFIX_PRECEDENCE);
+    use(input, JSPrecedence.MEMBER_PRECEDENCE);
+    buffer.add('.fixed\$length');
+    endExpression(JSPrecedence.PREFIX_PRECEDENCE);
   }
 
   void checkNull(HInstruction input) {
-    binary("==",
-           () => use(input, expectedPrecedence),
-           () => literal("null"));
+    beginExpression(JSPrecedence.EQUALITY_PRECEDENCE);
+    use(input, JSPrecedence.EQUALITY_PRECEDENCE);
+    buffer.add(" == null");
+    endExpression(JSPrecedence.EQUALITY_PRECEDENCE);
   }
 
   void checkFunction(HInstruction input, Element element) {
-    binary("||",
-           () => checkJSType(input, "===", "function"),
-           () => binary('&&',
-                        () => checkObject(input, '==='),
-                        () => checkType(input, element)));
+    withPrecedence(JSPrecedence.LOGICAL_OR_PRECEDENCE, () {
+      beginExpression(JSPrecedence.EQUALITY_PRECEDENCE);
+      buffer.add('typeof ');
+      use(input, JSPrecedence.PREFIX_PRECEDENCE);
+      buffer.add(" === 'function'");
+      endExpression(JSPrecedence.EQUALITY_PRECEDENCE);
+      buffer.add(" || ");
+      beginExpression(JSPrecedence.LOGICAL_AND_PRECEDENCE);
+      checkObject(input, '===');
+      buffer.add(" && ");
+      checkType(input, element);
+      endExpression(JSPrecedence.LOGICAL_AND_PRECEDENCE);
+    });
   }
 
   void checkType(HInstruction input, Element element, [bool negative = false]) {
     world.registerIsCheck(element);
     bool requiresNativeIsCheck =
         backend.emitter.nativeEmitter.requiresNativeIsCheck(element);
-    void body() {
-      assert(JSPrecedence.CALL_PRECEDENCE == JSPrecedence.MEMBER_PRECEDENCE);
-      parenthesize(JSPrecedence.CALL_PRECEDENCE, () {
-        use(input, JSPrecedence.MEMBER_PRECEDENCE);
-        buffer.add('.');
-        buffer.add(compiler.namer.operatorIs(element));
-        if (requiresNativeIsCheck) buffer.add('()');
-      });
-    }
     if (!requiresNativeIsCheck) {
       if (negative) {
-        prefix("!", body);
+        buffer.add('!');
       } else {
-        prefix("!!", body);
+        buffer.add('!!');
       }
     } else if (negative) {
-      prefix("!", body);
-    } else {
-      body();
+      buffer.add('!');
     }
+    use(input, JSPrecedence.MEMBER_PRECEDENCE);
+    buffer.add('.');
+    buffer.add(compiler.namer.operatorIs(element));
+    if (requiresNativeIsCheck) buffer.add('()');
   }
 
   void handleStringSupertypeCheck(HInstruction input, Element element) {
     // Make sure List and String don't share supertypes, otherwise we
     // would need to check for List too.
     assert(element !== compiler.listClass
            && !Elements.isListSupertype(element, compiler));
-    binary("||",
-           () => checkString(input, '==='),
-           () => binary("&&",
-                        () => checkObject(input, '==='),
-                        () => checkType(input, element)));
+    withPrecedence(JSPrecedence.LOGICAL_OR_PRECEDENCE, () {
+      checkString(input, '===');
+      buffer.add(' || ');
+      withPrecedence(JSPrecedence.LOGICAL_AND_PRECEDENCE, () {
+        checkObject(input, '===');
+        buffer.add(' && ');
+        checkType(input, element);
+      });
+    });
   }
 
   void handleListOrSupertypeCheck(HInstruction input, Element element) {
     // Make sure List and String don't share supertypes, otherwise we
     // would need to check for String too.
     assert(element !== compiler.stringClass
            && !Elements.isStringSupertype(element, compiler));
-    binary("&&",
-           () => checkObject(input, '==='),
-           () => binary("||",
-                        () => checkArray(input, '==='),
-                        () => checkType(input, element)));
+    beginExpression(JSPrecedence.LOGICAL_AND_PRECEDENCE);
+    checkObject(input, '===');
+    buffer.add(' && (');
+    beginExpression(JSPrecedence.LOGICAL_OR_PRECEDENCE);
+    checkArray(input, '===');
+    buffer.add(' || ');
+    checkType(input, element);
+    buffer.add(')');
+    endExpression(JSPrecedence.LOGICAL_OR_PRECEDENCE);
+    endExpression(JSPrecedence.LOGICAL_AND_PRECEDENCE);
   }
 
   void visitIs(HIs node) {
     Type type = node.typeExpression;
     Element element = type.element;
     if (element.kind === ElementKind.TYPE_VARIABLE) {
       compiler.unimplemented("visitIs for type variables", instruction: node);
     } else if (element.kind === ElementKind.TYPEDEF) {
       compiler.unimplemented("visitIs for typedefs", instruction: node);
     }
     LibraryElement coreLibrary = compiler.coreLibrary;
     ClassElement objectClass = compiler.objectClass;
     HInstruction input = node.expression;
 
-    void plainTypeCheck() {
-      if (element === objectClass || element === compiler.dynamicClass) {
-        // The constant folder also does this optimization, but we make
-        // it safe by assuming it may have not run.
-        literal('true');
-      } else if (element == compiler.stringClass) {
-        checkString(input, '===');
-      } else if (element == compiler.doubleClass) {
-        checkDouble(input, '===');
-      } else if (element == compiler.numClass) {
-        checkNum(input, '===');
-      } else if (element == compiler.boolClass) {
-        checkBool(input, '===');
-      } else if (element == compiler.functionClass) {
-        checkFunction(input, element);
-      } else if (element == compiler.intClass) {
-        binary("&&",
-               () => checkNum(input, '==='),
-               () => checkInt(input, '==='));
-      } else if (Elements.isStringSupertype(element, compiler)) {
-        handleStringSupertypeCheck(input, element);
-      } else if (element === compiler.listClass
-                 || Elements.isListSupertype(element, compiler)) {
-        handleListOrSupertypeCheck(input, element);
-      } else if (input.propagatedType.canBePrimitive()
-                 || input.propagatedType.canBeNull()) {
-        binary("&&",
-               () => checkObject(input, '==='),
-               () => checkType(input, element));
-      } else {
-        checkType(input, element);
-      }
+    int oldPrecedence;
+    if (node.nullOk) {
+      oldPrecedence = expectedPrecedence;
+      beginExpression(JSPrecedence.LOGICAL_OR_PRECEDENCE);
+      expectedPrecedence = JSPrecedence.LOGICAL_OR_PRECEDENCE;
+      checkNull(input);
+      buffer.add(' || ');
     }
-
-    void typeArgumentCheck() {
-      if (compiler.codegenWorld.rti.hasTypeArguments(type)) {
-        InterfaceType interfaceType = type;
-        ClassElement cls = type.element;
-        Link<Type> arguments = interfaceType.arguments;
-        binary("&&", plainTypeCheck, () {
-          var base = () => checkObject(node.typeInfoCall, '===');
-          // Do left-fold on elements with [base] as initial value.
-          cls.typeParameters.forEach((name, _) {
-            Type argument = arguments.head;
-            // TODO(lrn): Should we advance arguments here?
-            // What if there aren't any?
-            var oldBase = base;
-            base = () => binary("&&", oldBase, () {
-              parenthesize(JSPrecedence.ASSIGNMENT_PRECEDENCE, () {
-                use(node.typeInfoCall, JSPrecedence.MEMBER_PRECEDENCE);
-                buffer.add(".${name.slowToString()} === '${argument}'");
-              });
-            });
-          });
-          base();
-        });
-      } else {
-        plainTypeCheck();
-      }
+    if (element === objectClass || element === compiler.dynamicClass) {
+      // The constant folder also does this optimization, but we make
+      // it safe by assuming it may have not run.
+      buffer.add('true');
+    } else if (element == compiler.stringClass) {
+      checkString(input, '===');
+    } else if (element == compiler.doubleClass) {
+      checkDouble(input, '===');
+    } else if (element == compiler.numClass) {
+      checkNum(input, '===');
+    } else if (element == compiler.boolClass) {
+      checkBool(input, '===');
+    } else if (element == compiler.functionClass) {
+      checkFunction(input, element);
+    } else if (element == compiler.intClass) {
+      beginExpression(JSPrecedence.LOGICAL_AND_PRECEDENCE);
+      checkNum(input, '===');
+      buffer.add(' && ');
+      checkInt(input, '===');
+      endExpression(JSPrecedence.LOGICAL_AND_PRECEDENCE);
+    } else if (Elements.isStringSupertype(element, compiler)) {
+      handleStringSupertypeCheck(input, element);
+    } else if (element === compiler.listClass
+               || Elements.isListSupertype(element, compiler)) {
+      handleListOrSupertypeCheck(input, element);
+    } else if (input.propagatedType.canBePrimitive()
+               || input.propagatedType.canBeNull()) {
+      beginExpression(JSPrecedence.LOGICAL_AND_PRECEDENCE);
+      checkObject(input, '===');
+      buffer.add(' && ');
+      checkType(input, element);
+      endExpression(JSPrecedence.LOGICAL_AND_PRECEDENCE);
+    } else {
+      checkType(input, element);
+    }
+    if (compiler.codegenWorld.rti.hasTypeArguments(type)) {
+      InterfaceType interfaceType = type;
+      ClassElement cls = type.element;
+      Link<Type> arguments = interfaceType.arguments;
+      buffer.add(' && ');
+      checkObject(node.typeInfoCall, '===');
+      cls.typeParameters.forEach((name, _) {
+        buffer.add(' && ');
+        beginExpression(JSPrecedence.LOGICAL_AND_PRECEDENCE);
+        use(node.typeInfoCall, JSPrecedence.EQUALITY_PRECEDENCE);
+        buffer.add(".${name.slowToString()} === '${arguments.head}'");
+        endExpression(JSPrecedence.LOGICAL_AND_PRECEDENCE);
+      });
     }
     if (node.nullOk) {
-      binary("||", () => checkNull(input), typeArgumentCheck);
-    } else {
-      typeArgumentCheck();
+      expectedPrecedence = oldPrecedence;
+      endExpression(JSPrecedence.LOGICAL_OR_PRECEDENCE);
     }
   }
 
   void visitTypeConversion(HTypeConversion node) {
     Map<String, SourceString> castNames = const <SourceString> {
       "stringTypeCheck":
           const SourceString("stringTypeCast"),
       "doubleTypeCheck":
           const SourceString("doubleTypeCast"),
       "numTypeCheck":
@@ skipping 173 matching lines @@
       bailout(node, 'Not a boolean');
     } else if (node.isString()) {
       // if (input is !string) bailout
       buffer.add('if (');
       checkString(input, '!==');
       buffer.add(') ');
       bailout(node, 'Not a string');
     } else if (node.isExtendableArray()) {
       // if (input is !Object || input is !Array || input.isFixed) bailout
       buffer.add('if (');
-      binary("||",
-             () => binary("||",
-                          () => checkObject(input, '!=='),
-                          () => checkArray(input, '!==')),
-             () => checkFixedArray(input));
+      checkObject(input, '!==');
+      buffer.add('||');
+      checkArray(input, '!==');
+      buffer.add('||');
+      checkFixedArray(input);
       buffer.add(') ');
       bailout(node, 'Not an extendable array');
     } else if (node.isMutableArray()) {
       // if (input is !Object
       //     || ((input is !Array || input.isImmutable)
       //         && input is !JsIndexingBehavior)) bailout
       buffer.add('if (');
-      binary("||",
-             () => checkObject(input, '!=='),
-             () => binary("&&",
-                          () => binary("||",
-                                       () => checkArray(input, '!=='),
-                                       () => checkImmutableArray(input)),
-                          () => checkType(input, indexingBehavior,
-                                          negative: true)));
-      buffer.add(") ");
+      checkObject(input, '!==');
+      buffer.add(' || ((');
+      checkArray(input, '!==');
+      buffer.add(' || ');
+      checkImmutableArray(input);
+      buffer.add(') && ');
+      checkType(input, indexingBehavior, negative: true);
+      buffer.add(')) ');
       bailout(node, 'Not a mutable array');
     } else if (node.isReadableArray()) {
       // if (input is !Object
       //     || (input is !Array && input is !JsIndexingBehavior)) bailout
       buffer.add('if (');
-      binary("||",
-             () => checkObject(input, '!=='),
-             () => binary("&&",
-                          () => checkArray(input, '!=='),
-                          () => checkType(input, indexingBehavior,
-                                          negative: true)));
-      buffer.add(') ');
+      checkObject(input, '!==');
+      buffer.add(' || (');
+      checkArray(input, '!==');
+      buffer.add(' && ');
+      checkType(input, indexingBehavior, negative: true);
+      buffer.add(')) ');
       bailout(node, 'Not an array');
     } else if (node.isIndexablePrimitive()) {
       // if (input is !String
       //     && (input is !Object
       //         || (input is !Array && input is !JsIndexingBehavior))) bailout
       buffer.add('if (');
-      binary("&&",
-             () => checkString(input, '!=='),
-             () => binary("||",
-                          () => checkObject(input, '!=='),
-                          () => binary("&&",
-                                       () => checkArray(input, '!=='),
-                                       () => checkType(input,
-                                                       indexingBehavior,
-                                                       negative: true))));
-      buffer.add(') ');
+      checkString(input, '!==');
+      buffer.add(' && (');
+      checkObject(input, '!==');
+      buffer.add(' || (');
+      checkArray(input, '!==');
+      buffer.add(' && ');
+      checkType(input, indexingBehavior, negative: true);
+      buffer.add('))) ');
       bailout(node, 'Not a string or array');
     } else {
       compiler.internalError('Unexpected type guard', instruction: input);
     }
     buffer.add(';\n');
   }
 
   void beginLoop(HBasicBlock block) {
     addIndentation();
     HLoopInformation info = block.loopInformation;
@@ skipping 245 matching lines @@
     int elseKind = analyzeGraphForCodegen(elseGraph);
     bool emptyElse = !node.hasElse || elseKind == SsaCodeGenerator.EMPTY;
 
     startBailoutCase(thenGraph.start.guards,
         node.hasElse ? elseGraph.start.guards : const <HTypeGuard>[]);
 
     addIndented('if (');
     int precedence = JSPrecedence.EXPRESSION_PRECEDENCE;
     // TODO(ngeoffray): Put the condition initialization in the
     // [setup] buffer.
+    List<HTypeGuard> guards = node.thenBlock.guards;
+    for (int i = 0, len = guards.length; i < len; i++) {
+      buffer.add('state == ${guards[i].state} || ');
+    }
+    buffer.add('(state == 0 && ');
+    precedence = JSPrecedence.BITWISE_OR_PRECEDENCE;
+    use(node.inputs[0], precedence);
 
-    void stateTest() {
-      binary("&&",
-             () => binary("==", () => literal("state"), () => literal("0")),
-             () => use(node.inputs[0], expectedPrecedence));
-    }
-
-    List<HTypeGuard> guards = node.thenBlock.guards;
-    if (guards.length > 0) {
-      // Fold guards from the left using '||'.
-      Function buildGuard(int i) => () {
-        binary("==",
-               () => literal("state"),
-               () => literal("${guards[i].state}"));
-      }
-      Function guard = buildGuard(0);
-      for (int i = 1, len = guards.length; i < len; i++) {
-        int index = i;
-        Function oldGuard = guard;
-        guard = () => binary("||", oldGuard, buildGuard(index));
-      }
-      binary("||", guard, stateTest);
-    } else {
-      stateTest();
-    }
-
-    buffer.add(') {\n');
+    buffer.add(')) {\n');
 
     indent++;
     if (thenHasGuards) startBailoutSwitch();
     generateStatements(thenGraph);
     if (thenHasGuards) endBailoutSwitch();
     indent--;
 
     if (!emptyElse) {
       addIndented('} else {\n');
       indent++;
@@ skipping 19 matching lines @@
       startBailoutSwitch();
     }
   }
 
   void endLabeledBlock(HLabeledBlockInformation labeledBlockInfo) {
     if (labeledBlockInfo.body.start.hasGuards()) {
       endBailoutSwitch();
     }
   }
 }