Add JavaScript AST.

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';
   NativeEmitter get nativeEmitter() => backend.emitter.nativeEmitter;
 
 
-  CodeBuffer buildJavaScriptFunction(FunctionElement element,
-                                     String parameters,
-                                     CodeBuffer body) {
-    String extraSpace = "";
-    // Members are emitted inside a JavaScript object literal. To line up the
-    // indentation we want the closing curly brace to be indented by one space.
-    // Example:
-    // defineClass("A", "B", ... , {
-    //  foo$1: function(..) {
-    //  },  /* <========== indent by 1. */
-    //  bar$2: function(..) {
-    //  },  /* <========== indent by 1. */
-    //
-    // For static functions this is not necessary:
-    // $.staticFun = function() {
-    //   ...
-    // };
-    if (element.isInstanceMember() ||
-        element.kind == ElementKind.GENERATIVE_CONSTRUCTOR_BODY) {
-      extraSpace = " ";
-    }
+  js.Fun buildJavaScriptFunction(FunctionElement element,
+                                 List<js.Parameter> parameters,
+                                 js.Block body) {
+    FunctionExpression expression = element.cachedNode;
+    js.Fun result = new js.Fun(parameters, body);
+    result.sourcePosition = expression.getBeginToken();
+    result.endSourcePosition = expression.getEndToken();
+    return result;
+  }
 
-    FunctionExpression expression = element.cachedNode;
-    CodeBuffer buffer = new CodeBuffer();
-    buffer.setSourceLocation(element, expression.getBeginToken());
-    buffer.add('function($parameters) {\n');
-    buffer.add(body);
-    buffer.add(extraSpace);
-    buffer.setSourceLocation(element, expression.getEndToken());
-    buffer.add('}');
-    return buffer;
+  CodeBuffer prettyPrint(js.Node node, Element positionElement) {
+    return js.prettyPrint(node, compiler, positionElement);
   }
 
   CodeBuffer generateMethod(WorkItem work, HGraph graph) {
     return measure(() {
       compiler.tracer.traceGraph("codegen", graph);
       Map<Element, String> parameterNames = getParameterNames(work);
       parameterNames.forEach((element, name) {
         compiler.enqueuer.codegen.addToWorkList(element);
       });
-      String parameters = Strings.join(parameterNames.getValues(), ', ');
+      List<js.Parameter> parameters = <js.Parameter>[];
+      parameterNames.forEach((element, name) {
+        parameters.add(new js.Parameter(name));
+      });
+      String parametersString = Strings.join(parameterNames.getValues(), ", ");
       SsaOptimizedCodeGenerator codegen = new SsaOptimizedCodeGenerator(
           backend, work, parameters, parameterNames);
       codegen.visitGraph(graph);
 
       FunctionElement element = work.element;
-      CodeBuffer code;
+      js.Block body;
       if (element.isInstanceMember()
           && element.enclosingElement.isClass()
           && element.enclosingElement.isNative()
           && native.isOverriddenMethod(
               element, element.enclosingElement, nativeEmitter)) {
         // Record that this method is overridden. In case of optional
         // arguments, the emitter will generate stubs to handle them,
         // and needs to know if the method is overridden.
         nativeEmitter.overriddenMethods.add(element);
         StringBuffer buffer = new StringBuffer();
+        String codeString = prettyPrint(codegen.body, work.element).toString();
         native.generateMethodWithPrototypeCheckForElement(
-            compiler, buffer, element, '${codegen.buffer}', parameters);
-        code = new CodeBuffer();
-        code.add(buffer);
+            compiler, buffer, element, codeString, parametersString);
+        js.Node blob = new js.LiteralStatement(buffer.toString());
+        body = new js.Block(<js.Statement>[new js.ExpressionStatement(blob)]);
       } else {
-        code = codegen.buffer;
+        body = codegen.body;
       }
-      return buildJavaScriptFunction(element, parameters, code);
+      js.Fun fun = buildJavaScriptFunction(element, parameters, body);
+      return prettyPrint(fun, work.element);
     });
   }
 
   CodeBuffer generateBailoutMethod(WorkItem work, HGraph graph) {
     return measure(() {
       compiler.tracer.traceGraph("codegen-bailout", graph);
 
       Map<Element, String> parameterNames = getParameterNames(work);
-      String parameters = Strings.join(parameterNames.getValues(), ', ');
+      List<js.Parameter> parameters = <js.Parameter>[];
+      parameterNames.forEach((element, name) {
+        parameters.add(new js.Parameter(name));
+      });
       SsaUnoptimizedCodeGenerator codegen = new SsaUnoptimizedCodeGenerator(
           backend, work, parameters, parameterNames);
       codegen.visitGraph(graph);
 
-      CodeBuffer code = new CodeBuffer();
-      code.add(codegen.setup);
-      code.add(codegen.buffer);
-      return buildJavaScriptFunction(
-          work.element, codegen.newParameters.toString(), code);
+      js.Block body = new js.Block(<js.Statement>[]);
+      body.statements.add(codegen.setup);
+      body.statements.add(codegen.body);
+      js.Fun fun =
+          buildJavaScriptFunction(work.element, codegen.newParameters, body);
+      return prettyPrint(fun, work.element);
     });
   }
 
   Map<Element, String> getParameterNames(WorkItem work) {
     Map<Element, String> parameterNames = new LinkedHashMap<Element, String>();
     FunctionElement function = work.element;
 
     // The dom/html libraries have inline JS code that reference
     // parameter names directly. Long-term such code will be rejected.
     // Now, just don't mangle the parameter name.
     function.computeSignature(compiler).forEachParameter((Element element) {
       parameterNames[element] = function.isNative()
           ? element.name.slowToString()
           : JsNames.getValid('${element.name.slowToString()}');
     });
     return parameterNames;
   }
 }
 
 typedef void ElementAction(Element element);
 
 class SsaCodeGenerator implements HVisitor, HBlockInformationVisitor {
   /**
-   * Current state for generating simple (non-local-control) code.
-   * It is generated as either statements (indented and ';'-terminated),
-   * expressions (comma separated) or declarations (also comma separated,
-   * but expected to be preceeded by a 'var' so it declares its variables);
-   */
-  static final int STATE_STATEMENT = 0;
-  static final int STATE_FIRST_EXPRESSION = 1;
-  static final int STATE_FIRST_DECLARATION = 2;
-  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;
-
-  /**
    * 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
    *   variable = expression
    * which are also valid as parts of a "var" declaration.
    */
   static final int TYPE_STATEMENT = 0;
   static final int TYPE_EXPRESSION = 1;
   static final int TYPE_DECLARATION = 2;
 
+  /**
+   * Whether we are currently generating expressions instead of statements.
+   * This includes declarations, which are generated as expressions.
+   */
+  bool isGeneratingExpression = false;
+
   final JavaScriptBackend backend;
   final WorkItem work;
-  final CodeBuffer buffer;
-  final String parameters;
 
   final Set<HInstruction> generateAtUseSite;
   final Set<HInstruction> controlFlowOperators;
   final Map<Element, ElementAction> breakAction;
   final Map<Element, ElementAction> continueAction;
   final Map<Element, String> parameterNames;
 
+  js.Block currentContainer;
+  js.Block get body() => currentContainer;
+  List<js.Expression> expressionStack;
+  List<js.Block> oldContainerStack;
+
   /**
    * Contains the names of the instructions, as well as the parallel
    * copies to perform on block transitioning.
    */
   VariableNames variableNames;
 
   /**
    * While generating expressions, we can't insert variable declarations.
    * Instead we declare them at the end of the function
    */
   final Set<String> delayedVariableDeclarations;
 
   /**
    * 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;
   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 10 matching lines @@
       int value =
           ((instruction as HConstant).constant as PrimitiveConstant).value;
       if (value >= 0 && value < (1 << 31)) {
         return true;
       }
     }
     return false;
   }
 
   bool hasNonBitOpUser(HInstruction instruction, Set<HPhi> phiSet) {
-    for (HInstruction use in instruction.usedBy) {
-      if (use is HPhi) {
-        if (!phiSet.contains(use)) {
-          phiSet.add(use);
-          if (hasNonBitOpUser(use, phiSet)) return true;
+    for (HInstruction user in instruction.usedBy) {
+      if (user is HPhi) {
+        if (!phiSet.contains(user)) {
+          phiSet.add(user);
+          if (hasNonBitOpUser(user, phiSet)) return true;
         }
-      } else if (use is! HBitNot && use is! HBinaryBitOp) {
+      } else if (user is! HBitNot && user is! HBinaryBitOp) {
         return true;
       }
     }
     return false;
   }
 
   // We want the outcome of bit-operations to be positive. However, if
   // the result of a bit-operation is only used by other bit
   // operations we do not have to convert to an unsigned
   // integer. Also, if we are using & with a positive constant we know
   // that the result is positive already and need no conversion.
   bool requiresUintConversion(HInstruction instruction) {
     if (instruction is HBitAnd &&
         (isNonNegativeInt32Constant((instruction as HBitAnd).left) ||
          isNonNegativeInt32Constant((instruction as HBitAnd).right))) {
       return false;
     }
     return hasNonBitOpUser(instruction, new Set<HPhi>());
   }
 
+  /**
+   * If the [instruction] is not `null` it will be used to attach the position
+   * to the [statement].
+   */
+  void pushStatement(js.Statement statement, [HInstruction instruction]) {
+    assert(expressionStack.isEmpty());
+    if (instruction != null) {
+      attachLocation(statement, instruction);
+    }
+    currentContainer.statements.add(statement);
+  }
+
+  /**
+   * If the [instruction] is not `null` it will be used to attach the position
+   * to the [expression].
+   */
+  pushExpressionAsStatement(js.Expression expression,
+                            [HInstruction instruction]) {
+    pushStatement(new js.ExpressionStatement(expression), instruction);
+  }
+
+  /**
+   * If the [instruction] is not `null` it will be used to attach the position
+   * to the [expression].
+   */
+  push(js.Expression expression, [HInstruction instruction]) {
+    if (instruction != null) {
+      attachLocation(expression, instruction);
+    }
+    expressionStack.add(expression);
+  }
+
+  js.Expression pop() {
+    return expressionStack.removeLast();
+  }
+
+  attachLocationToLast(HInstruction instruction) {
+    attachLocation(expressionStack.last(), instruction);
+  }
+
+  js.Node attachLocation(js.Node jsNode, HInstruction instruction) {
+    if (instruction.sourcePosition !== null) {
+      jsNode.sourcePosition = instruction.sourcePosition;
+    }
+    return jsNode;
+  }
+
+  js.Node attachLocationRange(js.Node jsNode, Node node) {
+    jsNode.sourcePosition = node.getBeginToken();
+    jsNode.endSourcePosition = node.getEndToken();
+    return jsNode;
+  }
+
   SsaCodeGenerator(this.backend,
                    this.work,
-                   this.parameters,
                    this.parameterNames)
     : declaredVariables = new Set<String>(),
       delayedVariableDeclarations = new Set<String>(),
-      buffer = new CodeBuffer(),
+      currentContainer = new js.Block.empty(),
+      expressionStack = <js.Expression>[],
+      oldContainerStack = <js.Block>[],
       generateAtUseSite = new Set<HInstruction>(),
       controlFlowOperators = new Set<HInstruction>(),
       breakAction = new Map<Element, ElementAction>(),
-      continueAction = new Map<Element, ElementAction>(),
-      unsignedShiftPrecedences = JSPrecedence.binary['>>>'] {
-  }
+      continueAction = new Map<Element, ElementAction>();
 
   abstract visitTypeGuard(HTypeGuard node);
   abstract visitBailoutTarget(HBailoutTarget node);
 
   abstract beginGraph(HGraph graph);
   abstract endGraph(HGraph graph);
 
   abstract beginLoop(HBasicBlock block);
   abstract endLoop(HBasicBlock block);
   abstract handleLoopCondition(HLoopBranch node);
 
   abstract preLabeledBlock(HLabeledBlockInformation labeledBlockInfo);
   abstract startLabeledBlock(HLabeledBlockInformation labeledBlockInfo);
   abstract endLabeledBlock(HLabeledBlockInformation labeledBlockInfo);
 
-  void beginExpression(int precedence) {
-    if (precedence < expectedPrecedence) {
-      buffer.add('(');
-    }
-  }
-
-  void endExpression(int precedence) {
-    if (precedence < expectedPrecedence) {
-      buffer.add(')');
-    }
-  }
-
-  void withPrecedence(int precedence, void action()) {
-    int oldPrecedence = expectedPrecedence;
-    beginExpression(precedence);
-    expectedPrecedence = precedence;
-    action();
-    expectedPrecedence = oldPrecedence;
-    endExpression(precedence);
-  }
-
   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,
         intervalBuilder.liveIntervals,
         generateAtUseSite,
         parameterNames);
     allocator.visitGraph(graph);
     variableNames = allocator.names;
   }
 
   visitGraph(HGraph graph) {
     preGenerateMethod(graph);
     currentGraph = graph;
     indent++;  // We are already inside a function.
     subGraph = new SubGraph(graph.entry, graph.exit);
     HBasicBlock start = beginGraph(graph);
     visitBasicBlock(start);
     if (!delayedVariableDeclarations.isEmpty()) {
-      addIndented("var ");
-      buffer.add(Strings.join(
-          new List<String>.from(delayedVariableDeclarations), ', '));
-      buffer.add(";\n");
+      List<js.VariableInitialization> declarations =
+          <js.VariableInitialization>[];
+      delayedVariableDeclarations.forEach((String name) {
+        declarations.add(new js.VariableInitialization(
+            new js.VariableDeclaration(name), null));
+      });
+      pushExpressionAsStatement(new js.VariableDeclarationList(declarations));
     }
     endGraph(graph);
   }
 
   void visitSubGraph(SubGraph newSubGraph) {
     SubGraph oldSubGraph = subGraph;
     subGraph = newSubGraph;
     visitBasicBlock(subGraph.start);
     subGraph = oldSubGraph;
   }
@@ skipping 76 matching lines @@
        (limits.end.last is HConditionalBranch);
   }
 
   /**
    * Generate statements from block information.
    * If the block information contains expressions, generate only
    * assignments, and if it ends in a conditional branch, don't generate
    * the condition.
    */
   void generateStatements(HBlockInformation block) {
-    int oldState = generationState;
-    generationState = STATE_STATEMENT;
     if (block is HStatementInformation) {
       block.accept(this);
     } else {
       HSubExpressionBlockInformation expression = block;
       visitSubGraph(expression.subExpression);
     }
-    generationState = oldState;
+  }
+
+  js.Block generateStatementsInNewBlock(HBlockInformation block) {
+    js.Block result = new js.Block.empty();
+    js.Block oldContainer = currentContainer;
+    currentContainer = result;
+    generateStatements(block);
+    currentContainer = oldContainer;
+    return result;
+  }
+
+  /**
+   * If the [block] only contains one statement returns that statement. If the
+   * that statement itself is a block, recursively calls this method.
+   *
+   * If the block is empty, returns a new instance of [js.NOP].
+   */
+  js.Statement unwrapStatement(js.Block block) {
+    int len = block.statements.length;
+    if (len == 0) return new js.EmptyStatement();
+    if (len == 1) {
+      js.Statement result = block.statements[0];
+      if (result is Block) return unwrapStatement(result);
+      return result;
+    }
+    return block;
   }
 
   /**
    * Generate expressions from block information.
    */
-  void generateExpression(HExpressionInformation expression) {
+  js.Expression generateExpression(HExpressionInformation expression) {
     // Currently we only handle sub-expression graphs.
     assert(expression is HSubExpressionBlockInformation);
-    // [visitSubGraph] will reset the [expectedPrecedence]. Make sure we don't
-    // need parenthesis. I.e., this only expects to be called for top-level
-    // expressions, not sub-expressions.
-    assert(expectedPrecedence == JSPrecedence.STATEMENT_PRECEDENCE
-        || expectedPrecedence == JSPrecedence.EXPRESSION_PRECEDENCE);
-
+
+    bool oldIsGeneratingExpression = isGeneratingExpression;
+    isGeneratingExpression = true;
+    List<js.Expression> oldExpressionStack = expressionStack;
+    List<js.Expression> sequenceElements = <js.Expression>[];
+    expressionStack = sequenceElements;
     HSubExpressionBlockInformation expressionSubGraph = expression;
-
-    int oldState = generationState;
-    generationState = STATE_FIRST_EXPRESSION;
     visitSubGraph(expressionSubGraph.subExpression);
-    generationState = oldState;
-  }
-
-  void generateDeclaration(HExpressionInformation expression) {
-    // Currently we only handle sub-expression graphs.
-    assert(expression is HSubExpressionBlockInformation);
-    HSubExpressionBlockInformation expressionSubGraph = expression;
-
-    int oldState = generationState;
-    generationState = STATE_FIRST_DECLARATION;
-    visitSubGraph(expressionSubGraph.subExpression);
-    generationState = oldState;
-  }
-
-  void generateCondition(HBlockInformation condition) {
-    generateExpression(condition);
+    expressionStack = oldExpressionStack;
+    isGeneratingExpression = oldIsGeneratingExpression;
+    if (sequenceElements.isEmpty()) {
+      // Happens when the initializer, condition or update of a loop is empty.
+      return null;
+    } else if (sequenceElements.length == 1) {
+      return sequenceElements[0];
+    } else {
+      return new js.Sequence(sequenceElements);
+    }
   }
 
   /**
     * Only visits the arguments starting at inputs[HInvoke.ARGUMENTS_OFFSET].
     */
-  void visitArguments(List<HInstruction> inputs) {
+  List<js.Expression> visitArguments(List<HInstruction> inputs) {
     assert(inputs.length >= HInvoke.ARGUMENTS_OFFSET);
-    buffer.add('(');
+    List<js.Expression> result = <js.Expression>[];
     for (int i = HInvoke.ARGUMENTS_OFFSET; i < inputs.length; i++) {
-      if (i != HInvoke.ARGUMENTS_OFFSET) buffer.add(', ');
-      use(inputs[i], JSPrecedence.ASSIGNMENT_PRECEDENCE);
-    }
-    buffer.add(')');
-  }
-
-  /**
-   * Whether we are currently generating expressions instead of statements.
-   * This includes declarations, which are generated as expressions.
-   */
-  bool isGeneratingExpression() {
-    return generationState != STATE_STATEMENT;
-  }
-
-  /**
-   * Whether we are generating a declaration.
-   */
-  bool isGeneratingDeclaration() {
-    return (generationState == STATE_DECLARATION ||
-            generationState == STATE_FIRST_DECLARATION);
-  }
-
-  /**
-   * Called before writing an expression.
-   * Ensures that expressions are comma spearated.
-   */
-  void addExpressionSeparator() {
-    if (generationState == STATE_FIRST_EXPRESSION) {
-      generationState = STATE_EXPRESSION;
-    } else if (generationState != STATE_FIRST_DECLARATION) {
-      buffer.add(", ");
-    }
-    // If the state is [STATE_FIRST_DECLARATION] the potential
-    // declaration of the variable will be done by the instruction.
+      use(inputs[i]);
+      result.add(pop());
+    }
+    return result;
   }
 
   bool isVariableDeclared(String variableName) {
     return declaredVariables.contains(variableName);
   }
 
-  void declareVariable(String variableName) {
-    if (isGeneratingExpression()) {
-      if (generationState == STATE_FIRST_DECLARATION) {
-        if (!isVariableDeclared(variableName)) {
-          declaredVariables.add(variableName);
-          buffer.add("var ");
-          generationState = STATE_DECLARATION;
-        } else {
-          generationState = STATE_EXPRESSION;
+  js.Expression generateExpressionAssignment(String variableName,
+                                             js.Expression value) {
+    if (value is js.Binary) {
+      js.Binary binary = value;
+      String op = binary.op;
+      if (op == '+' || op == '-' || op == '/' || op == '*' || op == '%' ||
+          op == '^' || op == '&' || op == '|') {
+        if (binary.left is js.VariableUse &&
+            (binary.left as js.VariableUse).name == variableName) {
+          // We know now, that we can shorten x = x + y into x += y.
+          // Also check for the shortcut where y equals 1: x++ and x--.
+          if ((op == '+' || op == '-') &&
+              binary.right is js.LiteralNumber &&
+              (binary.right as js.LiteralNumber).value == "1") {
+            return new js.Prefix(op == '+' ? '++' : '--', binary.left);
+          }
+          return new js.Assignment.compound(binary.left, op, binary.right);
         }
-
-      } else if (!isVariableDeclared(variableName)) {
-        if (!isGeneratingDeclaration()) {
-          delayedVariableDeclarations.add(variableName);
-        }
-        // No matter if we are declaring the variable now or if we are
-        // delaying the declaration we can treat the variable as
-        // being declared from this point on.
+      }
+    }
+    return new js.Assignment(new js.VariableUse(variableName), value);
+  }
+
+  void assignVariable(String variableName, js.Expression value) {
+    if (isGeneratingExpression) {
+      if (!isVariableDeclared(variableName)) {
+        delayedVariableDeclarations.add(variableName);
+        // We can treat the variable as being declared from this point on.
         declaredVariables.add(variableName);
       }
-    } else if (!isVariableDeclared(variableName)) {
+      push(generateExpressionAssignment(variableName, value));
+    } else if (!isVariableDeclared(variableName) ||
+               delayedVariableDeclarations.contains(variableName)) {
       declaredVariables.add(variableName);
-      buffer.add("var ");
-    }
-    buffer.add(variableName);
-  }
-
-  void declareInstruction(HInstruction instruction) {
-    declareVariable(variableNames.getName(instruction));
-  }
-
-  // For simple updates of the form 'i = i op constant' generate
-  // 'i op= constant' instead.
-  bool handleSimpleUpdateDefinition(HInstruction instruction, String name) {
-    // If the variable is not declared the short update syntax cannot
-    // be used since it is a declaration and not an update.
-    if (!isVariableDeclared(name)) return false;
-
-    // Check that the operation is one of +, *, - or /. Record whether
-    // or not the operation is commutative.
-    var isCommutative = false;
-    if (instruction is HAdd || instruction is HMultiply) {
-      isCommutative = true;
-    } else if (instruction is !HSubtract && instruction is !HDivide) {
-      return false;
-    }
-
-    // Is it a builtin operation involving +, -, /, or *?
-    HBinaryArithmetic binaryInstruction = instruction;
-    assert(binaryInstruction.inputs.length == 3);
-    if (binaryInstruction.builtin) {
-      var left = binaryInstruction.left;
-      var right = binaryInstruction.right;
-      if (isCommutative && variableNames.getName(right) == name) {
-        var tmp = right;
-        right = left;
-        left = tmp;
-      }
-
-      // Check that left has the same name as the definition and emit
-      // 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) {
-          beginExpression(JSPrecedence.PREFIX_PRECEDENCE);
-          buffer.add('++');
-          declareVariable(name);
-          endExpression(JSPrecedence.PREFIX_PRECEDENCE);
-        } else if (binaryInstruction is HSubtract && rightIsOne) {
-          beginExpression(JSPrecedence.PREFIX_PRECEDENCE);
-          buffer.add('--');
-          declareVariable(name);
-          endExpression(JSPrecedence.PREFIX_PRECEDENCE);
-        } else {
-          var operation = binaryInstruction.operation.name;
-          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;
+      delayedVariableDeclarations.remove(variableName);
+      js.VariableDeclaration decl = new js.VariableDeclaration(variableName);
+      js.VariableInitialization initialization =
+          new js.VariableInitialization(decl, value);
+
+      pushExpressionAsStatement(new js.VariableDeclarationList(
+          <js.VariableInitialization>[initialization]));
+    } else {
+      pushExpressionAsStatement(
+          generateExpressionAssignment(variableName, value));
+    }
   }
 
   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)) {
-        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) {
+    // For simple type checks like i = intTypeCheck(i), we don't have to
+    // emit an assignment, because the intTypeCheck just returns its
+    // argument.
+    bool needsAssignment = true;
+    if (instruction is HTypeConversion) {
+      String inputName = variableNames.getName(instruction.checkedInput);
+      if (variableNames.getName(instruction) == inputName) {
+        needsAssignment = false;
+      }
+    }
+
+    if (needsAssignment &&
+        !instruction.isControlFlow() && variableNames.hasName(instruction)) {
+      visitExpression(instruction);
+      assignVariable(variableNames.getName(instruction), pop());
+      return;
+    }
+
+    if (isGeneratingExpression) {
+      visitExpression(instruction);
+    } else {
+      visitStatement(instruction);
+    }
+  }
+
+  void use(HInstruction argument) {
     if (isGenerateAtUseSite(argument)) {
-      visit(argument, expectedPrecedenceForArgument);
+      visitExpression(argument);
     } else if (argument is HCheck && argument.isControlFlow()) {
       // A [HCheck] that has control flow can never be used as an
       // expression and may not have a name. Therefore we just use the
       // checked instruction.
       HCheck check = argument;
-      use(check.checkedInput, expectedPrecedenceForArgument);
-    } else {
-      buffer.add(variableNames.getName(argument));
-    }
-  }
-
-  visit(HInstruction node, int expectedPrecedenceForNode) {
-    int oldPrecedence = this.expectedPrecedence;
-    this.expectedPrecedence = expectedPrecedenceForNode;
-    if (node.sourcePosition !== null) {
-      buffer.setSourceLocation(work.element, node.sourcePosition);
-    }
+      use(check.checkedInput);
+    } else {
+      push(new js.VariableUse(variableNames.getName(argument)), argument);
+    }
+  }
+
+  visit(HInstruction node) {
     node.accept(this);
-    this.expectedPrecedence = oldPrecedence;
+  }
+
+  visitExpression(HInstruction node) {
+    bool oldIsGeneratingExpression = isGeneratingExpression;
+    isGeneratingExpression = true;
+    visit(node);
+    isGeneratingExpression = oldIsGeneratingExpression;
+  }
+
+  visitStatement(HInstruction node) {
+    assert(!isGeneratingExpression);
+    visit(node);
+    if (!expressionStack.isEmpty()) {
+      assert(expressionStack.length == 1);
+      pushExpressionAsStatement(pop());
+    }
   }
 
   void continueAsBreak(LabelElement target) {
-    addIndented("break ");
-    writeContinueLabel(target);
-    buffer.add(";\n");
+    pushStatement(new js.Break(compiler.namer.continueLabelName(target)));
   }
 
   void implicitContinueAsBreak(TargetElement target) {
-    addIndented("break ");
-    writeImplicitContinueLabel(target);
-    buffer.add(";\n");
+    pushStatement(new js.Break(
+        compiler.namer.implicitContinueLabelName(target)));
   }
 
   void implicitBreakWithLabel(TargetElement target) {
-    addIndented("break ");
-    writeImplicitLabel(target);
-    buffer.add(";\n");
-  }
+    pushStatement(new js.Break(compiler.namer.implicitBreakLabelName(target)));
+  }
+
+  js.Statement wrapIntoLabels(js.Statement result, List<LabelElement> labels) {
+    for (LabelElement label in labels) {
+      if (label.isTarget) {
+        String breakLabelString = compiler.namer.breakLabelName(label);
+        result = new js.LabeledStatement(breakLabelString, result);
+      }
+    }
+    return result;
+  }
+
 
   // The regular [visitIf] method implements the needed logic.
   bool visitIfInfo(HIfBlockInformation info) => false;
 
   bool visitSwitchInfo(HSwitchBlockInformation info) {
     bool isExpression = isJSExpression(info.expression);
     if (!isExpression) {
       generateStatements(info.expression);
     }
-    addIndentation();
-    for (LabelElement label in info.labels) {
-      if (label.isTarget) {
-        writeLabel(label);
-        buffer.add(":");
-      }
+
+    if (isExpression) {
+      push(generateExpression(info.expression));
+    } else {
+      use(info.expression.conditionExpression);
     }
-    buffer.add("switch (");
-    if (isExpression) {
-      generateExpression(info.expression);
-    } else {
-      use(info.expression.conditionExpression,
-          JSPrecedence.EXPRESSION_PRECEDENCE);
-    }
-    buffer.add(") {\n");
-    indent++;
+    js.Expression key = pop();
+    List<js.SwitchClause> cases = <js.SwitchClause>[];
+
+    js.Block oldContainer = currentContainer;
     for (int i = 0; i < info.matchExpressions.length; i++) {
       for (Constant constant in info.matchExpressions[i]) {
-        addIndented("case ");
         generateConstant(constant);
-        buffer.add(":\n");
+        currentContainer = new js.Block.empty();
+        cases.add(new js.Case(pop(), currentContainer));
       }
       if (i == info.matchExpressions.length - 1 && info.hasDefault) {
-        addIndented("default:\n");
+        currentContainer = new js.Block.empty();
+        cases.add(new js.Default(currentContainer));
       }
-      indent++;
       generateStatements(info.statements[i]);
-      indent--;
     }
-    indent--;
-    addIndented("}\n");
+    currentContainer = oldContainer;
+
+    js.Statement result = new js.Switch(key, cases);
+    pushStatement(wrapIntoLabels(result, info.labels));
     return true;
   }
 
   bool visitSequenceInfo(HStatementSequenceInformation info) {
     return false;
   }
 
   bool visitSubGraphInfo(HSubGraphBlockInformation info) {
     visitSubGraph(info.subGraph);
     return true;
   }
 
   bool visitSubExpressionInfo(HSubExpressionBlockInformation info) {
     return false;
   }
 
   bool visitAndOrInfo(HAndOrBlockInformation info) {
     return false;
   }
 
   bool visitTryInfo(HTryBlockInformation info) {
-    addIndented("try {\n");
-    indent++;
-    generateStatements(info.body);
-    indent--;
-    addIndented("}");
+    js.Block body = generateStatementsInNewBlock(info.body);
+    js.Catch catchPart = null;
+    js.Block finallyPart = null;
     if (info.catchBlock !== null) {
-      // Printing the catch part.
       HParameterValue exception = info.catchVariable;
       String name = variableNames.getName(exception);
       parameterNames[exception.sourceElement] = name;
-      buffer.add(' catch ($name) {\n');
-      indent++;
-      generateStatements(info.catchBlock);
-      parameterNames.remove(exception.sourceElement);
-      indent--;
-      addIndented('}');
+      js.VariableDeclaration decl = new js.VariableDeclaration(name);
+      js.Block catchBlock = generateStatementsInNewBlock(info.catchBlock);
+      catchPart = new js.Catch(decl, catchBlock);
     }
     if (info.finallyBlock != null) {
-      buffer.add(" finally {\n");
-      indent++;
-      generateStatements(info.finallyBlock);
-      indent--;
-      addIndented("}");
+      finallyPart = generateStatementsInNewBlock(info.finallyBlock);
     }
-    buffer.add("\n");
+    pushStatement(new js.Try(body, catchPart, finallyPart));
     return true;
   }
 
   void visitBodyIgnoreLabels(HLoopBlockInformation info) {
     if (info.body.start.isLabeledBlock()) {
       HBlockInformation oldInfo = currentBlockInformation;
       currentBlockInformation = info.body.start.blockFlow.body;
       generateStatements(info.body);
       currentBlockInformation = oldInfo;
     } else {
       generateStatements(info.body);
     }
   }
 
   bool visitLoopInfo(HLoopBlockInformation info) {
     HExpressionInformation condition = info.condition;
     bool isConditionExpression = isJSCondition(condition);
-    buffer.setSourceLocation(work.element, info.sourcePosition.getBeginToken());
+
+    js.Loop loop;
 
     switch (info.kind) {
       // Treate all three "test-first" loops the same way.
       case HLoopBlockInformation.FOR_LOOP:
       case HLoopBlockInformation.WHILE_LOOP:
       case HLoopBlockInformation.FOR_IN_LOOP: {
         HBlockInformation initialization = info.initializer;
         int initializationType = TYPE_STATEMENT;
         if (initialization !== null) {
           initializationType = expressionType(initialization);
           if (initializationType == TYPE_STATEMENT) {
             generateStatements(initialization);
             initialization = null;
           }
         }
-        for (LabelElement label in info.labels) {
-          if (label.isTarget) {
-            writeLabel(label);
-            buffer.add(":");
-          }
-        }
         if (isConditionExpression &&
             info.updates !== null && isJSExpression(info.updates)) {
           // If we have an updates graph, and it's expressible as an
           // expression, generate a for-loop.
-          addIndented("for (");
+          js.Expression jsInitialization = null;
           if (initialization !== null) {
-            if (initializationType != TYPE_DECLARATION) {
-              generateExpression(initialization);
-            } else {
-              generateDeclaration(initialization);
+            int delayedVariablesCount = delayedVariableDeclarations.length;
+            jsInitialization = generateExpression(initialization);
+            if (delayedVariablesCount < delayedVariableDeclarations.length) {
+              // We just added a new delayed variable-declaration. See if we
+              // can put in a 'var' in front of the initialization to make it
+              // go away.
+              List<js.Expression> expressions;
+              if (jsInitialization is js.Sequence) {
+                expressions = jsInitialization.expressions;
+              } else {
+                expressions = <js.Expression>[jsInitialization];
+              }
+              bool canTransformToVariableDeclaration = true;
+              for (js.Expression expression in expressions) {
+                bool expressionIsVariableAssignment = false;
+                if (expression is js.Assignment) {
+                  js.Assignment assignment = expression;
+                  if (assignment.leftHandSide is js.VariableUse &&
+                      assignment.compoundTarget == null) {
+                    expressionIsVariableAssignment = true;
+                  }
+                }
+                if (!expressionIsVariableAssignment) {
+                  canTransformToVariableDeclaration = false;
+                  break;
+                }
+              }
+              if (canTransformToVariableDeclaration) {
+                List<js.VariableInitialization> inits =
+                    <js.VariableInitialization>[];
+                for (js.Assignment assignment in expressions) {
+                  String id = (assignment.leftHandSide as js.VariableUse).name;
+                  js.Node declaration = new js.VariableDeclaration(id);
+                  inits.add(new js.VariableInitialization(declaration,
+                                                          assignment.value));
+                  delayedVariableDeclarations.remove(id);
+                }
+                jsInitialization = new js.VariableDeclarationList(inits);
+              }
             }
           }
-          buffer.add("; ");
-          generateCondition(condition);
-          buffer.add("; ");
-          generateExpression(info.updates);
-          buffer.add(") {\n");
-          indent++;
+          js.Expression jsCondition = generateExpression(condition);
+          js.Expression jsUpdates = generateExpression(info.updates);
           // The body might be labeled. Ignore this when recursing on the
           // subgraph.
           // TODO(lrn): Remove this extra labeling when handling all loops
           // using subgraphs.
+          js.Block oldContainer = currentContainer;
+          js.Statement body = new js.Block.empty();
+          currentContainer = body;
           visitBodyIgnoreLabels(info);
-
-          indent--;
+          currentContainer = oldContainer;
+          body = unwrapStatement(body);
+          loop = new js.For(jsInitialization, jsCondition, jsUpdates, body);
         } else {
           // We have either no update graph, or it's too complex to
           // put in an expression.
           if (initialization !== null) {
             generateStatements(initialization);
           }
-          addIndented("while (");
+          js.Expression jsCondition;
+          js.Block oldContainer = currentContainer;
+          js.Statement body = new js.Block.empty();
           if (isConditionExpression) {
-            generateCondition(condition);
-            buffer.add(") {\n");
-            indent++;
+            jsCondition = generateExpression(condition);
+            currentContainer = body;
           } else {
-            buffer.add("true) {\n");
-            indent++;
+            jsCondition = new js.LiteralBool(true);
+            currentContainer = body;
             generateStatements(condition);
-            addIndented("if (!");
-            use(condition.conditionExpression, JSPrecedence.PREFIX_PRECEDENCE);
-            buffer.add(") break;\n");
+            use(condition.conditionExpression);
+            js.Expression ifTest = new js.Prefix("!", pop());
+            js.Break jsBreak = new js.Break(null);
+            pushStatement(new js.If.then(ifTest, jsBreak));
           }
           if (info.updates !== null) {
             wrapLoopBodyForContinue(info);
             generateStatements(info.updates);
           } else {
             visitBodyIgnoreLabels(info);
           }
-          indent--;
+          currentContainer = oldContainer;
+          body = unwrapStatement(body);
+          loop = new js.While(jsCondition, body);
         }
-        addIndented("}\n");
         break;
       }
       case HLoopBlockInformation.DO_WHILE_LOOP: {
         // Generate do-while loop in all cases.
         if (info.initializer !== null) {
           generateStatements(info.initializer);
         }
-        addIndentation();
-        for (LabelElement label in info.labels) {
-          if (label.isTarget) {
-            writeLabel(label);
-            buffer.add(":");
-          }
-        }
-        buffer.add("do {\n");
-        indent++;
+        js.Block oldContainer = currentContainer;
+        js.Statement body = new js.Block.empty();
+        currentContainer = body;
         if (!isConditionExpression || info.updates !== null) {
           wrapLoopBodyForContinue(info);
         } else {
           visitBodyIgnoreLabels(info);
         }
         if (info.updates !== null) {
           generateStatements(info.updates);
         }
         if (isConditionExpression) {
-          indent--;
-          addIndented("} while (");
-          generateExpression(condition);
-          buffer.add(");\n");
+          push(generateExpression(condition));
         } else {
           generateStatements(condition);
-          indent--;
-          addIndented("} while (");
-          use(condition.conditionExpression, JSPrecedence.PREFIX_PRECEDENCE);
-          buffer.add(");\n");
+          use(condition.conditionExpression);
         }
+        js.Expression jsCondition = pop();
+        currentContainer = oldContainer;
+        body = unwrapStatement(body);
+        loop = new js.Do(body, jsCondition);
         break;
       }
       default:
         compiler.internalError(
           'Unexpected loop kind: ${info.kind}',
           instruction: condition.conditionExpression);
     }
-    buffer.setSourceLocation(work.element, info.sourcePosition.getEndToken());
+    attachLocationRange(loop, info.sourcePosition);
+    pushStatement(wrapIntoLabels(loop, info.labels));
     return true;
   }
 
   bool visitLabeledBlockInfo(HLabeledBlockInformation labeledBlockInfo) {
     preLabeledBlock(labeledBlockInfo);
-    addIndentation();
     Link<Element> continueOverrides = const EmptyLink<Element>();
+
+    js.Block oldContainer = currentContainer;
+    js.Block body = new js.Block.empty();
+    js.Statement result = body;
+
+    currentContainer = body;
+
     // If [labeledBlockInfo.isContinue], the block is an artificial
     // block around the body of a loop with an update block, so that
     // continues of the loop can be written as breaks of the body
     // block.
     if (labeledBlockInfo.isContinue) {
       for (LabelElement label in labeledBlockInfo.labels) {
         if (label.isContinueTarget) {
-          writeContinueLabel(label);
-          buffer.add(':');
+          String labelName = compiler.namer.continueLabelName(label);
+          result = new js.LabeledStatement(labelName, result);
           continueAction[label] = continueAsBreak;
           continueOverrides = continueOverrides.prepend(label);
         }
       }
       // For handling unlabeled continues from the body of a loop.
       // TODO(lrn): Consider recording whether the target is in fact
       // a target of an unlabeled continue, and not generate this if it isn't.
       TargetElement target = labeledBlockInfo.target;
-      writeImplicitContinueLabel(target);
-      buffer.add(':');
+      String labelName = compiler.namer.implicitContinueLabelName(target);
+      result = new js.LabeledStatement(labelName, result);
       continueAction[target] = implicitContinueAsBreak;
       continueOverrides = continueOverrides.prepend(target);
     } else {
       for (LabelElement label in labeledBlockInfo.labels) {
         if (label.isBreakTarget) {
-          writeLabel(label);
-          buffer.add(':');
+          String labelName = compiler.namer.breakLabelName(label);
+          result = new js.LabeledStatement(labelName, result);
         }
       }
       TargetElement target = labeledBlockInfo.target;
       if (target.isSwitch) {
         // This is an extra block around a switch that is generated
         // as a nested if/else chain. We add an extra break target
         // so that case code can break.
-        writeImplicitLabel(target);
-        buffer.add(':');
+        String labelName = compiler.namer.implicitBreakLabelName(target);
+        result = new js.LabeledStatement(labelName, result);
         breakAction[target] = implicitBreakWithLabel;
       }
     }
-    buffer.add('{\n');
-    indent++;
 
+    currentContainer = body;
     startLabeledBlock(labeledBlockInfo);
     generateStatements(labeledBlockInfo.body);
     endLabeledBlock(labeledBlockInfo);
 
-    indent--;
-    addIndented('}\n');
-
     if (labeledBlockInfo.isContinue) {
       while (!continueOverrides.isEmpty()) {
         continueAction.remove(continueOverrides.head);
         continueOverrides = continueOverrides.tail;
       }
     } else {
       breakAction.remove(labeledBlockInfo.target);
     }
+
+    currentContainer = oldContainer;
+    pushStatement(result);
     return true;
   }
 
   // Wraps a loop body in a block to make continues have a target to break
   // to (if necessary).
   void wrapLoopBodyForContinue(HLoopBlockInformation info) {
     TargetElement target = info.target;
     if (target !== null && target.isContinueTarget) {
-      addIndentation();
+      js.Block oldContainer = currentContainer;
+      js.Block body = new js.Block.empty();
+      currentContainer = body;
+      js.Statement result = body;
       for (LabelElement label in info.labels) {
         if (label.isContinueTarget) {
-          writeContinueLabel(label);
-          buffer.add(":");
+          String labelName = compiler.namer.continueLabelName(label);
+          result = new js.LabeledStatement(labelName, result);
           continueAction[label] = continueAsBreak;
         }
       }
-      writeImplicitContinueLabel(target);
-      buffer.add(":{\n");
+      String labelName = compiler.namer.implicitContinueLabelName(target);
+      result = new js.LabeledStatement(labelName, result);
       continueAction[info.target] = implicitContinueAsBreak;
-      indent++;
       visitBodyIgnoreLabels(info);
-      indent--;
-      addIndented("}\n");
       continueAction.remove(info.target);
       for (LabelElement label in info.labels) {
         if (label.isContinueTarget) {
           continueAction.remove(label);
         }
       }
+      currentContainer = oldContainer;
+      pushStatement(result);
     } else {
       // Loop body contains no continues, so we don't need a break target.
       generateStatements(info.body);
     }
   }
 
   bool handleBlockFlow(HBlockFlow block) {
     HBlockInformation info = block.body;
     // If we reach here again while handling the attached information,
     // e.g., because we call visitSubGraph on a subgraph starting on
@@ skipping 29 matching lines @@
     }
     // Flow based traversal.
     if (node.isLoopHeader() &&
         node.loopInformation.loopBlockInformation !== currentBlockInformation) {
       beginLoop(node);
     }
     iterateBasicBlock(node);
   }
 
   void emitAssignment(String destination, String source) {
-    if (isGeneratingExpression()) {
-      addExpressionSeparator();
-    } else {
-      addIndentation();
-    }
-    declareVariable(destination);
-    buffer.add(' = $source');
-    if (!isGeneratingExpression()) {
-      buffer.add(';\n');
-    }
+    assignVariable(destination, new js.VariableUse(source));
   }
 
   /**
    * Sequentialize a list of conceptually parallel copies. Parallel
    * copies may contain cycles, that this method breaks.
    */
   void sequentializeCopies(List<Copy> copies) {
     // Map to keep track of the current location (ie the variable that
     // holds the initial value) of a variable.
     Map<String, String> currentLocation = new Map<String, String>();
@@ skipping 72 matching lines @@
     }
   }
 
   void assignPhisOfSuccessors(HBasicBlock node) {
     CopyHandler handler = variableNames.getCopyHandler(node);
     if (handler == null) return;
 
     sequentializeCopies(handler.copies);
 
     for (Copy copy in handler.assignments) {
-      if (isGeneratingExpression()) {
-        addExpressionSeparator();
-      } else {
-        addIndentation();
-      }
       String name = variableNames.getName(copy.destination);
-      if (!handleSimpleUpdateDefinition(copy.source, name)) {
-        declareVariable(name);
-        buffer.add(' = ');
-        use(copy.source, JSPrecedence.ASSIGNMENT_PRECEDENCE);
-      }
-      if (!isGeneratingExpression()) {
-        buffer.add(';\n');
-      }
+      use(copy.source);
+      assignVariable(name, pop());
     }
   }
 
   void iterateBasicBlock(HBasicBlock node) {
     HInstruction instruction = node.first;
     while (instruction !== node.last) {
       if (instruction is HTypeGuard || instruction is HBailoutTarget) {
-        visit(instruction, JSPrecedence.STATEMENT_PRECEDENCE);
+        visit(instruction);
       } else if (!isGenerateAtUseSite(instruction)) {
-        expectedPrecedence = JSPrecedence.STATEMENT_PRECEDENCE;
         define(instruction);
       }
       instruction = instruction.next;
     }
     assignPhisOfSuccessors(node);
-    if (instruction is HLoopBranch && isGeneratingExpression()) {
-      addExpressionSeparator();
-    }
-    visit(instruction, JSPrecedence.STATEMENT_PRECEDENCE);
+    visit(instruction);
   }
 
   visitInvokeBinary(HInvokeBinary node, String op) {
     if (node.builtin) {
-      JSBinaryOperatorPrecedence operatorPrecedences = JSPrecedence.binary[op];
-      beginExpression(operatorPrecedences.precedence);
-      use(node.left, operatorPrecedences.left);
-      buffer.add(' $op ');
-      use(node.right, operatorPrecedences.right);
-      endExpression(operatorPrecedences.precedence);
+      use(node.left);
+      js.Expression jsLeft = pop();
+      use(node.right);
+      push(new js.Binary(op, jsLeft, pop()), node);
     } 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) {
+    visitInvokeBinary(node, op);
     if (node.builtin && requiresUintConversion(node)) {
-      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);
+      push(new js.Binary(">>>", pop(), new js.LiteralNumber("0")), node);
     }
   }
 
   visitInvokeUnary(HInvokeUnary node, String op) {
     if (node.builtin) {
-      beginExpression(JSPrecedence.PREFIX_PRECEDENCE);
-      buffer.add('$op');
-      use(node.operand, JSPrecedence.PREFIX_PRECEDENCE);
-      endExpression(JSPrecedence.PREFIX_PRECEDENCE);
+      use(node.operand);
+      push(new js.Prefix(op, pop()), node);
     } 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) {
+    visitInvokeUnary(node, op);
     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);
+      push(new js.Binary(">>>", pop(), new js.LiteralNumber("0")), node);
     }
   }
 
   void emitIdentityComparison(HInstruction left, HInstruction right) {
     String op = singleIdentityComparison(left, right);
     if (op != null) {
-      beginExpression(JSPrecedence.EQUALITY_PRECEDENCE);
-      use(left, JSPrecedence.EQUALITY_PRECEDENCE);
-      buffer.add(' $op ');
-      use(right, JSPrecedence.RELATIONAL_PRECEDENCE);
-      endExpression(JSPrecedence.EQUALITY_PRECEDENCE);
+      use(left);
+      js.Expression jsLeft = pop();
+      use(right);
+      push(new js.Binary(op, jsLeft, pop()));
     } else {
       assert(NullConstant.JsNull == 'null');
-      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);
-        });
-      });
+      use(left);
+      js.Binary leftEqualsNull =
+          new js.Binary("==", pop(), new js.LiteralNull());
+      use(right);
+      js.Binary rightEqualsNull =
+          new js.Binary("==", pop(), new js.LiteralNull());
+      use(right);
+      use(left);
+      js.Binary tripleEq = new js.Binary("===", pop(), pop());
+
+      push(new js.Conditional(leftEqualsNull, rightEqualsNull, tripleEq));
     }
   }
 
   visitEquals(HEquals node) {
     if (node.builtin) {
       emitIdentityComparison(node.left, node.right);
     } else {
       visitInvokeStatic(node);
     }
   }
@@ skipping 20 matching lines @@
   visitShiftLeft(HShiftLeft node)   => visitBitInvokeBinary(node, '<<');
 
   visitNegate(HNegate node)         => visitInvokeUnary(node, '-');
 
   visitLess(HLess node)                 => visitInvokeBinary(node, '<');
   visitLessEqual(HLessEqual node)       => visitInvokeBinary(node, '<=');
   visitGreater(HGreater node)           => visitInvokeBinary(node, '>');
   visitGreaterEqual(HGreaterEqual node) => visitInvokeBinary(node, '>=');
 
   visitBoolify(HBoolify node) {
-    beginExpression(JSPrecedence.EQUALITY_PRECEDENCE);
     assert(node.inputs.length == 1);
-    use(node.inputs[0], JSPrecedence.EQUALITY_PRECEDENCE);
-    buffer.add(' === true');
-    endExpression(JSPrecedence.EQUALITY_PRECEDENCE);
+    use(node.inputs[0]);
+    push(new js.Binary('===', pop(), new js.LiteralBool(true)), node);
   }
 
   visitExit(HExit node) {
     // Don't do anything.
   }
 
   visitGoto(HGoto node) {
     assert(currentBlock.successors.length == 1);
     List<HBasicBlock> dominated = currentBlock.dominatedBlocks;
     // With the exception of the entry-node which dominates its successor
     // and the exit node, no block finishing with a 'goto' can have more than
     // one dominated block (since it has only one successor).
     // If the successor is dominated by another block, then the other block
     // is responsible for visiting the successor.
     if (dominated.isEmpty()) return;
     if (dominated.length > 2) {
       compiler.internalError('dominated.length = ${dominated.length}',
                              instruction: node);
     }
     if (dominated.length == 2 && currentBlock !== currentGraph.entry) {
       compiler.internalError('currentBlock !== currentGraph.entry',
                              instruction: node);
     }
     assert(dominated[0] == currentBlock.successors[0]);
     visitBasicBlock(dominated[0]);
   }
 
-  // Used to write the name of labels.
-  void writeLabel(LabelElement label) {
-    buffer.add('\$${label.labelName}\$${label.target.nestingLevel}');
-  }
-
-  void writeImplicitLabel(TargetElement target) {
-    buffer.add('\$${target.nestingLevel}');
-  }
-
-  // We sometimes handle continue targets differently from break targets,
-  // so we have special continue-only labels.
-  void writeContinueLabel(LabelElement label) {
-    buffer.add('c\$${label.labelName}\$${label.target.nestingLevel}');
-  }
-
-  void writeImplicitContinueLabel(TargetElement target) {
-    buffer.add('c\$${target.nestingLevel}');
-  }
-
   /**
    * Checks if [map] contains an [ElementAction] for [element], and
    * if so calls that action and returns true.
    * Otherwise returns false.
    */
   bool tryCallAction(Map<Element, ElementAction> map, Element element) {
     ElementAction action = map[element];
     if (action === null) return false;
     action(element);
     return true;
   }
 
   visitBreak(HBreak node) {
     assert(currentBlock.successors.length == 1);
     if (node.label !== null) {
       LabelElement label = node.label;
       if (!tryCallAction(breakAction, label)) {
-        addIndented("break ");
-        writeLabel(label);
-        buffer.add(";\n");
+        pushStatement(new js.Break(compiler.namer.breakLabelName(label)), node);
       }
     } else {
       TargetElement target = node.target;
       if (!tryCallAction(breakAction, target)) {
-        addIndented("break;\n");
+        pushStatement(new js.Break(null), node);
       }
     }
   }
 
   visitContinue(HContinue node) {
     assert(currentBlock.successors.length == 1);
     if (node.label !== null) {
       LabelElement label = node.label;
       if (!tryCallAction(continueAction, label)) {
-        addIndented("continue ");
-        writeLabel(label);
-        buffer.add(";\n");
+        // TODO(floitsch): should this really be the breakLabelName?
+        pushStatement(new js.Continue(compiler.namer.breakLabelName(label)),
+                      node);
       }
     } else {
       TargetElement target = node.target;
       if (!tryCallAction(continueAction, target)) {
-        addIndented("continue;\n");
+        pushStatement(new js.Continue(null), node);
       }
     }
   }
 
   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);
   }
 
-  /**
-   * 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;
-
-    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)) {
-        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
-      // not empty.
-      for (Copy copy in handler.copies) {
-        String sourceName = variableNames.getName(copy.source);
-        String destinationName = variableNames.getName(copy.destination);
-        if (sourceName != destinationName) {
-          if (!updateKind(ONE_STATEMENT)) return MULTIPLE_STATEMENTS;
-        }
-      }
-    }
-    return kind;
-  }
-
   bool tryControlFlowOperation(HIf node) {
     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
         && 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) {
+    use(node.inputs[0]);
+    js.Expression test = pop();
+
     HStatementInformation thenGraph = info.thenGraph;
     HStatementInformation elseGraph = info.elseGraph;
-    int thenKind = analyzeGraphForCodegen(thenGraph);
-    int elseKind = analyzeGraphForCodegen(elseGraph);
+    js.Statement thenPart =
+        unwrapStatement(generateStatementsInNewBlock(thenGraph));
+    js.Statement elsePart =
+        unwrapStatement(generateStatementsInNewBlock(elseGraph));
 
-    void visitWithoutIndent(HStatementInformation toVisit) {
-      int oldIndent = indent;
-      indent = 0;
-      generateStatements(toVisit);
-      indent = oldIndent;
-    }
-
-    void visitExpression(HStatementInformation toVisit) {
-      // [generateExpression] only works if the [expectedPrecedence] is a
-      // statement or an expression. We therefore have to duplicate some
-      // work here.
-      assert(toVisit.start == toVisit.end);
-      assert(toVisit.start.last is HGoto);
-      // Find the expression (there must only be one).
-      HInstruction expression = toVisit.start.first;
-      while (generateAtUseSite.contains(expression)) {
-        expression = expression.next;
-      }
-      assert(() {
-        HInstruction remaining = expression.next;
-        while (remaining is !HGoto) {
-          if (!generateAtUseSite.contains(remaining)) return false;
-          remaining = remaining.next;
-        }
-        return true;
-      });
-
-      int oldState = generationState;
-      generationState = STATE_FIRST_EXPRESSION;
-      define(expression);
-      generationState = oldState;
-    }
-
-    void visitWithIndent(HStatementInformation toVisit) {
-      buffer.add('{\n');
-      indent++;
-      generateStatements(toVisit);
-      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();
-      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) {
-          case EMPTY:
-            if (isGenerateAtUseSite(node.inputs[0])) {
-              addIndentation();
-              use(node.inputs[0], JSPrecedence.STATEMENT_PRECEDENCE);
-              buffer.add(';\n');
-            }
-            break;
-
-          case ONE_EXPRESSION:
-            generateAnd(elseGraph, () { generateNot(node.inputs[0]); });
-            break;
-
-          case ONE_STATEMENT:
-            addIndented('if (');
-            generateNot(node.inputs[0]);
-            buffer.add(') ');
-            visitWithoutIndent(elseGraph);
-            break;
-
-          case MULTIPLE_STATEMENTS:
-            addIndented('if (');
-            generateNot(node.inputs[0]);
-            buffer.add(') ');
-            visitWithIndent(elseGraph);
-            buffer.add('\n');
-            break;
-        }
-
-        break;
-
-      case ONE_EXPRESSION:
-      case ONE_STATEMENT:
-        switch (elseKind) {
-          case EMPTY:
-            if (thenKind == ONE_EXPRESSION) {
-              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();
-            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:
-        emitIf();
-        visitWithIndent(thenGraph);
-
-        switch (elseKind) {
-          case EMPTY:
-            buffer.add('\n');
-            break;
-
-          case ONE_EXPRESSION:
-          case ONE_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;
-    }
+    pushStatement(new js.If(test, thenPart, elsePart), node);
   }
 
-
   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);
       } else {
         generateStatements(info.elseGraph);
       }
@@ skipping 12 matching lines @@
     // 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
     // (e.g., return/throw/break) there can be any number of these.
     List<HBasicBlock> dominated = node.block.dominatedBlocks;
     for (int i = 2; i < dominated.length; i++) {
       visitBasicBlock(dominated[i]);
     }
   }
 
+  js.Call jsPropertyCall(js.Expression receiver,
+                         String fieldName,
+                         List<js.Expression> arguments) {
+    return new js.Call(new js.PropertyAccess.field(receiver, fieldName),
+                       arguments);
+  }
+
   visitInvokeDynamicMethod(HInvokeDynamicMethod node) {
-    beginExpression(JSPrecedence.CALL_PRECEDENCE);
-    use(node.receiver, JSPrecedence.MEMBER_PRECEDENCE);
-    buffer.add('.');
+    use(node.receiver);
+    js.Expression object = pop();
+    String methodName;
+    List<js.Expression> arguments;
+
     // Avoid adding the generative constructor name to the list of
     // seen selectors.
     if (node.inputs[0] is HForeignNew) {
-      HForeignNew foreignNew = node.inputs[0];
-      // Remove 'this' from the number of arguments.
-      int argumentCount = node.inputs.length - 1;
-
       // TODO(ahe): The constructor name was statically resolved in
       // SsaBuilder.buildFactory. Is there a cleaner way to do this?
-      node.name.printOn(buffer);
-      visitArguments(node.inputs);
+      methodName = node.name.slowToString();
+      arguments = visitArguments(node.inputs);
     } else {
-      buffer.add(compiler.namer.instanceMethodInvocationName(
-          currentLibrary, node.name, node.selector));
-      visitArguments(node.inputs);
+      methodName = compiler.namer.instanceMethodInvocationName(
+          currentLibrary, node.name, node.selector);
+      arguments = visitArguments(node.inputs);
       bool inLoop = node.block.enclosingLoopHeader !== null;
       if (node.element !== null) {
         // If we know we're calling a specific method, register that
         // method only.
         if (inLoop) {
           backend.builder.functionsCalledInLoop.add(node.element);
         }
         world.registerDynamicInvocationOf(node.element);
       } else {
         Selector selector = getOptimizedSelectorFor(node, node.selector);
         world.registerDynamicInvocation(node.name, selector);
         if (inLoop) backend.builder.selectorsCalledInLoop[node.name] = selector;
       }
     }
-    endExpression(JSPrecedence.CALL_PRECEDENCE);
+    push(jsPropertyCall(object, methodName, arguments), node);
   }
 
   Selector getOptimizedSelectorFor(HInvoke node, Selector defaultSelector) {
     Type receiverType = node.inputs[0].propagatedType.computeType(compiler);
     if (receiverType !== null) {
       return new TypedSelector(receiverType, defaultSelector);
     } else {
       return defaultSelector;
     }
   }
 
   visitInvokeDynamicSetter(HInvokeDynamicSetter node) {
-    beginExpression(JSPrecedence.CALL_PRECEDENCE);
-    use(node.receiver, JSPrecedence.MEMBER_PRECEDENCE);
-    buffer.add('.');
-    buffer.add(compiler.namer.setterName(currentLibrary, node.name));
-    visitArguments(node.inputs);
+    use(node.receiver);
+    push(jsPropertyCall(pop(),
+                        compiler.namer.setterName(currentLibrary, node.name),
+                        visitArguments(node.inputs)),
+         node);
     world.registerDynamicSetter(
         node.name, getOptimizedSelectorFor(node, Selector.SETTER));
-    endExpression(JSPrecedence.CALL_PRECEDENCE);
   }
 
   visitInvokeDynamicGetter(HInvokeDynamicGetter node) {
-    beginExpression(JSPrecedence.CALL_PRECEDENCE);
-    use(node.receiver, JSPrecedence.MEMBER_PRECEDENCE);
-    buffer.add('.');
-    buffer.add(compiler.namer.getterName(currentLibrary, node.name));
-    visitArguments(node.inputs);
+    use(node.receiver);
+    push(jsPropertyCall(pop(),
+                        compiler.namer.getterName(currentLibrary, node.name),
+                        visitArguments(node.inputs)),
+         node);
     world.registerDynamicGetter(
         node.name, getOptimizedSelectorFor(node, Selector.GETTER));
-    endExpression(JSPrecedence.CALL_PRECEDENCE);
   }
 
   visitInvokeClosure(HInvokeClosure node) {
-    beginExpression(JSPrecedence.CALL_PRECEDENCE);
-    use(node.receiver, JSPrecedence.MEMBER_PRECEDENCE);
-    buffer.add('.');
-    buffer.add(compiler.namer.closureInvocationName(node.selector));
-    visitArguments(node.inputs);
+    use(node.receiver);
+    push(jsPropertyCall(pop(),
+                        compiler.namer.closureInvocationName(node.selector),
+                        visitArguments(node.inputs)),
+         node);
     // TODO(floitsch): we should have a separate list for closure invocations.
     world.registerDynamicInvocation(compiler.namer.CLOSURE_INVOCATION_NAME,
                                     node.selector);
-    endExpression(JSPrecedence.CALL_PRECEDENCE);
   }
 
   visitInvokeStatic(HInvokeStatic node) {
-    beginExpression(JSPrecedence.CALL_PRECEDENCE);
-    use(node.target, JSPrecedence.CALL_PRECEDENCE);
-    visitArguments(node.inputs);
-    endExpression(JSPrecedence.CALL_PRECEDENCE);
+    use(node.target);
+    push(new js.Call(pop(), visitArguments(node.inputs)), node);
   }
 
   visitInvokeSuper(HInvokeSuper node) {
-    beginExpression(JSPrecedence.CALL_PRECEDENCE);
     Element superMethod = node.element;
     Element superClass = superMethod.enclosingElement;
     // Remove the element and 'this'.
     int argumentCount = node.inputs.length - 2;
     String className = compiler.namer.isolateAccess(superClass);
-    if (superMethod.kind == ElementKind.FUNCTION ||
-        superMethod.kind == ElementKind.GENERATIVE_CONSTRUCTOR) {
-      String methodName = compiler.namer.instanceMethodName(
-          currentLibrary, superMethod.name, argumentCount);
-      buffer.add('$className.prototype.$methodName.call');
-      visitArguments(node.inputs);
-    } else if (superMethod.kind == ElementKind.FIELD) {
+    if (superMethod.kind == ElementKind.FIELD) {
       ClassElement currentClass = work.element.enclosingElement;
+      String fieldName;
       if (currentClass.isShadowedByField(superMethod)) {
-        buffer.add('this.${compiler.namer.shadowedFieldName(superMethod)}');
+        fieldName = compiler.namer.shadowedFieldName(superMethod);
       } else {
         LibraryElement library = superMethod.getLibrary();
         SourceString name = superMethod.name;
-        buffer.add('this.${compiler.namer.instanceFieldName(library, name)}');
+        fieldName = compiler.namer.instanceFieldName(library, name);
       }
+      push(new js.PropertyAccess.field(new js.This(), fieldName), node);
     } else {
-      assert(superMethod.kind == ElementKind.GETTER ||
-             superMethod.kind == ElementKind.SETTER);
       String methodName;
-      if (superMethod.kind == ElementKind.GETTER) {
+      if (superMethod.kind == ElementKind.FUNCTION ||
+          superMethod.kind == ElementKind.GENERATIVE_CONSTRUCTOR) {
+        methodName = compiler.namer.instanceMethodName(
+            currentLibrary, superMethod.name, argumentCount);
+      } else if (superMethod.kind == ElementKind.GETTER) {
         methodName =
             compiler.namer.getterName(currentLibrary, superMethod.name);
       } else {
+        assert(superMethod.kind == ElementKind.SETTER);
         methodName =
             compiler.namer.setterName(currentLibrary, superMethod.name);
       }
-      buffer.add('$className.prototype.$methodName.call');
-      visitArguments(node.inputs);
+      js.VariableUse classReference = new js.VariableUse(className);
+      js.PropertyAccess prototype =
+          new js.PropertyAccess.field(classReference, "prototype");
+      js.PropertyAccess method =
+          new js.PropertyAccess.field(prototype, methodName);
+      push(jsPropertyCall(method, "call", visitArguments(node.inputs)), node);
     }
-    endExpression(JSPrecedence.CALL_PRECEDENCE);
     world.registerStaticUse(superMethod);
   }
 
   visitFieldGet(HFieldGet node) {
     String name =
         compiler.namer.instanceFieldName(node.library, node.fieldName);
-    beginExpression(JSPrecedence.MEMBER_PRECEDENCE);
-    use(node.receiver, JSPrecedence.MEMBER_PRECEDENCE);
-    buffer.add('.');
-    buffer.add(name);
-    beginExpression(JSPrecedence.MEMBER_PRECEDENCE);
+    use(node.receiver);
+    push(new js.PropertyAccess.field(pop(), name), node);
     if (node.element == null) {
       // If we don't have an element we register a dynamic field getter.
       // This might lead to unnecessary getters, but these cases should be
       // rare.
       world.registerDynamicGetter(node.fieldName, Selector.GETTER);
     } else {
       Type type = node.receiver.propagatedType.computeType(compiler);
       if (type != null) {
         world.registerFieldGetter(node.element.name, type);
       }
@@ skipping 17 matching lines @@
     if (node.element != null &&
         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.instanceFieldName(node.library, node.fieldName);
-    beginExpression(JSPrecedence.ASSIGNMENT_PRECEDENCE);
-    use(node.receiver, JSPrecedence.MEMBER_PRECEDENCE);
-    buffer.add('.');
-    buffer.add(name);
     if (node.element == null) {
       // If we don't have an element we register a dynamic field setter.
       // This might lead to unnecessary setters, but these cases should be
       // rare.
       world.registerDynamicSetter(node.fieldName, Selector.SETTER);
     } else {
       Type type = node.receiver.propagatedType.computeType(compiler);
       if (type != null) {
         if (!work.element.isGenerativeConstructorBody()) {
           world.registerFieldSetter(node.element.name, type);
         }
         // Determine the types seen so far for the field. If only number
         // types have been seen and the value of the field set is a
         // simple number computation only depending on that field, we
         // can safely keep the number type for the field.
         HType fieldSettersType = backend.fieldSettersTypeSoFar(node.element);
         HType initializersType =
             backend.typeFromInitializersSoFar(node.element);
         HType fieldType = fieldSettersType.union(initializersType);
         if (HType.NUMBER.union(fieldType) == HType.NUMBER &&
             isSimpleFieldNumberComputation(node.value, node)) {
           backend.updateFieldSetters(node.element, HType.NUMBER);
         } else {
           backend.updateFieldSetters(node.element,
                                      node.value.propagatedType);
         }
       }
     }
-    buffer.add(' = ');
-    use(node.value, JSPrecedence.ASSIGNMENT_PRECEDENCE);
-    endExpression(JSPrecedence.ASSIGNMENT_PRECEDENCE);
+    use(node.receiver);
+    js.Expression receiver = pop();
+    use(node.value);
+    push(new js.Assignment(new js.PropertyAccess.field(receiver, name), pop()),
+         node);
   }
 
   visitLocalGet(HLocalGet node) {
-    use(node.receiver, JSPrecedence.EXPRESSION_PRECEDENCE);
+    use(node.receiver);
   }
 
   visitLocalSet(HLocalSet node) {
-    declareInstruction(node.receiver);
-    buffer.add(' = ');
-    use(node.value, JSPrecedence.ASSIGNMENT_PRECEDENCE);
+    use(node.value);
+    assignVariable(variableNames.getName(node.receiver), pop());
   }
 
   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);
+    if (node.isStatement) {
+      if (!inputs.isEmpty()) {
+        compiler.internalError("foreign statement with inputs: $code",
+                               instruction: node);
+      }
+      pushStatement(new js.LiteralStatement(code), node);
+    } else {
+      List<js.Expression> data = <js.Expression>[];
+      for (int i = 0; i < inputs.length; i++) {
+        use(inputs[i]);
+        data.add(pop());
+      }
+      push(new js.LiteralExpression.withData(code, data), node);
     }
-    beginExpression(JSPrecedence.EXPRESSION_PRECEDENCE);
-    buffer.add(parts[0]);
-    for (int i = 0; i < inputs.length; i++) {
-      use(inputs[i], JSPrecedence.EXPRESSION_PRECEDENCE);
-      buffer.add(parts[i + 1]);
-    }
-    endExpression(JSPrecedence.EXPRESSION_PRECEDENCE);
   }
 
   visitForeignNew(HForeignNew node) {
     int j = 0;
     node.element.forEachInstanceField(
       includeBackendMembers: true,
       includeSuperMembers: true,
       f: (ClassElement enclosingClass, Element member) {
         backend.updateFieldInitializers(member,
                                         node.inputs[j].propagatedType);
         j++;
       });
     String jsClassReference = compiler.namer.isolateAccess(node.element);
-    beginExpression(JSPrecedence.MEMBER_PRECEDENCE);
-    buffer.add('new $jsClassReference(');
+    List<HInstruction> inputs = node.inputs;
     // We can't use 'visitArguments', since our arguments start at input[0].
-    List<HInstruction> inputs = node.inputs;
+    List<js.Expression> arguments = <js.Expression>[];
     for (int i = 0; i < inputs.length; i++) {
-      if (i != 0) buffer.add(', ');
-      use(inputs[i], JSPrecedence.ASSIGNMENT_PRECEDENCE);
+      use(inputs[i]);
+      arguments.add(pop());
     }
-    buffer.add(')');
-    endExpression(JSPrecedence.MEMBER_PRECEDENCE);
+    // TODO(floitsch): jsClassReference is an Access. We shouldn't treat it
+    // as if it was a string.
+    push(new js.New(new js.VariableUse(jsClassReference), arguments), node);
   }
 
   void generateConstant(Constant constant) {
-    // TODO(floitsch): the compile-time constant handler and the codegen
-    // need to work together to avoid the parenthesis. See r4928 for an
-    // implementation that still dealt with precedence.
     ConstantHandler handler = compiler.constantHandler;
     String name = handler.getNameForConstant(constant);
     if (name === null) {
       assert(!constant.isObject());
-      if (constant.isNum()
-          && expectedPrecedence == JSPrecedence.MEMBER_PRECEDENCE) {
-        buffer.add('(');
+      if (constant.isBool()) {
+        push(new js.LiteralBool((constant as BoolConstant).value));
+      } else if (constant.isNum()) {
+        // TODO(floitsch): get rid of the code buffer.
+        CodeBuffer buffer = new CodeBuffer();
         handler.writeConstant(buffer, constant);
-        buffer.add(')');
+        push(new js.LiteralNumber(buffer.toString()));
+      } else if (constant.isNull()) {
+        push(new js.LiteralNull());
+      } else if (constant.isString()) {
+        // TODO(floitsch): get rid of the code buffer.
+        CodeBuffer buffer = new CodeBuffer();
+        handler.writeConstant(buffer, constant);
+        push(new js.LiteralString(buffer.toString()));
       } else {
-        handler.writeConstant(buffer, constant);
+        compiler.internalError("Forgot constant $constant");
       }
     } else {
-      buffer.add(compiler.namer.CURRENT_ISOLATE);
-      buffer.add(".");
-      buffer.add(name);
+      js.VariableUse currentIsolateUse =
+          new js.VariableUse(compiler.namer.CURRENT_ISOLATE);
+      push(new js.PropertyAccess.field(currentIsolateUse, name));
     }
-
   }
 
   visitConstant(HConstant node) {
     assert(isGenerateAtUseSite(node));
     generateConstant(node.constant);
   }
 
   visitLoopBranch(HLoopBranch node) {
     if (subGraph !== null && node.block === subGraph.end) {
       // We are generating code for a loop condition.
       // If doing this as part of a SubGraph traversal, the
       // calling code will handle the control flow logic.
 
       // If we are generating the subgraph as an expression, the
       // condition will be generated as the expression.
       // Otherwise, we don't generate the expression, and leave that
       // to the code that called [visitSubGraph].
-      if (isGeneratingExpression()) {
-        use(node.inputs[0], JSPrecedence.EXPRESSION_PRECEDENCE);
+      if (isGeneratingExpression) {
+        use(node.inputs[0]);
       }
       return;
     }
     HBasicBlock branchBlock = currentBlock;
-    addIndentation();
     handleLoopCondition(node);
     List<HBasicBlock> dominated = currentBlock.dominatedBlocks;
     // For a do while loop, the body has already been visited.
     if (!node.isDoWhile()) {
       visitBasicBlock(dominated[0]);
     }
     endLoop(node.block);
 
     // If the branch does not dominate the code after the loop, the
     // dominator will visit it.
     if (branchBlock.successors[1].dominator !== branchBlock) return;
 
     visitBasicBlock(branchBlock.successors[1]);
     // With labeled breaks we can have more dominated blocks.
     if (dominated.length >= 3) {
       for (int i = 2; i < dominated.length; i++) {
         visitBasicBlock(dominated[i]);
       }
     }
   }
 
   visitNot(HNot node) {
     assert(node.inputs.length == 1);
     generateNot(node.inputs[0]);
+    attachLocationToLast(node);
   }
 
 
   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)) {
-      beginExpression(JSPrecedence.EQUALITY_PRECEDENCE);
-      use(input.inputs[0], JSPrecedence.EQUALITY_PRECEDENCE);
-      buffer.add(' !== true');
-      endExpression(JSPrecedence.EQUALITY_PRECEDENCE);
+      use(input.inputs[0]);
+      push(new js.Binary("!==", pop(), new js.LiteralBool(true)), input);
     } 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 {
-      beginExpression(JSPrecedence.PREFIX_PRECEDENCE);
-      buffer.add('!');
-      use(input, JSPrecedence.PREFIX_PRECEDENCE);
-      endExpression(JSPrecedence.PREFIX_PRECEDENCE);
+      use(input);
+      push(new js.Prefix("!", pop()));
     }
   }
 
   visitParameterValue(HParameterValue node) => visitLocalValue(node);
 
   visitLocalValue(HLocalValue node) {
     assert(isGenerateAtUseSite(node));
-    buffer.add(variableNames.getName(node));
+    push(new js.VariableUse(variableNames.getName(node)), 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);
+      use(node.inputs[1]);
     } else if (input.isConstantTrue()) {
-      use(node.inputs[0], expectedPrecedence);
+      use(node.inputs[0]);
     } else if (node.inputs[1].isConstantBoolean()) {
       String operation = node.inputs[1].isConstantFalse() ? '&&' : '||';
-      JSBinaryOperatorPrecedence operatorPrecedence =
-          JSPrecedence.binary[operation];
-      beginExpression(operatorPrecedence.precedence);
       if (operation == '||') {
         if (input is HNot) {
-          use(input.inputs[0], operatorPrecedence.left);
+          use(input.inputs[0]);
         } else {
           generateNot(input);
         }
       } else {
-        use(input, operatorPrecedence.left);
+        use(input);
       }
-      buffer.add(" $operation ");
-      use(node.inputs[0], operatorPrecedence.right);
-      endExpression(operatorPrecedence.precedence);
+      js.Expression left = pop();
+      use(node.inputs[0]);
+      push(new js.Binary(operation, left, pop()));
     } else {
-      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);
+      use(input);
+      js.Expression test = pop();
+      use(node.inputs[0]);
+      js.Expression then = pop();
+      use(node.inputs[1]);
+      push(new js.Conditional(test, then, pop()));
     }
   }
 
   visitReturn(HReturn node) {
-    addIndentation();
     assert(node.inputs.length == 1);
     HInstruction input = node.inputs[0];
     if (input.isConstantNull()) {
-      buffer.add('return;\n');
+      pushStatement(new js.Return(null), node);
     } else {
-      buffer.add('return ');
-      use(node.inputs[0], JSPrecedence.EXPRESSION_PRECEDENCE);
-      buffer.add(';\n');
+      use(node.inputs[0]);
+      pushStatement(new js.Return(pop()), node);
     }
   }
 
   visitThis(HThis node) {
-    buffer.add('this');
+    push(new js.This());
   }
 
   visitThrow(HThrow node) {
-    addIndentation();
     if (node.isRethrow) {
-      buffer.add('throw ');
-      use(node.inputs[0], JSPrecedence.EXPRESSION_PRECEDENCE);
+      use(node.inputs[0]);
+      pushStatement(new js.Throw(pop()), node);
     } else {
       generateThrowWithHelper('captureStackTrace', node.inputs[0]);
     }
-    buffer.add(';\n');
   }
 
   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
+    // If the checks always succeeds, we would have removed the bounds check
     // completely.
     assert(node.staticChecks != HBoundsCheck.ALWAYS_TRUE);
     if (node.staticChecks != HBoundsCheck.ALWAYS_FALSE) {
-      buffer.add('if (');
+      js.Binary under;
       if (node.staticChecks != HBoundsCheck.ALWAYS_ABOVE_ZERO) {
         assert(node.staticChecks == HBoundsCheck.FULL_CHECK);
-        use(node.index, JSPrecedence.RELATIONAL_PRECEDENCE);
-        buffer.add(' < 0 || ');
+        use(node.index);
+        under = new js.Binary("<", pop(), new js.LiteralNumber("0"));
       }
-      use(node.index, JSPrecedence.RELATIONAL_PRECEDENCE);
-      buffer.add(' >= ');
-      use(node.length, JSPrecedence.SHIFT_PRECEDENCE);
-      buffer.add(") ");
+      use(node.index);
+      js.Expression index = pop();
+      use(node.length);
+      js.Binary over = new js.Binary(">=", index, pop());
+      js.Binary underOver =
+          under == null ? over : new js.Binary("||", under, over);
+      js.Statement thenBody = new js.Block.empty();
+      js.Block oldContainer = currentContainer;
+      currentContainer = thenBody;
+      generateThrowWithHelper('ioore', node.index);
+      currentContainer = oldContainer;
+      thenBody = unwrapStatement(thenBody);
+      pushStatement(new js.If.then(underOver, thenBody), node);
+    } else {
+      generateThrowWithHelper('ioore', node.index);
     }
-    generateThrowWithHelper('ioore', node.index);
   }
 
   visitIntegerCheck(HIntegerCheck node) {
     if (!node.alwaysFalse) {
-      buffer.add('if (');
       checkInt(node.value, '!==');
-      buffer.add(') ');
+      js.Expression test = pop();
+      js.Statement thenBody = new js.Block.empty();
+      js.Block oldContainer = currentContainer;
+      currentContainer = thenBody;
+      generateThrowWithHelper('iae', node.value);
+      currentContainer = oldContainer;
+      thenBody = unwrapStatement(thenBody);
+      pushStatement(new js.If.then(test, thenBody), node);
+    } else {
+      generateThrowWithHelper('iae', node.value);
     }
-    generateThrowWithHelper('iae', node.value);
   }
 
   void generateThrowWithHelper(String helperName, HInstruction argument) {
     Element helper = compiler.findHelper(new SourceString(helperName));
     world.registerStaticUse(helper);
-    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('  ');
-    }
-  }
-
-  void addIndented(String text) {
-    addIndentation();
-    buffer.add(text);
+    js.VariableUse jsHelper =
+        new js.VariableUse(compiler.namer.isolateAccess(helper));
+    js.Call value = new js.Call(jsHelper, visitArguments([null, argument]));
+    attachLocation(value, argument);
+    pushStatement(new js.Throw(value));
   }
 
   void visitSwitch(HSwitch node) {
     // Switches are handled using [visitSwitchInfo].
   }
 
   void visitStatic(HStatic node) {
     world.registerStaticUse(node.element);
-    buffer.add(compiler.namer.isolateAccess(node.element));
+    push(new js.VariableUse(compiler.namer.isolateAccess(node.element)));
   }
 
   void visitStaticStore(HStaticStore node) {
     world.registerStaticUse(node.element);
-    beginExpression(JSPrecedence.ASSIGNMENT_PRECEDENCE);
-    buffer.add(compiler.namer.isolateAccess(node.element));
-    buffer.add(' = ');
-    use(node.inputs[0], JSPrecedence.ASSIGNMENT_PRECEDENCE);
-    endExpression(JSPrecedence.ASSIGNMENT_PRECEDENCE);
+    js.VariableUse variableUse =
+        new js.VariableUse(compiler.namer.isolateAccess(node.element));
+    use(node.inputs[0]);
+    push(new js.Assignment(variableUse, pop()), node);
   }
 
   void visitStringConcat(HStringConcat node) {
     if (isEmptyString(node.left)) {
-      useStringified(node.right, expectedPrecedence);
+      useStringified(node.right);
    } else if (isEmptyString(node.right)) {
-      useStringified(node.left, expectedPrecedence);
+      useStringified(node.left);
     } 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.
-      int rightPrecedence = (node.right is HStringConcat)
-          ? JSPrecedence.ADDITIVE_PRECEDENCE
-          : operatorPrecedences.right;
-      useStringified(node.right, rightPrecedence);
-      endExpression(operatorPrecedences.precedence);
+      useStringified(node.left);
+      js.Expression left = pop();
+      useStringified(node.right);
+      push(new js.Binary("+", left, pop()), node);
     }
   }
 
   bool isEmptyString(HInstruction node) {
     if (!node.isConstantString()) return false;
     HConstant constant = node;
     StringConstant string = constant.constant;
     return string.value.length == 0;
   }
 
-  void useStringified(HInstruction node, int precedence) {
+  void useStringified(HInstruction node) {
     if (node.isString()) {
-      use(node, precedence);
+      use(node);
     } else {
       Element convertToString = compiler.findHelper(const SourceString("S"));
       world.registerStaticUse(convertToString);
-      buffer.add(compiler.namer.isolateAccess(convertToString));
-      buffer.add('(');
-      use(node, JSPrecedence.EXPRESSION_PRECEDENCE);
-      buffer.add(')');
+      js.VariableUse variableUse =
+          new js.VariableUse(compiler.namer.isolateAccess(convertToString));
+      use(node);
+      push(new js.Call(variableUse, <js.Expression>[pop()]), node);
     }
   }
 
   void visitLiteralList(HLiteralList node) {
     generateArrayLiteral(node);
   }
 
   void generateArrayLiteral(HLiteralList node) {
-    buffer.add('[');
     int len = node.inputs.length;
+    List<js.ArrayElement> elements = <js.ArrayElement>[];
     for (int i = 0; i < len; i++) {
-      if (i != 0) buffer.add(', ');
-      use(node.inputs[i], JSPrecedence.ASSIGNMENT_PRECEDENCE);
+      use(node.inputs[i]);
+      elements.add(new js.ArrayElement(i, pop()));
     }
-    buffer.add(']');
+    push(new js.ArrayInitialization(len, elements), node);
   }
 
   void visitIndex(HIndex node) {
     if (node.builtin) {
-      beginExpression(JSPrecedence.MEMBER_PRECEDENCE);
-      use(node.inputs[1], JSPrecedence.MEMBER_PRECEDENCE);
-      buffer.add('[');
-      use(node.inputs[2], JSPrecedence.EXPRESSION_PRECEDENCE);
-      buffer.add(']');
-      endExpression(JSPrecedence.MEMBER_PRECEDENCE);
+      use(node.inputs[1]);
+      js.Expression receiver = pop();
+      use(node.inputs[2]);
+      push(new js.PropertyAccess(receiver, pop()), node);
     } else {
       visitInvokeStatic(node);
     }
   }
 
   void visitIndexAssign(HIndexAssign node) {
     if (node.builtin) {
-      beginExpression(JSPrecedence.ASSIGNMENT_PRECEDENCE);
-      use(node.inputs[1], JSPrecedence.MEMBER_PRECEDENCE);
-      buffer.add('[');
-      use(node.inputs[2], JSPrecedence.EXPRESSION_PRECEDENCE);
-      buffer.add('] = ');
-      use(node.inputs[3], JSPrecedence.ASSIGNMENT_PRECEDENCE);
-      endExpression(JSPrecedence.ASSIGNMENT_PRECEDENCE);
+      use(node.inputs[1]);
+      js.Expression receiver = pop();
+      use(node.inputs[2]);
+      js.Expression index = pop();
+      use(node.inputs[3]);
+      push(new js.Assignment(new js.PropertyAccess(receiver, index), pop()),
+           node);
     } else {
       visitInvokeStatic(node);
     }
   }
 
   String builtinJsName(HInvokeInterceptor interceptor) {
     // Don't count the target method or the receiver in the arity.
     int arity = interceptor.inputs.length - 2;
     HInstruction receiver = interceptor.inputs[1];
     bool getter = interceptor.getter;
@@ skipping 16 matching lines @@
       }
     }
 
     return null;
   }
 
   void visitInvokeInterceptor(HInvokeInterceptor node) {
     String builtin = builtinJsName(node);
     if (builtin !== null) {
       if (builtin == '+') {
-        beginExpression(JSPrecedence.ADDITIVE_PRECEDENCE);
-        use(node.inputs[1], JSPrecedence.ADDITIVE_PRECEDENCE);
-        buffer.add(' + ');
-        use(node.inputs[2], JSPrecedence.MULTIPLICATIVE_PRECEDENCE);
-        endExpression(JSPrecedence.ADDITIVE_PRECEDENCE);
+        use(node.inputs[1]);
+        js.Expression left = pop();
+        use(node.inputs[2]);
+        push(new js.Binary("+", left, pop()), node);
       } else {
-        beginExpression(JSPrecedence.CALL_PRECEDENCE);
-        use(node.inputs[1], JSPrecedence.MEMBER_PRECEDENCE);
-        buffer.add('.');
-        buffer.add(builtin);
-        if (node.getter) return;
-        buffer.add('(');
+        use(node.inputs[1]);
+        js.PropertyAccess access = new js.PropertyAccess.field(pop(), builtin);
+        if (node.getter) {
+          push(access, node);
+          return;
+        }
+        List<js.Expression> arguments = <js.Expression>[];
         for (int i = 2; i < node.inputs.length; i++) {
-          if (i != 2) buffer.add(', ');
-          use(node.inputs[i], JSPrecedence.ASSIGNMENT_PRECEDENCE);
+          use(node.inputs[i]);
+          arguments.add(pop());
         }
-        buffer.add(")");
-        endExpression(JSPrecedence.CALL_PRECEDENCE);
+        push(new js.Call(access, arguments), node);
       }
     } else {
       return visitInvokeStatic(node);
     }
   }
 
   void checkInt(HInstruction input, String cmp) {
-    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);
+    use(input);
+    js.Expression left = pop();
+    use(input);
+    js.Expression or0 = new js.Binary("|", pop(), new js.LiteralNumber("0"));
+    push(new js.Binary(cmp, left, or0));
   }
 
-  void checkNum(HInstruction input, String cmp) {
-    beginExpression(JSPrecedence.EQUALITY_PRECEDENCE);
-    buffer.add('typeof ');
-    use(input, JSPrecedence.PREFIX_PRECEDENCE);
-    buffer.add(" $cmp 'number'");
-    endExpression(JSPrecedence.EQUALITY_PRECEDENCE);
+  void checkTypeOf(HInstruction input, String cmp, String typeName) {
+    use(input);
+    js.Expression typeOf = new js.Prefix("typeof", pop());
+    push(new js.Binary(cmp, typeOf, new js.LiteralString("'$typeName'")));
   }
 
-  void checkDouble(HInstruction input, String cmp) {
-    checkNum(input, cmp);
-  }
+  void checkNum(HInstruction input, String cmp)
+      => checkTypeOf(input, cmp, 'number');
 
-  void checkString(HInstruction input, String cmp) {
-    beginExpression(JSPrecedence.EQUALITY_PRECEDENCE);
-    buffer.add('typeof ');
-    use(input, JSPrecedence.PREFIX_PRECEDENCE);
-    buffer.add(" $cmp 'string'");
-    endExpression(JSPrecedence.EQUALITY_PRECEDENCE);
-  }
+  void checkDouble(HInstruction input, String cmp)  => checkNum(input, cmp);
 
-  void checkBool(HInstruction input, String cmp) {
-    beginExpression(JSPrecedence.EQUALITY_PRECEDENCE);
-    buffer.add('typeof ');
-    use(input, JSPrecedence.PREFIX_PRECEDENCE);
-    buffer.add(" $cmp 'boolean'");
-    endExpression(JSPrecedence.EQUALITY_PRECEDENCE);
-  }
+  void checkString(HInstruction input, String cmp)
+      => checkTypeOf(input, cmp, 'string');
+
+  void checkBool(HInstruction input, String cmp)
+      => checkTypeOf(input, cmp, 'boolean');
 
   void checkObject(HInstruction input, String cmp) {
     assert(NullConstant.JsNull == 'null');
     if (cmp == "===") {
-      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);
-      });
+      checkTypeOf(input, '===', 'object');
+      js.Expression left = pop();
+      use(input);
+      js.Expression notNull = new js.Binary("!==", pop(), new js.LiteralNull());
+      push(new js.Binary("&&", left, notNull));
     } else {
       assert(cmp == "!==");
-      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);
-      });
+      checkTypeOf(input, '!==', 'object');
+      js.Expression left = pop();
+      use(input);
+      js.Expression eqNull = new js.Binary("===", pop(), new js.LiteralNull());
+      push(new js.Binary("||", left, eqNull));
     }
   }
 
   void checkArray(HInstruction input, String cmp) {
-    beginExpression(JSPrecedence.EQUALITY_PRECEDENCE);
-    use(input, JSPrecedence.MEMBER_PRECEDENCE);
-    buffer.add('.constructor $cmp Array');
-    endExpression(JSPrecedence.EQUALITY_PRECEDENCE);
+    use(input);
+    js.PropertyAccess constructor =
+        new js.PropertyAccess.field(pop(), 'constructor');
+    push(new js.Binary(cmp, constructor, new js.VariableUse('Array')));
+  }
+
+  void checkFieldExists(HInstruction input, String fieldName) {
+    use(input);
+    js.PropertyAccess field = new js.PropertyAccess.field(pop(), fieldName);
+    // Double negate to boolify the result.
+    push(new js.Prefix('!', new js.Prefix('!', field)));
   }
 
   void checkImmutableArray(HInstruction input) {
-    beginExpression(JSPrecedence.PREFIX_PRECEDENCE);
-    buffer.add('!!');
-    use(input, JSPrecedence.MEMBER_PRECEDENCE);
-    buffer.add('.immutable\$list');
-    endExpression(JSPrecedence.PREFIX_PRECEDENCE);
+    checkFieldExists(input, 'immutable\$list');
   }
 
   void checkExtendableArray(HInstruction input) {
-    beginExpression(JSPrecedence.PREFIX_PRECEDENCE);
-    buffer.add('!!');
-    use(input, JSPrecedence.MEMBER_PRECEDENCE);
-    buffer.add('.fixed\$length');
-    endExpression(JSPrecedence.PREFIX_PRECEDENCE);
+    checkFieldExists(input, 'fixed\$length');
   }
 
   void checkFixedArray(HInstruction input) {
-    beginExpression(JSPrecedence.PREFIX_PRECEDENCE);
-    use(input, JSPrecedence.MEMBER_PRECEDENCE);
-    buffer.add('.fixed\$length');
-    endExpression(JSPrecedence.PREFIX_PRECEDENCE);
+    checkFieldExists(input, 'fixed\$length');
   }
 
   void checkNull(HInstruction input) {
-    beginExpression(JSPrecedence.EQUALITY_PRECEDENCE);
-    use(input, JSPrecedence.EQUALITY_PRECEDENCE);
-    buffer.add(" == null");
-    endExpression(JSPrecedence.EQUALITY_PRECEDENCE);
+    use(input);
+    push(new js.Binary('==', pop(), new js.LiteralNull()));
   }
 
   void checkFunction(HInstruction input, Element 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);
-    });
+    checkTypeOf(input, '===', 'function');
+    js.Expression functionTest = pop();
+    checkObject(input, '===');
+    js.Expression objectTest = pop();
+    checkType(input, element);
+    push(new js.Binary('||',
+                       functionTest,
+                       new js.Binary('&&', objectTest, pop())));
   }
 
   void checkType(HInstruction input, Element element, [bool negative = false]) {
     world.registerIsCheck(element);
-    bool requiresNativeIsCheck =
-        backend.emitter.nativeEmitter.requiresNativeIsCheck(element);
-    if (!requiresNativeIsCheck) {
-      if (negative) {
-        buffer.add('!');
-      } else {
-        buffer.add('!!');
-      }
-    } else if (negative) {
-      buffer.add('!');
+    use(input);
+    js.PropertyAccess field =
+        new js.PropertyAccess.field(pop(), compiler.namer.operatorIs(element));
+    if (backend.emitter.nativeEmitter.requiresNativeIsCheck(element)) {
+      push(new js.Call(field, <js.Expression>[]));
+      if (negative) push(new js.Prefix('!', pop()));
+    } else {
+      // We always negate at least once so that the result is boolified.
+      push(new js.Prefix('!', field));
+      // If the result is not negated, put another '!' in front.
+      if (!negative) push(new js.Prefix('!', pop()));
     }
-    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));
-    withPrecedence(JSPrecedence.LOGICAL_OR_PRECEDENCE, () {
-      checkString(input, '===');
-      buffer.add(' || ');
-      withPrecedence(JSPrecedence.LOGICAL_AND_PRECEDENCE, () {
-        checkObject(input, '===');
-        buffer.add(' && ');
-        checkType(input, element);
-      });
-    });
+    checkString(input, '===');
+    js.Expression stringTest = pop();
+    checkObject(input, '===');
+    js.Expression objectTest = pop();
+    checkType(input, element);
+    push(new js.Binary('||',
+                       stringTest,
+                       new js.Binary('&&', objectTest, pop())));
   }
 
   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));
-    beginExpression(JSPrecedence.LOGICAL_AND_PRECEDENCE);
     checkObject(input, '===');
-    buffer.add(' && (');
-    beginExpression(JSPrecedence.LOGICAL_OR_PRECEDENCE);
+    js.Expression objectTest = pop();
     checkArray(input, '===');
-    buffer.add(' || ');
+    js.Expression arrayTest = pop();
     checkType(input, element);
-    buffer.add(')');
-    endExpression(JSPrecedence.LOGICAL_OR_PRECEDENCE);
-    endExpression(JSPrecedence.LOGICAL_AND_PRECEDENCE);
+    push(new js.Binary('&&',
+                       objectTest,
+                       new js.Binary('||', arrayTest, pop())));
   }
 
   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;
 
-    int oldPrecedence;
-    if (node.nullOk) {
-      oldPrecedence = expectedPrecedence;
-      beginExpression(JSPrecedence.LOGICAL_OR_PRECEDENCE);
-      expectedPrecedence = JSPrecedence.LOGICAL_OR_PRECEDENCE;
-      checkNull(input);
-      buffer.add(' || ');
-    }
     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');
+      push(new js.LiteralBool(true), node);
     } else if (element == compiler.stringClass) {
       checkString(input, '===');
+      attachLocationToLast(node);
     } else if (element == compiler.doubleClass) {
       checkDouble(input, '===');
+      attachLocationToLast(node);
     } else if (element == compiler.numClass) {
       checkNum(input, '===');
+      attachLocationToLast(node);
     } else if (element == compiler.boolClass) {
       checkBool(input, '===');
+      attachLocationToLast(node);
     } else if (element == compiler.functionClass) {
       checkFunction(input, element);
+      attachLocationToLast(node);
     } else if (element == compiler.intClass) {
-      beginExpression(JSPrecedence.LOGICAL_AND_PRECEDENCE);
       checkNum(input, '===');
-      buffer.add(' && ');
+      js.Expression numTest = pop();
       checkInt(input, '===');
-      endExpression(JSPrecedence.LOGICAL_AND_PRECEDENCE);
+      push(new js.Binary('&&', numTest, pop()), node);
     } else if (Elements.isStringSupertype(element, compiler)) {
       handleStringSupertypeCheck(input, element);
+      attachLocationToLast(node);
     } else if (element === compiler.listClass
                || Elements.isListSupertype(element, compiler)) {
       handleListOrSupertypeCheck(input, element);
+      attachLocationToLast(node);
     } else if (input.propagatedType.canBePrimitive()
                || input.propagatedType.canBeNull()) {
-      beginExpression(JSPrecedence.LOGICAL_AND_PRECEDENCE);
       checkObject(input, '===');
-      buffer.add(' && ');
+      js.Expression objectTest = pop();
       checkType(input, element);
-      endExpression(JSPrecedence.LOGICAL_AND_PRECEDENCE);
+      push(new js.Binary('&&', objectTest, pop()), node);
     } else {
       checkType(input, element);
+      attachLocationToLast(node);
     }
     if (compiler.codegenWorld.rti.hasTypeArguments(type)) {
       InterfaceType interfaceType = type;
       ClassElement cls = type.element;
       Link<Type> arguments = interfaceType.arguments;
-      buffer.add(' && ');
+      js.Expression result = pop();
       checkObject(node.typeInfoCall, '===');
+      result = new js.Binary('&&', result, pop());
       for (TypeVariableType typeVariable in cls.typeVariables) {
-        buffer.add(' && ');
-        beginExpression(JSPrecedence.LOGICAL_AND_PRECEDENCE);
-        use(node.typeInfoCall, JSPrecedence.EQUALITY_PRECEDENCE);
+        use(node.typeInfoCall);
         // TODO(johnniwinther): Retrieve the type name properly and not through
         // [toString]. Note: Two cases below [typeVariable] and
         // [arguments.head].
-        buffer.add(
-            ".${typeVariable} === '${arguments.head}'");
-        endExpression(JSPrecedence.LOGICAL_AND_PRECEDENCE);
+        js.PropertyAccess field =
+            new js.PropertyAccess.field(pop(), typeVariable.toString());
+        js.Expression genericName = new js.LiteralString("'${arguments.head}'");
+        js.Binary eqTest = new js.Binary('===', field, genericName);
+        result = new js.Binary('&&', result, eqTest);
       }
+      push(result, node);
     }
     if (node.nullOk) {
-      expectedPrecedence = oldPrecedence;
-      endExpression(JSPrecedence.LOGICAL_OR_PRECEDENCE);
+      checkNull(input);
+      push(new js.Binary('||', pop(), pop()), node);
     }
   }
 
   void visitTypeConversion(HTypeConversion node) {
     Map<String, SourceString> castNames = const <SourceString> {
       "stringTypeCheck":
           const SourceString("stringTypeCast"),
       "doubleTypeCheck":
           const SourceString("doubleTypeCast"),
       "numTypeCheck":
@@ skipping 20 matching lines @@
           const SourceString("propertyTypeCast")
     };
 
     if (node.isChecked) {
       Element element = node.type.computeType(compiler).element;
       world.registerIsCheck(element);
       SourceString helper;
       String additionalArgument;
       bool nativeCheck =
           backend.emitter.nativeEmitter.requiresNativeIsCheck(element);
-      beginExpression(JSPrecedence.CALL_PRECEDENCE);
 
       if (node.isArgumentTypeCheck) {
-        buffer.add('if (');
         if (element == compiler.intClass) {
           checkInt(node.checkedInput, '!==');
         } else {
           assert(element == compiler.numClass);
           checkNum(node.checkedInput, '!==');
         }
-        buffer.add(') ');
+        js.Expression test = pop();
+        js.Block oldContainer = currentContainer;
+        js.Statement body = new js.Block.empty();
+        currentContainer = body;
         generateThrowWithHelper('iae', node.checkedInput);
+        currentContainer = oldContainer;
+        body = unwrapStatement(body);
+        pushStatement(new js.If.then(test, body), node);
         return;
       }
 
       assert(node.isCheckedModeCheck || node.isCastTypeCheck);
       if (element == compiler.stringClass) {
         helper = const SourceString('stringTypeCheck');
       } else if (element == compiler.doubleClass) {
         helper = const SourceString('doubleTypeCheck');
       } else if (element == compiler.numClass) {
         helper = const SourceString('numTypeCheck');
@@ skipping 24 matching lines @@
           helper = const SourceString('callTypeCheck');
         } else {
           helper = const SourceString('propertyTypeCheck');
         }
       }
       if (node.isCastTypeCheck) {
         helper = castNames[helper.stringValue];
       }
       Element helperElement = compiler.findHelper(helper);
       world.registerStaticUse(helperElement);
-      buffer.add(compiler.namer.isolateAccess(helperElement));
-      buffer.add('(');
-      use(node.checkedInput, JSPrecedence.EXPRESSION_PRECEDENCE);
-      if (additionalArgument !== null) buffer.add(", '$additionalArgument'");
-      buffer.add(')');
-      endExpression(JSPrecedence.CALL_PRECEDENCE);
+      List<js.Expression> arguments = <js.Expression>[];
+      use(node.checkedInput);
+      arguments.add(pop());
+      if (additionalArgument !== null) {
+        arguments.add(new js.LiteralString("'$additionalArgument'"));
+      }
+      String helperName = compiler.namer.isolateAccess(helperElement);
+      push(new js.Call(new js.VariableUse(helperName), arguments));
     } else {
-      use(node.checkedInput, expectedPrecedence);
+      use(node.checkedInput);
     }
   }
 }
 
 class SsaOptimizedCodeGenerator extends SsaCodeGenerator {
   SsaOptimizedCodeGenerator(backend, work, parameters, parameterNames)
-    : super(backend, work, parameters, parameterNames) {
+    : super(backend, work, parameterNames) {
     // Declare the parameter names only for the optimized version. The
     // unoptimized version has different parameters.
     parameterNames.forEach((Element element, String name) {
       declaredVariables.add(name);
     });
   }
 
   int maxBailoutParameters;
 
   HBasicBlock beginGraph(HGraph graph) => graph.entry;
   void endGraph(HGraph graph) {}
 
-  void bailout(HTypeGuard guard, String reason) {
+  js.Statement bailout(HTypeGuard guard, String reason) {
     if (maxBailoutParameters === null) {
       maxBailoutParameters = 0;
       work.guards.forEach((HTypeGuard workGuard) {
         HBailoutTarget target = workGuard.bailoutTarget;
         int inputLength = target.inputs.length;
         if (inputLength > maxBailoutParameters) {
           maxBailoutParameters = inputLength;
         }
       });
     }
     HInstruction input = guard.guarded;
     HBailoutTarget target = guard.bailoutTarget;
     Namer namer = compiler.namer;
     Element element = work.element;
-    buffer.add('return ');
-    if (element.isInstanceMember()) {
-      // TODO(ngeoffray): This does not work in case we come from a
-      // super call. We must make bailout names unique.
-      buffer.add('this.${namer.getBailoutName(element)}');
-    } else {
-      buffer.add(namer.isolateBailoutAccess(element));
-    }
-    buffer.add('(${guard.state}');
+    List<js.Expression> arguments = <js.Expression>[];
+    arguments.add(new js.LiteralNumber("${guard.state}"));
     // TODO(ngeoffray): try to put a variable at a deterministic
     // location, so that multiple bailout calls put the variable at
     // the same parameter index.
     int i = 0;
     for (; i < target.inputs.length; i++) {
       assert(guard.inputs.indexOf(target.inputs[i]) >= 0);
-      buffer.add(', ');
-      use(target.inputs[i], JSPrecedence.ASSIGNMENT_PRECEDENCE);
+      use(target.inputs[i]);
+      arguments.add(pop());
     }
     // Make sure we call the bailout method with the number of
     // arguments it expects. This avoids having the underlying
     // JS engine fill them in for us.
     for (; i < maxBailoutParameters; i++) {
-      buffer.add(', 0');
+      arguments.add(new js.LiteralNumber('0'));
     }
-    buffer.add(')');
+
+    js.Expression bailoutTarget;
+    if (element.isInstanceMember()) {
+      // TODO(ngeoffray): This does not work in case we come from a
+      // super call. We must make bailout names unique.
+      String bailoutName = namer.getBailoutName(element);
+      bailoutTarget = new js.PropertyAccess.field(new js.This(), bailoutName);
+    } else {
+      bailoutTarget = new js.VariableUse(namer.isolateBailoutAccess(element));
+    }
+    js.Call call = new js.Call(bailoutTarget, arguments);
+    attachLocation(call, guard);
+    return new js.Return(call);
   }
 
   void visitTypeGuard(HTypeGuard node) {
-    addIndentation();
     HInstruction input = node.guarded;
     Element indexingBehavior = compiler.jsIndexingBehaviorInterface;
     if (node.isInteger()) {
       // if (input is !int) bailout
-      buffer.add('if (');
       checkInt(input, '!==');
-      buffer.add(') ');
-      bailout(node, 'Not an integer');
+      pushStatement(new js.If.then(pop(), bailout(node, 'Not an integer')),
+                    node);
     } else if (node.isNumber()) {
       // if (input is !num) bailout
-      buffer.add('if (');
       checkNum(input, '!==');
-      buffer.add(') ');
-      bailout(node, 'Not a number');
+      pushStatement(new js.If.then(pop(), bailout(node, 'Not a number')), node);
     } else if (node.isBoolean()) {
       // if (input is !bool) bailout
-      buffer.add('if (');
       checkBool(input, '!==');
-      buffer.add(') ');
-      bailout(node, 'Not a boolean');
+      pushStatement(new js.If.then(pop(), bailout(node, 'Not a boolean')),
+                    node);
     } else if (node.isString()) {
       // if (input is !string) bailout
-      buffer.add('if (');
       checkString(input, '!==');
-      buffer.add(') ');
-      bailout(node, 'Not a string');
+      pushStatement(new js.If.then(pop(), bailout(node, 'Not a string')), node);
     } else if (node.isExtendableArray()) {
       // if (input is !Object || input is !Array || input.isFixed) bailout
-      buffer.add('if (');
       checkObject(input, '!==');
-      buffer.add('||');
+      js.Expression objectTest = pop();
       checkArray(input, '!==');
-      buffer.add('||');
+      js.Expression arrayTest = pop();
       checkFixedArray(input);
-      buffer.add(') ');
-      bailout(node, 'Not an extendable array');
+      js.Expression test = new js.Binary('||', objectTest, arrayTest);
+      test = new js.Binary('||', test, pop());
+      pushStatement(new js.If.then(test,
+                                   bailout(node, 'Not an extendable array')),
+                    node);
     } else if (node.isMutableArray()) {
       // if (input is !Object
       //     || ((input is !Array || input.isImmutable)
       //         && input is !JsIndexingBehavior)) bailout
-      buffer.add('if (');
       checkObject(input, '!==');
-      buffer.add(' || ((');
+      js.Expression objectTest = pop();
       checkArray(input, '!==');
-      buffer.add(' || ');
+      js.Expression arrayTest = pop();
       checkImmutableArray(input);
-      buffer.add(') && ');
+      js.Binary notArrayOrImmutable = new js.Binary('||', arrayTest, pop());
       checkType(input, indexingBehavior, negative: true);
-      buffer.add(')) ');
-      bailout(node, 'Not a mutable array');
+      js.Binary notIndexing = new js.Binary('&&', notArrayOrImmutable, pop());
+      pushStatement(new js.If.then(new js.Binary('||', objectTest, notIndexing),
+                                   bailout(node, 'Not a mutable array')),
+                    node);
     } else if (node.isReadableArray()) {
       // if (input is !Object
       //     || (input is !Array && input is !JsIndexingBehavior)) bailout
-      buffer.add('if (');
       checkObject(input, '!==');
-      buffer.add(' || (');
+      js.Expression objectTest = pop();
       checkArray(input, '!==');
-      buffer.add(' && ');
+      js.Expression arrayTest = pop();
       checkType(input, indexingBehavior, negative: true);
-      buffer.add(')) ');
-      bailout(node, 'Not an array');
+      js.Expression notIndexing = new js.Binary('&&', arrayTest, pop());
+      pushStatement(new js.If.then(new js.Binary('||', objectTest, notIndexing),
+                                   bailout(node, 'Not an array')),
+                    node);
     } else if (node.isIndexablePrimitive()) {
       // if (input is !String
       //     && (input is !Object
       //         || (input is !Array && input is !JsIndexingBehavior))) bailout
-      buffer.add('if (');
       checkString(input, '!==');
-      buffer.add(' && (');
+      js.Expression stringTest = pop();
       checkObject(input, '!==');
-      buffer.add(' || (');
+      js.Expression objectTest = pop();
       checkArray(input, '!==');
-      buffer.add(' && ');
+      js.Expression arrayTest = pop();
       checkType(input, indexingBehavior, negative: true);
-      buffer.add('))) ');
-      bailout(node, 'Not a string or array');
+      js.Binary notIndexingTest = new js.Binary('&&', arrayTest, pop());
+      js.Binary notObjectOrIndexingTest =
+          new js.Binary('||', objectTest, notIndexingTest);
+      js.Binary condition =
+          new js.Binary('&&', stringTest, notObjectOrIndexingTest);
+      pushStatement(new js.If.then(condition,
+                                   bailout(node, 'Not a string or array')),
+                    node);
     } else {
       compiler.internalError('Unexpected type guard', instruction: input);
     }
-    buffer.add(';\n');
   }
 
   void visitBailoutTarget(HBailoutTarget target) {
     // Do nothing. Bailout targets are only used in the non-optimized version.
   }
 
   void beginLoop(HBasicBlock block) {
-    addIndentation();
-    HLoopInformation info = block.loopInformation;
-    for (LabelElement label in info.labels) {
-      writeLabel(label);
-      buffer.add(":");
-    }
-    buffer.add('while (true) {\n');
-    indent++;
+    oldContainerStack.add(currentContainer);
+    currentContainer = new js.Block.empty();
   }
 
   void endLoop(HBasicBlock block) {
-    indent--;
-    addIndented('}\n');  // Close 'while' loop.
+    js.Statement body = currentContainer;
+    currentContainer = oldContainerStack.removeLast();
+    body = unwrapStatement(body);
+    js.While loop = new js.While(new js.LiteralBool(true), body);
+
+    HLoopInformation info = block.loopInformation;
+    attachLocationRange(loop, info.loopBlockInformation.sourcePosition);
+    pushStatement(wrapIntoLabels(loop, info.labels));
   }
 
   void handleLoopCondition(HLoopBranch node) {
-    buffer.add('if (!');
-    use(node.inputs[0], JSPrecedence.PREFIX_PRECEDENCE);
-    buffer.add(') break;\n');
+    use(node.inputs[0]);
+    pushStatement(new js.If.then(pop(), new js.Break(null)), node);
   }
 
 
   void preLabeledBlock(HLabeledBlockInformation labeledBlockInfo) {
   }
 
   void startLabeledBlock(HLabeledBlockInformation labeledBlockInfo) {
   }
 
   void endLabeledBlock(HLabeledBlockInformation labeledBlockInfo) {
   }
 }
 
 class SsaUnoptimizedCodeGenerator extends SsaCodeGenerator {
 
-  final CodeBuffer setup;
-  final CodeBuffer newParameters;
+  js.Statement setup;
+  js.Switch currentBailoutSwitch;
+  final List<js.Switch> oldBailoutSwitches;
+  final List<js.Parameter> newParameters;
   final List<String> labels;
   int labelId = 0;
   /**
    * Keeps track if a bailout switch already used its [:default::] clause. New
    * bailout-switches just push [:false:] on the stack and replace it when
    * they used the [:default::] clause.
    */
   final List<bool> defaultClauseUsedInBailoutStack;
 
   SsaBailoutPropagator propagator;
   HInstruction savedFirstInstruction;
 
   SsaUnoptimizedCodeGenerator(backend, work, parameters, parameterNames)
-    : super(backend, work, parameters, parameterNames),
-      setup = new CodeBuffer(),
-      newParameters = new CodeBuffer(),
+    : super(backend, work, parameterNames),
+      setup = new js.EmptyStatement(),
+      oldBailoutSwitches = <js.Switch>[],
+      newParameters = <js.Parameter>[],
       labels = <String>[],
       defaultClauseUsedInBailoutStack = <bool>[];
 
   String pushLabel() {
     String label = 'L${labelId++}';
     labels.addLast(label);
     return label;
   }
 
   String popLabel() {
     return labels.removeLast();
   }
 
   String currentLabel() {
     return labels.last();
   }
 
   HBasicBlock beginGraph(HGraph graph) {
     propagator = new SsaBailoutPropagator(compiler, generateAtUseSite);
     propagator.visitGraph(graph);
     // TODO(ngeoffray): We could avoid generating the state at the
     // call site for non-complex bailout methods.
-    newParameters.add('state');
+    newParameters.add(new js.Parameter('state'));
 
     if (propagator.hasComplexBailoutTargets) {
       // Use generic parameters that will be assigned to
       // the right variables in the setup phase.
       for (int i = 0; i < propagator.maxBailoutParameters; i++) {
         String name = 'env$i';
         declaredVariables.add(name);
-        newParameters.add(', $name');
+        newParameters.add(new js.Parameter(name));
       }
 
       startBailoutSwitch();
 
       // The setup phase of a bailout function sets up the environment for
       // each bailout target. Each bailout target will populate this
       // setup phase. It is put at the beginning of the function.
-      setup.add('  switch (state) {\n');
+      setup = new js.Switch(new js.VariableUse('state'), <js.SwitchClause>[]);
       return graph.entry;
     } else {
       // We have a simple bailout target, so we can reuse the names that
       // the bailout target expects.
       for (HInstruction input in propagator.firstBailoutTarget.inputs) {
         input = unwrap(input);
         String name = variableNames.getName(input);
         declaredVariables.add(name);
-        newParameters.add(', $name');
+        newParameters.add(new js.Parameter(name));
       }
 
       // We change the first instruction of the first guard to be the
       // bailout target. We will change it back in the call to [endGraph].
       HBasicBlock block = propagator.firstBailoutTarget.block;
       savedFirstInstruction = block.first;
       block.first = propagator.firstBailoutTarget;
       return block;
     }
   }
 
   // If argument is a [HCheck] and it does not have a name, we try to
   // find the name of its checked input. Note that there must be a
   // name, otherwise the instruction would not be in the live
   // environment.
   HInstruction unwrap(HInstruction argument) {
     while (argument is HCheck && !variableNames.hasName(argument)) {
       argument = argument.checkedInput;
     }
     assert(variableNames.hasName(argument));
     return argument;
   }
 
   void endGraph(HGraph graph) {
     if (propagator.hasComplexBailoutTargets) {
-      indent--; // Close original case.
-      indent--;
-      addIndented('}\n');  // Close 'switch'.
-      setup.add('  }\n');
+      endBailoutSwitch();
     } else {
       // Put back the original first instruction of the block.
       propagator.firstBailoutTarget.block.first = savedFirstInstruction;
     }
   }
 
   bool visitAndOrInfo(HAndOrBlockInformation info) => false;
 
   bool visitIfInfo(HIfBlockInformation info) {
     if (info.thenGraph.start.hasBailoutTargets()) return false;
@@ skipping 10 matching lines @@
   bool visitTryInfo(HTryBlockInformation info) => false;
   bool visitSequenceInfo(HStatementSequenceInformation info) => false;
 
   void visitTypeGuard(HTypeGuard node) {
     // Do nothing. Type guards are only used in the optimized version.
   }
 
   void visitBailoutTarget(HBailoutTarget node) {
     if (!propagator.hasComplexBailoutTargets) return;
 
-    indent--;
-    addIndented('case ${node.state}:\n');
-    indent++;
-    addIndented('state = 0;\n');
-
-    setup.add('    case ${node.state}:\n');
+    js.Block nextBlock = new js.Block.empty();
+    js.Case clause = new js.Case(new js.LiteralNumber('${node.state}'),
+                                 nextBlock);
+    currentBailoutSwitch.cases.add(clause);
+    currentContainer = nextBlock;
+    pushExpressionAsStatement(new js.Assignment(new js.VariableUse('state'),
+                                                new js.LiteralNumber('0')));
+    js.Block setupBlock = new js.Block.empty();
     int i = 0;
     for (HInstruction input in node.inputs) {
       input = unwrap(input);
       String name = variableNames.getName(input);
-      setup.add('      ');
       if (!isVariableDeclared(name)) {
         declaredVariables.add(name);
-        setup.add('var ');
+        js.VariableInitialization init =
+            new js.VariableInitialization(new js.VariableDeclaration(name),
+                                          new js.VariableUse('env$i'));
+        js.Expression varList =
+            new js.VariableDeclarationList(<js.VariableInitialization>[init]);
+        setupBlock.statements.add(new js.ExpressionStatement(varList));
+      } else {
+        js.Expression target = new js.VariableUse(name);
+        js.Expression source = new js.VariableUse('env$i');
+        js.Expression assignment = new js.Assignment(target, source);
+        setupBlock.statements.add(new js.ExpressionStatement(assignment));
       }
-      setup.add('$name = env$i;\n');
       i++;
     }
-    setup.add('      break;\n');
+    setupBlock.statements.add(new js.Break(null));
+    js.Case setupClause =
+        new js.Case(new js.LiteralNumber('${node.state}'), setupBlock);
+    (setup as js.Switch).cases.add(setupClause);
   }
 
   void startBailoutCase(List<HBailoutTarget> bailouts1,
-                        List<HBailoutTarget> bailouts2) {
-    indent--;
+                        [List<HBailoutTarget> bailouts2 = const []]) {
     if (!defaultClauseUsedInBailoutStack.last() &&
         bailouts1.length + bailouts2.length >= 2) {
-      addIndented('default:\n');
+      currentContainer = new js.Block.empty();
+      currentBailoutSwitch.cases.add(new js.Default(currentContainer));
       int len = defaultClauseUsedInBailoutStack.length;
       defaultClauseUsedInBailoutStack[len - 1] = true;
     } else {
-      handleBailoutCase(bailouts1);
-      handleBailoutCase(bailouts2);
+      _handleBailoutCase(bailouts1);
+      _handleBailoutCase(bailouts2);
+      currentContainer = currentBailoutSwitch.cases.last().body;
     }
-    indent++;
   }
 
-  void handleBailoutCase(List<HBailoutTarget> targets) {
-    if (!defaultClauseUsedInBailoutStack.last() && targets.length >= 2) {
-      addIndented('default:\n');
-      int len = defaultClauseUsedInBailoutStack.length;
-      defaultClauseUsedInBailoutStack[len - 1] = true;
-    } else {
-      for (int i = 0, len = targets.length; i < len; i++) {
-        addIndented('case ${targets[i].state}:\n');
-      }
+  void _handleBailoutCase(List<HBailoutTarget> targets) {
+    for (int i = 0, len = targets.length; i < len; i++) {
+      js.LiteralNumber expr = new js.LiteralNumber('${targets[i].state}');
+      currentBailoutSwitch.cases.add(new js.Case(expr, new js.Block.empty()));
     }
   }
 
   void startBailoutSwitch() {
     defaultClauseUsedInBailoutStack.add(false);
-    addIndented('switch (state) {\n');
-    indent++;
-    addIndented('case 0:\n');
-    indent++;
+    oldBailoutSwitches.add(currentBailoutSwitch);
+    List<js.SwitchClause> cases = <js.SwitchClause>[];
+    js.Block firstBlock = new js.Block.empty();
+    cases.add(new js.Case(new js.LiteralNumber("0"), firstBlock));
+    currentBailoutSwitch = new js.Switch(new js.VariableUse('state'), cases);
+    pushStatement(currentBailoutSwitch);
+    oldContainerStack.add(currentContainer);
+    currentContainer = firstBlock;
   }
 
-  void endBailoutSwitch() {
-    indent--; // Close 'case'.
-    indent--;
-    addIndented('}\n');  // Close 'switch'.
+  js.Switch endBailoutSwitch() {
+    js.Switch result = currentBailoutSwitch;
+    currentBailoutSwitch = oldBailoutSwitches.removeLast();
     defaultClauseUsedInBailoutStack.removeLast();
+    currentContainer = oldContainerStack.removeLast();
+    return result;
   }
 
   void beginLoop(HBasicBlock block) {
-    String newLabel = pushLabel();
+    String loopLabel = pushLabel();
     if (block.hasBailoutTargets()) {
-      startBailoutCase(block.bailoutTargets, const <HBailoutTarget>[]);
+      startBailoutCase(block.bailoutTargets);
     }
-
-    addIndentation();
-    HLoopInformation loopInformation = block.loopInformation;
-    for (LabelElement label in loopInformation.labels) {
-      writeLabel(label);
-      buffer.add(":");
-    }
-    buffer.add('$newLabel: while (true) {\n');
-    indent++;
-
+    oldContainerStack.add(currentContainer);
+    currentContainer = new js.Block.empty();
     if (block.hasBailoutTargets()) {
       startBailoutSwitch();
+      HLoopInformation loopInformation = block.loopInformation;
       if (loopInformation.target !== null) {
         breakAction[loopInformation.target] = (TargetElement target) {
-          addIndented("break $newLabel;\n");
+          pushStatement(new js.Break(loopLabel));
         };
       }
     }
   }
 
   void endLoop(HBasicBlock block) {
-    popLabel();
+    String loopLabel = popLabel();
+
     HBasicBlock header = block.isLoopHeader() ? block : block.parentLoopHeader;
+    HLoopInformation info = header.loopInformation;
     if (header.hasBailoutTargets()) {
       endBailoutSwitch();
-      HLoopInformation info = header.loopInformation;
       if (info.target != null) breakAction.remove(info.target);
     }
-    indent--;
-    addIndented('}\n');  // Close 'while'.
+
+    js.Statement body = unwrapStatement(currentContainer);
+    currentContainer = oldContainerStack.removeLast();
+
+    js.Statement result = new js.While(new js.LiteralBool(true), body);
+    attachLocationRange(result, info.loopBlockInformation.sourcePosition);
+    result = new js.LabeledStatement(loopLabel, result);
+    result = wrapIntoLabels(result, info.labels);
+    pushStatement(result);
   }
 
   void handleLoopCondition(HLoopBranch node) {
-    buffer.add('if (!');
-    use(node.inputs[0], JSPrecedence.PREFIX_PRECEDENCE);
-    buffer.add(') break ${currentLabel()};\n');
+    use(node.inputs[0]);
+    pushStatement(new js.If.then(new js.Prefix('!', pop()),
+                                 new js.Break(currentLabel())),
+                  node);
   }
 
   void generateIf(HIf node, HIfBlockInformation info) {
     HStatementInformation thenGraph = info.thenGraph;
     HStatementInformation elseGraph = info.elseGraph;
     bool thenHasGuards = thenGraph.start.hasBailoutTargets();
     bool elseHasGuards = elseGraph.start.hasBailoutTargets();
     bool hasGuards = thenHasGuards || elseHasGuards;
-    if (!hasGuards) return super.generateIf(node, info);
-
-    int elseKind = analyzeGraphForCodegen(elseGraph);
-    bool emptyElse = elseKind == SsaCodeGenerator.EMPTY;
+    if (!hasGuards) {
+      super.generateIf(node, info);
+      return;
+    }
 
     startBailoutCase(thenGraph.start.bailoutTargets,
-        emptyElse ? const <HBailoutTarget>[] : elseGraph.start.bailoutTargets);
+                     elseGraph.start.bailoutTargets);
 
-    addIndented('if (');
-    int precedence = JSPrecedence.EXPRESSION_PRECEDENCE;
+    use(node.inputs[0]);
+    js.Binary stateEquals0 =
+        new js.Binary('===',
+                      new js.VariableUse('state'), new js.LiteralNumber('0'));
+    js.Expression condition = new js.Binary('&&', stateEquals0, pop());
     // TODO(ngeoffray): Put the condition initialization in the
     // [setup] buffer.
     List<HBailoutTarget> targets = node.thenBlock.bailoutTargets;
     for (int i = 0, len = targets.length; i < len; i++) {
-      buffer.add('state == ${targets[i].state} || ');
+      js.VariableUse stateRef = new js.VariableUse('state');
+      js.Expression targetState = new js.LiteralNumber('${targets[i].state}');
+      js.Binary stateTest = new js.Binary('===', stateRef, targetState);
+      condition = new js.Binary('||', stateTest, condition);
     }
-    buffer.add('(state == 0 && ');
-    precedence = JSPrecedence.BITWISE_OR_PRECEDENCE;
-    use(node.inputs[0], precedence);
 
-    buffer.add(')) {\n');
-
-    indent++;
+    js.Statement thenBody = new js.Block.empty();
+    js.Block oldContainer = currentContainer;
+    currentContainer = thenBody;
     if (thenHasGuards) startBailoutSwitch();
     generateStatements(thenGraph);
     if (thenHasGuards) endBailoutSwitch();
-    indent--;
+    thenBody = unwrapStatement(thenBody);
 
-    if (!emptyElse) {
-      addIndented('} else {\n');
-      indent++;
-      if (elseHasGuards) startBailoutSwitch();
-      generateStatements(elseGraph);
-      if (elseHasGuards) endBailoutSwitch();
-      indent--;
-    }
+    js.Statement elseBody = null;
+    elseBody = new js.Block.empty();
+    currentContainer = elseBody;
+    if (elseHasGuards) startBailoutSwitch();
+    generateStatements(elseGraph);
+    if (elseHasGuards) endBailoutSwitch();
+    elseBody = unwrapStatement(elseBody);
 
-    addIndented('}\n');
+    currentContainer = oldContainer;
+    pushStatement(new js.If(condition, thenBody, elseBody), node);
   }
 
   void preLabeledBlock(HLabeledBlockInformation labeledBlockInfo) {
     if (labeledBlockInfo.body.start.hasBailoutTargets()) {
       indent--;
-      handleBailoutCase(labeledBlockInfo.body.start.bailoutTargets);
+      startBailoutCase(labeledBlockInfo.body.start.bailoutTargets);
       indent++;
     }
   }
 
   void startLabeledBlock(HLabeledBlockInformation labeledBlockInfo) {
     if (labeledBlockInfo.body.start.hasBailoutTargets()) {
       startBailoutSwitch();
     }
   }
 
@@ skipping 12 matching lines @@
   if (leftType.canBeNull() && rightType.canBeNull()) {
     if (left.isConstantNull() || right.isConstantNull() ||
         (leftType.isPrimitive() && leftType == rightType)) {
       return '==';
     }
     return null;
   } else {
     return '===';
   }
 }