// Copyright (c) 2014, 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.

library code_generator;

import 'glue.dart';

import '../../closure.dart' show
    ClosureClassElement;
import '../../common.dart';
import '../../common/codegen.dart' show
    CodegenRegistry;
import '../../constants/values.dart';
import '../../dart_types.dart';
import '../../elements/elements.dart';
import '../../io/source_information.dart' show
    SourceInformation;
import '../../js/js.dart' as js;
import '../../tree_ir/tree_ir_nodes.dart' as tree_ir;
import '../../tree_ir/tree_ir_nodes.dart' show
    BuiltinMethod,
    BuiltinOperator,
    isCompoundableOperator;
import '../../types/types.dart' show
    TypeMask;
import '../../universe/call_structure.dart' show
    CallStructure;
import '../../universe/selector.dart' show
    Selector;
import '../../universe/use.dart' show
    DynamicUse,
    StaticUse,
    TypeUse;
import '../../util/maplet.dart';

class CodegenBailout {
  final tree_ir.Node node;
  final String reason;
  CodegenBailout(this.node, this.reason);
  String get message {
    return 'bailout${node != null ? " on $node" : ""}: $reason';
  }
}

class CodeGenerator extends tree_ir.StatementVisitor
                    with tree_ir.ExpressionVisitor<js.Expression> {
  final CodegenRegistry registry;

  final Glue glue;

  ExecutableElement currentFunction;

  /// Maps variables to their name.
  Map<tree_ir.Variable, String> variableNames = <tree_ir.Variable, String>{};

  /// Maps local constants to their name.
  Maplet<VariableElement, String> constantNames =
      new Maplet<VariableElement, String>();

  /// Variable names that have already been used. Used to avoid name clashes.
  Set<String> usedVariableNames = new Set<String>();

  final tree_ir.FallthroughStack fallthrough = new tree_ir.FallthroughStack();

  /// Stacks whose top element is the current target of an unlabeled break
  /// or continue. For continues, this is the loop node itself.
  final tree_ir.FallthroughStack shortBreak = new tree_ir.FallthroughStack();
  final tree_ir.FallthroughStack shortContinue =
      new tree_ir.FallthroughStack();

  /// When the top element is true, [Unreachable] statements will be emitted
  /// as [Return]s, otherwise they are emitted as empty because they are
  /// followed by the end of the method.
  ///
  /// Note on why the [fallthrough] stack should not be used for this:
  /// Ordinary statements may choose whether to use the [fallthrough] target,
  /// and the choice to do so may disable an optimization in [visitIf].
  /// But omitting an unreachable 'return' should have lower priority than
  /// the optimizations in [visitIf], so [visitIf] will instead tell the
  /// [Unreachable] statements whether they may use fallthrough or not.
  List<bool> emitUnreachableAsReturn = <bool>[false];

  final Map<tree_ir.Label, String> labelNames = <tree_ir.Label, String>{};

  List<js.Statement> accumulator = new List<js.Statement>();

  CodeGenerator(this.glue, this.registry);

  /// Generates JavaScript code for the body of [function].
  js.Fun buildFunction(tree_ir.FunctionDefinition function) {
    registerDefaultParameterValues(function.element);
    currentFunction = function.element;
    tree_ir.Statement statement = function.body;
    while (statement != null) {
      statement = visitStatement(statement);
    }

    List<js.Parameter> parameters = new List<js.Parameter>();
    Set<tree_ir.Variable> parameterSet = new Set<tree_ir.Variable>();
    Set<String> declaredVariables = new Set<String>();

    for (tree_ir.Variable parameter in function.parameters) {
      String name = getVariableName(parameter);
      parameters.add(new js.Parameter(name));
      parameterSet.add(parameter);
      declaredVariables.add(name);
    }

    List<js.VariableInitialization> jsVariables = <js.VariableInitialization>[];

    // Declare variables with an initializer. Pull statements into the
    // initializer until we find a statement that cannot be pulled in.
    int accumulatorIndex = 0;
    while (accumulatorIndex < accumulator.length) {
      js.Node node = accumulator[accumulatorIndex];

      // Check that node is an assignment to a local variable.
      if (node is! js.ExpressionStatement) break;
      js.ExpressionStatement stmt = node;
      if (stmt.expression is! js.Assignment) break;
      js.Assignment assign = stmt.expression;
      if (assign.leftHandSide is! js.VariableUse) break;
      if (assign.op != null) break; // Compound assignment.
      js.VariableUse use = assign.leftHandSide;

      // Do not touch non-local variables.
      if (!usedVariableNames.contains(use.name)) break;

      // We cannot declare a variable more than once.
      if (!declaredVariables.add(use.name)) break;

      js.VariableInitialization jsVariable = new js.VariableInitialization(
        new js.VariableDeclaration(use.name),
        assign.value);
      jsVariables.add(jsVariable);

      ++accumulatorIndex;
    }

    // If the last statement is a for loop with an initializer expression, try
    // to pull that expression into an initializer as well.
    pullFromForLoop:
    if (accumulatorIndex < accumulator.length &&
        accumulator[accumulatorIndex] is js.For) {
      js.For forLoop = accumulator[accumulatorIndex];
      if (forLoop.init is! js.Assignment) break pullFromForLoop;
      js.Assignment assign = forLoop.init;
      if (assign.leftHandSide is! js.VariableUse) break pullFromForLoop;
      if (assign.op != null) break pullFromForLoop; // Compound assignment.
      js.VariableUse use = assign.leftHandSide;

      // Do not touch non-local variables.
      if (!usedVariableNames.contains(use.name)) break pullFromForLoop;

      // We cannot declare a variable more than once.
      if (!declaredVariables.add(use.name)) break pullFromForLoop;

      js.VariableInitialization jsVariable = new js.VariableInitialization(
        new js.VariableDeclaration(use.name),
        assign.value);
      jsVariables.add(jsVariable);

      // Remove the initializer from the for loop.
      accumulator[accumulatorIndex] =
          new js.For(null, forLoop.condition, forLoop.update, forLoop.body);
    }

    // Discard the statements that were pulled in the initializer.
    if (accumulatorIndex > 0) {
      accumulator = accumulator.sublist(accumulatorIndex);
    }

    // Declare remaining variables.
    for (tree_ir.Variable variable in variableNames.keys) {
      String name = getVariableName(variable);
      if (declaredVariables.contains(name)) continue;
      js.VariableInitialization jsVariable = new js.VariableInitialization(
        new js.VariableDeclaration(name),
        null);
      jsVariables.add(jsVariable);
    }

    if (jsVariables.length > 0) {
      // Would be nice to avoid inserting at the beginning of list.
      accumulator.insert(0, new js.ExpressionStatement(
          new js.VariableDeclarationList(jsVariables)));
    }
    return new js.Fun(parameters, new js.Block(accumulator));
  }

  @override
  js.Expression visitExpression(tree_ir.Expression node) {
    js.Expression result = node.accept(this);
    if (result == null) {
      glue.reportInternalError('$node did not produce code.');
    }
    return result;
  }

  /// Generates a name for the given variable. First trying with the name of
  /// the [Variable.element] if it is non-null.
  String getVariableName(tree_ir.Variable variable) {
    // Functions are not nested in the JS backend.
    assert(variable.host == currentFunction);

    // Get the name if we already have one.
    String name = variableNames[variable];
    if (name != null) {
      return name;
    }

    // Synthesize a variable name that isn't used elsewhere.
    String prefix = variable.element == null ? 'v' : variable.element.name;
    int counter = 0;
    name = glue.safeVariableName(variable.element == null
        ? '$prefix$counter'
        : variable.element.name);
    while (!usedVariableNames.add(name)) {
      ++counter;
      name = '$prefix$counter';
    }
    variableNames[variable] = name;

    return name;
  }

  List<js.Expression> visitExpressionList(
      List<tree_ir.Expression> expressions) {
    List<js.Expression> result = new List<js.Expression>(expressions.length);
    for (int i = 0; i < expressions.length; ++i) {
      result[i] = visitExpression(expressions[i]);
    }
    return result;
  }

  giveup(tree_ir.Node node,
         [String reason = 'unimplemented in CodeGenerator']) {
    throw new CodegenBailout(node, reason);
  }

  @override
  js.Expression visitConditional(tree_ir.Conditional node) {
    return new js.Conditional(
        visitExpression(node.condition),
        visitExpression(node.thenExpression),
        visitExpression(node.elseExpression));
  }

  js.Expression buildConstant(ConstantValue constant,
                              {SourceInformation sourceInformation}) {
    registry.registerCompileTimeConstant(constant);
    return glue.constantReference(constant)
        .withSourceInformation(sourceInformation);
  }

  @override
  js.Expression visitConstant(tree_ir.Constant node) {
    return buildConstant(
        node.value,
        sourceInformation: node.sourceInformation);
  }

  js.Expression buildStaticInvoke(Element target,
                                  List<js.Expression> arguments,
                                  {SourceInformation sourceInformation}) {
    if (target.isConstructor) {
      // TODO(johnniwinther): Avoid dependency on [isGenerativeConstructor] by
      // using backend-specific [StatisUse] classes.
      registry.registerStaticUse(
          new StaticUse.constructorInvoke(target.declaration,
              new CallStructure.unnamed(arguments.length)));
    } else {
      registry.registerStaticUse(
          new StaticUse.staticInvoke(target.declaration,
              new CallStructure.unnamed(arguments.length)));
    }
    js.Expression elementAccess = glue.staticFunctionAccess(target);
    return new js.Call(elementAccess, arguments,
        sourceInformation: sourceInformation);
  }

  @override
  js.Expression visitInvokeConstructor(tree_ir.InvokeConstructor node) {
    if (node.constant != null) return giveup(node);

    registry.registerInstantiation(node.type);
    FunctionElement target = node.target;
    List<js.Expression> arguments = visitExpressionList(node.arguments);
    return buildStaticInvoke(
        target,
        arguments,
        sourceInformation: node.sourceInformation);
  }

  void registerMethodInvoke(Selector selector, TypeMask receiverType) {
    registry.registerDynamicUse(new DynamicUse(selector, receiverType));
    if (!selector.isGetter && !selector.isSetter) {
      // TODO(sigurdm): We should find a better place to register the call.
      Selector call = new Selector.callClosureFrom(selector);
      registry.registerDynamicUse(new DynamicUse(call, null));
    }
  }

  @override
  js.Expression visitInvokeMethod(tree_ir.InvokeMethod node) {
    TypeMask mask = glue.extendMaskIfReachesAll(node.selector, node.mask);
    registerMethodInvoke(node.selector, mask);
    return js.propertyCall(visitExpression(node.receiver),
                           glue.invocationName(node.selector),
                           visitExpressionList(node.arguments))
        .withSourceInformation(node.sourceInformation);
  }

  @override
  js.Expression visitInvokeStatic(tree_ir.InvokeStatic node) {
    FunctionElement target = node.target;
    List<js.Expression> arguments = visitExpressionList(node.arguments);
    return buildStaticInvoke(target, arguments,
          sourceInformation: node.sourceInformation);
  }

  @override
  js.Expression visitInvokeMethodDirectly(tree_ir.InvokeMethodDirectly node) {
    if (node.isTearOff) {
      // If this is a tear-off, register the fact that a tear-off closure
      // will be created, and that this tear-off must bypass ordinary
      // dispatch to ensure the super method is invoked.
      registry.registerStaticUse(new StaticUse.staticInvoke(
          glue.closureFromTearOff, new CallStructure.unnamed(
            glue.closureFromTearOff.parameters.length)));
      registry.registerStaticUse(new StaticUse.superTearOff(node.target));
    }
    if (node.target is ConstructorBodyElement) {
      registry.registerStaticUse(
          new StaticUse.constructorBodyInvoke(
              node.target.declaration,
              new CallStructure.unnamed(node.arguments.length)));
      // A constructor body cannot be overriden or intercepted, so we can
      // use the short form for this invocation.
      return js.js('#.#(#)',
          [visitExpression(node.receiver),
           glue.instanceMethodName(node.target),
           visitExpressionList(node.arguments)])
          .withSourceInformation(node.sourceInformation);
    }
    registry.registerStaticUse(
        new StaticUse.superInvoke(
            node.target.declaration,
            new CallStructure.unnamed(node.arguments.length)));
    return js.js('#.#.call(#, #)',
        [glue.prototypeAccess(node.target.enclosingClass),
         glue.invocationName(node.selector),
         visitExpression(node.receiver),
         visitExpressionList(node.arguments)])
        .withSourceInformation(node.sourceInformation);
  }

  @override
  js.Expression visitOneShotInterceptor(tree_ir.OneShotInterceptor node) {
    registerMethodInvoke(node.selector, node.mask);
    registry.registerUseInterceptor();
    return js.js('#.#(#)',
        [glue.getInterceptorLibrary(),
         glue.registerOneShotInterceptor(node.selector),
         visitExpressionList(node.arguments)])
        .withSourceInformation(node.sourceInformation);
  }

  @override
  js.Expression visitLiteralList(tree_ir.LiteralList node) {
    registry.registerInstantiatedClass(glue.listClass);
    List<js.Expression> entries = visitExpressionList(node.values);
    return new js.ArrayInitializer(entries);
  }

  @override
  js.Expression visitLogicalOperator(tree_ir.LogicalOperator node) {
    return new js.Binary(
        node.operator,
        visitExpression(node.left),
        visitExpression(node.right));
  }

  @override
  js.Expression visitNot(tree_ir.Not node) {
    return new js.Prefix("!", visitExpression(node.operand));
  }

  @override
  js.Expression visitThis(tree_ir.This node) {
    return new js.This();
  }

  /// Ensure that 'instanceof' checks may be performed against [class_].
  ///
  /// Even if the class is never instantiated, a JS constructor must be emitted
  /// so the 'instanceof' expression does not throw an exception at runtime.
  bool tryRegisterInstanceofCheck(ClassElement class_) {
    if (glue.classWorld.isInstantiated(class_)) {
      // Ensure the class remains instantiated during backend tree-shaking.
      // TODO(asgerf): We could have a more precise hook to inform the emitter
      // that the JS constructor function is needed, without the class being
      // instantiated.
      registry.registerInstantiatedClass(class_);
      return true;
    }
    // Will throw if the JS constructor is not emitted, so do not allow the
    // instanceof check.  This should only happen when certain optimization
    // passes are disabled, as the type check itself is trivial.
    return false;
  }

  @override
  js.Expression visitTypeOperator(tree_ir.TypeOperator node) {
    js.Expression value = visitExpression(node.value);
    List<js.Expression> typeArguments = visitExpressionList(node.typeArguments);
    DartType type = node.type;
    if (type is InterfaceType) {
      registry.registerTypeUse(new TypeUse.isCheck(type));
      ClassElement clazz = type.element;

      if (glue.isStringClass(clazz)) {
        if (node.isTypeTest) {
          return js.js(r'typeof # === "string"', <js.Expression>[value]);
        }
        // TODO(sra): Implement fast cast via calling 'stringTypeCast'.
      } else if (glue.isBoolClass(clazz)) {
        if (node.isTypeTest) {
          return js.js(r'typeof # === "boolean"', <js.Expression>[value]);
        }
        // TODO(sra): Implement fast cast via calling 'boolTypeCast'.
      } else if (node.isTypeTest &&
                 node.typeArguments.isEmpty &&
                 glue.mayGenerateInstanceofCheck(type) &&
                 tryRegisterInstanceofCheck(clazz)) {
        return js.js('# instanceof #', [value, glue.constructorAccess(clazz)]);
      }

      // The helper we use needs the JSArray class to exist, but for some
      // reason the helper does not cause this dependency to be registered.
      // TODO(asgerf): Most programs need List anyway, but we should fix this.
      registry.registerInstantiatedClass(glue.listClass);

      // We use one of the two helpers:
      //
      //     checkSubtype(value, $isT, typeArgs, $asT)
      //     subtypeCast(value, $isT, typeArgs, $asT)
      //
      // Any of the last two arguments may be null if there are no type
      // arguments, and/or if no substitution is required.
      Element function = node.isTypeTest
          ? glue.getCheckSubtype()
          : glue.getSubtypeCast();

      js.Expression isT = js.quoteName(glue.getTypeTestTag(type));

      js.Expression typeArgumentArray = typeArguments.isNotEmpty
          ? new js.ArrayInitializer(typeArguments)
          : new js.LiteralNull();

      js.Expression asT = glue.hasStrictSubtype(clazz)
          ? js.quoteName(glue.getTypeSubstitutionTag(clazz))
          : new js.LiteralNull();

      return buildStaticHelperInvocation(
          function,
          <js.Expression>[value, isT, typeArgumentArray, asT]);
    } else if (type is TypeVariableType || type is FunctionType) {
      registry.registerTypeUse(new TypeUse.isCheck(type));

      Element function = node.isTypeTest
          ? glue.getCheckSubtypeOfRuntimeType()
          : glue.getSubtypeOfRuntimeTypeCast();

      // The only type argument is the type held in the type variable.
      js.Expression typeValue = typeArguments.single;

      return buildStaticHelperInvocation(
          function,
          <js.Expression>[value, typeValue]);
    }
    return giveup(node, 'type check unimplemented for $type.');
  }

  @override
  js.Expression visitGetTypeTestProperty(tree_ir.GetTypeTestProperty node) {
    js.Expression object = visitExpression(node.object);
    DartType dartType = node.dartType;
    assert(dartType.isInterfaceType);
    registry.registerTypeUse(new TypeUse.isCheck(dartType));
    //glue.registerIsCheck(dartType, registry);
    js.Expression property = glue.getTypeTestTag(dartType);
    return js.js(r'#.#', [object, property]);
  }

  @override
  js.Expression visitVariableUse(tree_ir.VariableUse node) {
    return buildVariableAccess(node.variable);
  }

  js.Expression buildVariableAccess(tree_ir.Variable variable) {
    return new js.VariableUse(getVariableName(variable));
  }

  /// Returns the JS operator for the given built-in operator for use in a
  /// compound assignment (not including the '=' sign).
  String getAsCompoundOperator(BuiltinOperator operator) {
    switch (operator) {
      case BuiltinOperator.NumAdd:
      case BuiltinOperator.StringConcatenate:
        return '+';
      case BuiltinOperator.NumSubtract:
        return '-';
      case BuiltinOperator.NumMultiply:
        return '*';
      case BuiltinOperator.NumDivide:
        return '/';
      case BuiltinOperator.NumRemainder:
        return '%';
      default:
        throw 'Not a compoundable operator: $operator';
    }
  }

  bool isCompoundableBuiltin(tree_ir.Expression exp) {
    return exp is tree_ir.ApplyBuiltinOperator &&
           exp.arguments.length == 2 &&
           isCompoundableOperator(exp.operator);
  }

  bool isOneConstant(tree_ir.Expression exp) {
    return exp is tree_ir.Constant && exp.value.isOne;
  }

  js.Expression makeAssignment(
      js.Expression leftHand,
      tree_ir.Expression value,
      {BuiltinOperator compound}) {
    if (isOneConstant(value)) {
      if (compound == BuiltinOperator.NumAdd) {
        return new js.Prefix('++', leftHand);
      }
      if (compound == BuiltinOperator.NumSubtract) {
        return new js.Prefix('--', leftHand);
      }
    }
    if (compound != null) {
      return new js.Assignment.compound(leftHand,
          getAsCompoundOperator(compound), visitExpression(value));
    }
    return new js.Assignment(leftHand, visitExpression(value));
  }

  @override
  js.Expression visitAssign(tree_ir.Assign node) {
    js.Expression variable = buildVariableAccess(node.variable);
    if (isCompoundableBuiltin(node.value)) {
      tree_ir.ApplyBuiltinOperator rhs = node.value;
      tree_ir.Expression left = rhs.arguments[0];
      tree_ir.Expression right = rhs.arguments[1];
      if (left is tree_ir.VariableUse && left.variable == node.variable) {
        return makeAssignment(variable, right, compound: rhs.operator);
      }
    }
    return makeAssignment(variable, node.value);
  }

  @override
  void visitContinue(tree_ir.Continue node) {
    tree_ir.Statement next = fallthrough.target;
    if (node.target.binding == next ||
        next is tree_ir.Continue && node.target == next.target) {
      // Fall through to continue target or to equivalent continue.
      fallthrough.use();
    } else if (node.target.binding == shortContinue.target) {
      // The target is the immediately enclosing loop.
      shortContinue.use();
      accumulator.add(new js.Continue(null));
    } else {
      accumulator.add(new js.Continue(makeLabel(node.target)));
    }
  }

  /// True if [other] is the target of [node] or is a [Break] with the same
  /// target. This means jumping to [other] is equivalent to executing [node].
  bool isEffectiveBreakTarget(tree_ir.Break node, tree_ir.Statement other) {
    return node.target.binding.next == other ||
           other is tree_ir.Break && node.target == other.target;
  }

  /// True if the given break is equivalent to an unlabeled continue.
  bool isShortContinue(tree_ir.Break node) {
    tree_ir.Statement next = node.target.binding.next;
    return next is tree_ir.Continue &&
           next.target.binding == shortContinue.target;
  }

  @override
  void visitBreak(tree_ir.Break node) {
    if (isEffectiveBreakTarget(node, fallthrough.target)) {
      // Fall through to break target or to equivalent break.
      fallthrough.use();
    } else if (isEffectiveBreakTarget(node, shortBreak.target)) {
      // Unlabeled break to the break target or to an equivalent break.
      shortBreak.use();
      accumulator.add(new js.Break(null));
    } else if (isShortContinue(node)) {
      // An unlabeled continue is better than a labeled break.
      shortContinue.use();
      accumulator.add(new js.Continue(null));
    } else {
      accumulator.add(new js.Break(makeLabel(node.target)));
    }
  }

  @override
  visitExpressionStatement(tree_ir.ExpressionStatement node) {
    js.Expression exp = visitExpression(node.expression);
    if (node.next is tree_ir.Unreachable && emitUnreachableAsReturn.last) {
      // Emit as 'return exp' to assist local analysis in the VM.
      accumulator.add(new js.Return(exp));
      return null;
    } else {
      accumulator.add(new js.ExpressionStatement(exp));
      return node.next;
    }
  }

  bool isNullReturn(tree_ir.Statement node) {
    return node is tree_ir.Return && isNull(node.value);
  }

  bool isEndOfMethod(tree_ir.Statement node) {
    return isNullReturn(node) ||
           node is tree_ir.Break && isNullReturn(node.target.binding.next);
  }

  @override
  visitIf(tree_ir.If node) {
    js.Expression condition = visitExpression(node.condition);
    int usesBefore = fallthrough.useCount;
    // Unless the 'else' part ends the method. make sure to terminate any
    // uncompletable code paths in the 'then' part.
    emitUnreachableAsReturn.add(!isEndOfMethod(node.elseStatement));
    js.Statement thenBody = buildBodyStatement(node.thenStatement);
    emitUnreachableAsReturn.removeLast();
    bool thenHasFallthrough = (fallthrough.useCount > usesBefore);
    if (thenHasFallthrough) {
      js.Statement elseBody = buildBodyStatement(node.elseStatement);
      accumulator.add(new js.If(condition, thenBody, elseBody));
      return null;
    } else {
      // The 'then' body cannot complete normally, so emit a short 'if'
      // and put the 'else' body after it.
      accumulator.add(new js.If.noElse(condition, thenBody));
      return node.elseStatement;
    }
  }

  @override
  visitLabeledStatement(tree_ir.LabeledStatement node) {
    fallthrough.push(node.next);
    js.Statement body = buildBodyStatement(node.body);
    fallthrough.pop();
    accumulator.add(insertLabel(node.label, body));
    return node.next;
  }

  /// Creates a name for [label] if it does not already have one.
  ///
  /// This also marks the label as being used.
  String makeLabel(tree_ir.Label label) {
    return labelNames.putIfAbsent(label, () => 'L${labelNames.length}');
  }

  /// Wraps a node in a labeled statement unless the label is unused.
  js.Statement insertLabel(tree_ir.Label label, js.Statement node) {
    String name = labelNames[label];
    if (name == null) return node; // Label is unused.
    return new js.LabeledStatement(name, node);
  }

  /// Returns the current [accumulator] wrapped in a block if neccessary.
  js.Statement _bodyAsStatement() {
    if (accumulator.length == 0) {
      return new js.EmptyStatement();
    }
    if (accumulator.length == 1) {
      return accumulator.single;
    }
    return new js.Block(accumulator);
  }

  /// Builds a nested statement.
  js.Statement buildBodyStatement(tree_ir.Statement statement) {
    List<js.Statement> savedAccumulator = accumulator;
    accumulator = <js.Statement>[];
    while (statement != null) {
      statement = visitStatement(statement);
    }
    js.Statement result = _bodyAsStatement();
    accumulator = savedAccumulator;
    return result;
  }

  js.Block buildBodyBlock(tree_ir.Statement statement) {
    List<js.Statement> savedAccumulator = accumulator;
    accumulator = <js.Statement>[];
    while (statement != null) {
      statement = visitStatement(statement);
    }
    js.Statement result = new js.Block(accumulator);
    accumulator = savedAccumulator;
    return result;
  }

  js.Expression makeSequence(List<tree_ir.Expression> list) {
    return list.map(visitExpression).reduce((x,y) => new js.Binary(',', x, y));
  }

  @override
  visitFor(tree_ir.For node) {
    js.Expression condition = visitExpression(node.condition);
    shortBreak.push(node.next);
    shortContinue.push(node);
    fallthrough.push(node);
    emitUnreachableAsReturn.add(true);
    js.Statement body = buildBodyStatement(node.body);
    emitUnreachableAsReturn.removeLast();
    fallthrough.pop();
    shortContinue.pop();
    shortBreak.pop();
    js.Statement loopNode;
    if (node.updates.isEmpty) {
      loopNode = new js.While(condition, body);
    } else { // Compile as a for loop.
      js.Expression init;
      if (accumulator.isNotEmpty &&
          accumulator.last is js.ExpressionStatement) {
        // Take the preceding expression from the accumulator and use
        // it as the initializer expression.
        js.ExpressionStatement initStmt = accumulator.removeLast();
        init = initStmt.expression;
      }
      js.Expression update = makeSequence(node.updates);
      loopNode = new js.For(init, condition, update, body);
    }
    accumulator.add(insertLabel(node.label, loopNode));
    return node.next;
  }

  @override
  void visitWhileTrue(tree_ir.WhileTrue node) {
    // A short break in the while will jump to the current fallthrough target.
    shortBreak.push(fallthrough.target);
    shortContinue.push(node);
    fallthrough.push(node);
    emitUnreachableAsReturn.add(true);
    js.Statement jsBody = buildBodyStatement(node.body);
    emitUnreachableAsReturn.removeLast();
    fallthrough.pop();
    shortContinue.pop();
    if (shortBreak.useCount > 0) {
      // Short breaks use the current fallthrough target.
      fallthrough.use();
    }
    shortBreak.pop();
    accumulator.add(
        insertLabel(node.label, new js.For(null, null, null, jsBody)));
  }

  bool isNull(tree_ir.Expression node) {
    return node is tree_ir.Constant && node.value.isNull;
  }

  @override
  void visitReturn(tree_ir.Return node) {
    if (isNull(node.value) && fallthrough.target == null) {
      // Do nothing. Implicitly return JS undefined by falling over the end.
      registry.registerCompileTimeConstant(new NullConstantValue());
      fallthrough.use();
    } else {
      accumulator.add(new js.Return(visitExpression(node.value))
            .withSourceInformation(node.sourceInformation));
    }
  }

  @override
  void visitThrow(tree_ir.Throw node) {
    accumulator.add(new js.Throw(visitExpression(node.value)));
  }

  @override
  void visitUnreachable(tree_ir.Unreachable node) {
    if (emitUnreachableAsReturn.last) {
      // Emit a return to assist local analysis in the VM.
      accumulator.add(new js.Return());
    }
  }

  @override
  void visitTry(tree_ir.Try node) {
    js.Block tryBlock = buildBodyBlock(node.tryBody);
    tree_ir.Variable exceptionVariable = node.catchParameters.first;
    js.VariableDeclaration exceptionParameter =
        new js.VariableDeclaration(getVariableName(exceptionVariable));
    js.Block catchBlock = buildBodyBlock(node.catchBody);
    js.Catch catchPart = new js.Catch(exceptionParameter, catchBlock);
    accumulator.add(new js.Try(tryBlock, catchPart, null));
  }

  @override
  js.Expression visitCreateBox(tree_ir.CreateBox node) {
    return new js.ObjectInitializer(const <js.Property>[]);
  }

  @override
  js.Expression visitCreateInstance(tree_ir.CreateInstance node) {
    ClassElement classElement = node.classElement;
    // TODO(asgerf): To allow inlining of InvokeConstructor, CreateInstance must
    //               carry a DartType so we can register the instantiated type
    //               with its type arguments. Otherwise dataflow analysis is
    //               needed to reconstruct the instantiated type.
    registry.registerInstantiation(classElement.rawType);
    if (classElement is ClosureClassElement) {
      registry.registerInstantiatedClosure(classElement.methodElement);
    }
    js.Expression instance = new js.New(
            glue.constructorAccess(classElement),
            visitExpressionList(node.arguments))
        .withSourceInformation(node.sourceInformation);

    tree_ir.Expression typeInformation = node.typeInformation;
    if (typeInformation != null) {
      FunctionElement helper = glue.getAddRuntimeTypeInformation();
      js.Expression typeArguments = visitExpression(typeInformation);
      return buildStaticHelperInvocation(helper,
          <js.Expression>[instance, typeArguments],
          sourceInformation: node.sourceInformation);
    } else {
      return instance;
    }
  }

  @override
  js.Expression visitCreateInvocationMirror(
      tree_ir.CreateInvocationMirror node) {
    js.Expression name = js.string(node.selector.name);
    js.Expression internalName =
        js.quoteName(glue.invocationName(node.selector));
    js.Expression kind = js.number(node.selector.invocationMirrorKind);
    js.Expression arguments = new js.ArrayInitializer(
        visitExpressionList(node.arguments));
    js.Expression argumentNames = new js.ArrayInitializer(
        node.selector.namedArguments.map(js.string).toList(growable: false));
    return buildStaticHelperInvocation(glue.createInvocationMirrorMethod,
        <js.Expression>[name, internalName, kind, arguments, argumentNames]);
  }

  @override
  js.Expression visitInterceptor(tree_ir.Interceptor node) {
    registry.registerUseInterceptor();
    // Default to all intercepted classes if they have not been computed.
    // This is to ensure we can run codegen without prior optimization passes.
    Set<ClassElement> interceptedClasses = node.interceptedClasses.isEmpty
        ? glue.interceptedClasses
        : node.interceptedClasses;
    registry.registerSpecializedGetInterceptor(interceptedClasses);
    js.Name helperName = glue.getInterceptorName(interceptedClasses);
    js.Expression globalHolder = glue.getInterceptorLibrary();
    return js.js('#.#(#)',
        [globalHolder, helperName, visitExpression(node.input)])
            .withSourceInformation(node.sourceInformation);
  }

  @override
  js.Expression visitGetField(tree_ir.GetField node) {
    registry.registerStaticUse(new StaticUse.fieldGet(node.field));
    return new js.PropertyAccess(
        visitExpression(node.object),
        glue.instanceFieldPropertyName(node.field));
  }

  @override
  js.Expression visitSetField(tree_ir.SetField node) {
    registry.registerStaticUse(new StaticUse.fieldSet(node.field));
    js.PropertyAccess field =
        new js.PropertyAccess(
            visitExpression(node.object),
            glue.instanceFieldPropertyName(node.field));
    return makeAssignment(field, node.value, compound: node.compound);
  }

  @override
  js.Expression visitGetStatic(tree_ir.GetStatic node) {
    assert(node.element is FieldElement || node.element is FunctionElement);
    if (node.element is FunctionElement) {
      // Tear off a method.
      registry.registerStaticUse(
          new StaticUse.staticTearOff(node.element.declaration));
      return glue.isolateStaticClosureAccess(node.element);
    }
    if (node.useLazyGetter) {
      // Read a lazily initialized field.
      registry.registerStaticUse(
          new StaticUse.staticInit(node.element.declaration));
      js.Expression getter = glue.isolateLazyInitializerAccess(node.element);
      return new js.Call(getter, <js.Expression>[],
          sourceInformation: node.sourceInformation);
    }
    // Read an eagerly initialized field.
    registry.registerStaticUse(
        new StaticUse.staticGet(node.element.declaration));
    return glue.staticFieldAccess(node.element);
  }

  @override
  js.Expression visitSetStatic(tree_ir.SetStatic node) {
    assert(node.element is FieldElement);
    registry.registerStaticUse(
        new StaticUse.staticSet(node.element.declaration));
    js.Expression field = glue.staticFieldAccess(node.element);
    return makeAssignment(field, node.value, compound: node.compound);
  }

  @override
  js.Expression visitGetLength(tree_ir.GetLength node) {
    return new js.PropertyAccess.field(visitExpression(node.object), 'length');
  }

  @override
  js.Expression visitGetIndex(tree_ir.GetIndex node) {
    return new js.PropertyAccess(
        visitExpression(node.object),
        visitExpression(node.index));
  }

  @override
  js.Expression visitSetIndex(tree_ir.SetIndex node) {
    js.Expression index = new js.PropertyAccess(
        visitExpression(node.object), visitExpression(node.index));
    return makeAssignment(index, node.value, compound: node.compound);
  }

  js.Expression buildStaticHelperInvocation(
      FunctionElement helper,
      List<js.Expression> arguments,
      {SourceInformation sourceInformation}) {
    registry.registerStaticUse(new StaticUse.staticInvoke(
        helper, new CallStructure.unnamed(arguments.length)));
    return buildStaticInvoke(
        helper, arguments, sourceInformation: sourceInformation);
  }

  @override
  js.Expression visitReifyRuntimeType(tree_ir.ReifyRuntimeType node) {
    js.Expression typeToString = buildStaticHelperInvocation(
        glue.getRuntimeTypeToString(),
        [visitExpression(node.value)],
        sourceInformation: node.sourceInformation);
    return buildStaticHelperInvocation(
        glue.getCreateRuntimeType(),
        [typeToString],
        sourceInformation: node.sourceInformation);
  }

  @override
  js.Expression visitReadTypeVariable(tree_ir.ReadTypeVariable node) {
    ClassElement context = node.variable.element.enclosingClass;
    js.Expression index = js.number(glue.getTypeVariableIndex(node.variable));
    if (glue.needsSubstitutionForTypeVariableAccess(context)) {
      js.Expression typeName = glue.getRuntimeTypeName(context);
      return buildStaticHelperInvocation(
          glue.getRuntimeTypeArgument(),
          [visitExpression(node.target), typeName, index],
          sourceInformation: node.sourceInformation);
    } else {
      return buildStaticHelperInvocation(
          glue.getTypeArgumentByIndex(),
          [visitExpression(node.target), index],
          sourceInformation: node.sourceInformation);
    }
  }

  @override
  js.Expression visitTypeExpression(tree_ir.TypeExpression node) {
    List<js.Expression> arguments = visitExpressionList(node.arguments);
    switch (node.kind) {
      case tree_ir.TypeExpressionKind.COMPLETE:
        return glue.generateTypeRepresentation(
            node.dartType, arguments, registry);
      case tree_ir.TypeExpressionKind.INSTANCE:
        // We expect only flat types for the INSTANCE representation.
        assert(node.dartType ==
               (node.dartType.element as ClassElement).thisType);
        registry.registerInstantiatedClass(glue.listClass);
        return new js.ArrayInitializer(arguments);
    }
  }

  js.Node handleForeignCode(tree_ir.ForeignCode node) {
    if (node.dependency != null) {
      // Dependency is only used if [node] calls a Dart function. Currently only
      // through foreign function `RAW_DART_FUNCTION_REF`.
      registry.registerStaticUse(
          new StaticUse.staticInvoke(
              node.dependency,
              new CallStructure.unnamed(node.arguments.length)));
    }
    // TODO(sra,johnniwinther): Should this be in CodegenRegistry?
    glue.registerNativeBehavior(node.nativeBehavior, node);
    return node.codeTemplate.instantiate(visitExpressionList(node.arguments));
  }

  @override
  js.Expression visitForeignExpression(tree_ir.ForeignExpression node) {
    return handleForeignCode(node);
  }

  @override
  void visitForeignStatement(tree_ir.ForeignStatement node) {
    accumulator.add(handleForeignCode(node));
  }

  @override
  visitYield(tree_ir.Yield node) {
    js.Expression value = visitExpression(node.input);
    accumulator.add(new js.DartYield(value, node.hasStar));
    return node.next;
  }

  @override
  visitReceiverCheck(tree_ir.ReceiverCheck node) {
    js.Expression value = visitExpression(node.value);
    // TODO(sra): Try to use the selector even when [useSelector] is false. The
    // reason we use 'toString' is that it is always defined so avoids a slow
    // lookup (in V8) of an absent property. We could use the property for the
    // selector if we knew it was present. The property is present if the
    // associated method was not inlined away, or if there is a noSuchMethod
    // hook for that selector. We don't know these things here, but the decision
    // could be deferred by creating a deferred property that was resolved after
    // codegen.
    js.Expression access = node.useSelector
        ? js.js('#.#', [value, glue.invocationName(node.selector)])
        : js.js('#.toString', [value]);
    if (node.useInvoke) {
      access = new js.Call(access, []);
    }
    if (node.condition != null) {
      js.Expression condition = visitExpression(node.condition);
      js.Statement body = isNullReturn(node.next)
          ? new js.ExpressionStatement(access)
          : new js.Return(access);
      accumulator.add(new js.If.noElse(condition, body));
    } else {
      accumulator.add(new js.ExpressionStatement(access));
    }
    return node.next;
  }

  @override
  js.Expression visitApplyBuiltinOperator(tree_ir.ApplyBuiltinOperator node) {
    List<js.Expression> args = visitExpressionList(node.arguments);
    switch (node.operator) {
      case BuiltinOperator.NumAdd:
        return new js.Binary('+', args[0], args[1]);
      case BuiltinOperator.NumSubtract:
        return new js.Binary('-', args[0], args[1]);
      case BuiltinOperator.NumMultiply:
        return new js.Binary('*', args[0], args[1]);
      case BuiltinOperator.NumDivide:
        return new js.Binary('/', args[0], args[1]);
      case BuiltinOperator.NumRemainder:
        return new js.Binary('%', args[0], args[1]);
      case BuiltinOperator.NumTruncatingDivideToSigned32:
        return js.js('(# / #) | 0', args);
      case BuiltinOperator.NumAnd:
        return normalizeBitOp(js.js('# & #', args), node);
      case BuiltinOperator.NumOr:
        return normalizeBitOp(js.js('# | #', args), node);
      case BuiltinOperator.NumXor:
        return normalizeBitOp(js.js('# ^ #', args), node);
      case BuiltinOperator.NumLt:
        return new js.Binary('<', args[0], args[1]);
      case BuiltinOperator.NumLe:
        return new js.Binary('<=', args[0], args[1]);
      case BuiltinOperator.NumGt:
        return new js.Binary('>', args[0], args[1]);
      case BuiltinOperator.NumGe:
        return new js.Binary('>=', args[0], args[1]);
      case BuiltinOperator.NumShl:
        return normalizeBitOp(js.js('# << #', args), node);
      case BuiltinOperator.NumShr:
        // No normalization required since output is always uint32.
        return js.js('# >>> #', args);
      case BuiltinOperator.NumBitNot:
        return js.js('(~#) >>> 0', args);
      case BuiltinOperator.NumNegate:
        return js.js('-#', args);
      case BuiltinOperator.StringConcatenate:
        if (args.isEmpty) return js.string('');
        return args.reduce((e1,e2) => new js.Binary('+', e1, e2));
      case BuiltinOperator.CharCodeAt:
        return js.js('#.charCodeAt(#)', args);
      case BuiltinOperator.Identical:
        registry.registerStaticUse(new StaticUse.staticInvoke(
            glue.identicalFunction, new CallStructure.unnamed(args.length)));
        return buildStaticHelperInvocation(glue.identicalFunction, args);
      case BuiltinOperator.StrictEq:
        return new js.Binary('===', args[0], args[1]);
      case BuiltinOperator.StrictNeq:
        return new js.Binary('!==', args[0], args[1]);
      case BuiltinOperator.LooseEq:
        return new js.Binary('==', args[0], args[1]);
      case BuiltinOperator.LooseNeq:
        return new js.Binary('!=', args[0], args[1]);
      case BuiltinOperator.IsFalsy:
        return new js.Prefix('!', args[0]);
      case BuiltinOperator.IsNumber:
        return js.js('typeof # === "number"', args);
      case BuiltinOperator.IsNotNumber:
        return js.js('typeof # !== "number"', args);
      case BuiltinOperator.IsFloor:
        return js.js('Math.floor(#) === #', args);
      case BuiltinOperator.IsInteger:
        return js.js('typeof # === "number" && Math.floor(#) === #', args);
      case BuiltinOperator.IsNotInteger:
        return js.js('typeof # !== "number" || Math.floor(#) !== #', args);
      case BuiltinOperator.IsUnsigned32BitInteger:
        return js.js('# >>> 0 === #', args);
      case BuiltinOperator.IsNotUnsigned32BitInteger:
        return js.js('# >>> 0 !== #', args);
      case BuiltinOperator.IsFixedLengthJSArray:
        // TODO(sra): Remove boolify (i.e. !!).
        return js.js(r'!!#.fixed$length', args);
      case BuiltinOperator.IsExtendableJSArray:
        return js.js(r'!#.fixed$length', args);
      case BuiltinOperator.IsModifiableJSArray:
        return js.js(r'!#.immutable$list', args);
      case BuiltinOperator.IsUnmodifiableJSArray:
        // TODO(sra): Remove boolify (i.e. !!).
        return js.js(r'!!#.immutable$list', args);
    }
  }

  /// Add a uint32 normalization `op >>> 0` to [op] if it is not in 31-bit
  /// range.
  js.Expression normalizeBitOp(js.Expression op,
                               tree_ir.ApplyBuiltinOperator node) {
    const MAX_UINT31 = 0x7fffffff;
    const MAX_UINT32 = 0xffffffff;

    int constantValue(tree_ir.Expression e) {
      if (e is tree_ir.Constant) {
        ConstantValue value = e.value;
        if (!value.isInt) return null;
        IntConstantValue intConstant = value;
        if (intConstant.primitiveValue < 0) return null;
        if (intConstant.primitiveValue > MAX_UINT32) return null;
        return intConstant.primitiveValue;
      }
      return null;
    }

    /// Returns a value of the form 0b0001xxxx to represent the highest bit set
    /// in the result.  This represents the range [0, 0b00011111], up to 32
    /// bits.  `null` represents a result possibly outside the uint32 range.
    int maxBitOf(tree_ir.Expression e) {
      if (e is tree_ir.Constant) {
        return constantValue(e);
      }
      if (e is tree_ir.ApplyBuiltinOperator) {
        if (e.operator == BuiltinOperator.NumAnd) {
          int left = maxBitOf(e.arguments[0]);
          int right = maxBitOf(e.arguments[1]);
          if (left == null && right == null) return MAX_UINT32;
          if (left == null) return right;
          if (right == null) return left;
          return (left < right) ? left : right;
        }
        if (e.operator == BuiltinOperator.NumOr ||
            e.operator == BuiltinOperator.NumXor) {
          int left = maxBitOf(e.arguments[0]);
          int right = maxBitOf(e.arguments[1]);
          if (left == null || right == null) return MAX_UINT32;
          return left | right;
        }
        if (e.operator == BuiltinOperator.NumShr) {
          int right = constantValue(e.arguments[1]);
          // NumShr is JavaScript '>>>' so always generates a uint32 result.
          if (right == null || right <= 0 || right > 31) return MAX_UINT32;
          int left = maxBitOf(e.arguments[0]);
          if (left == null) return MAX_UINT32;
          return left >> right;
        }
        if (e.operator == BuiltinOperator.NumShl) {
          int right = constantValue(e.arguments[1]);
          if (right == null || right <= 0 || right > 31) return MAX_UINT32;
          int left = maxBitOf(e.arguments[0]);
          if (left == null) return MAX_UINT32;
          if (left.bitLength + right > 31) return MAX_UINT32;
          return left << right;
        }
      }
      return null;
    }

    int maxBit = maxBitOf(node);
    if (maxBit != null && maxBit <= MAX_UINT31) return op;
    return js.js('# >>> 0', [op]);
  }

  @override
  js.Expression visitApplyBuiltinMethod(tree_ir.ApplyBuiltinMethod node) {
    js.Expression receiver = visitExpression(node.receiver);
    List<js.Expression> args = visitExpressionList(node.arguments);
    switch (node.method) {
      case BuiltinMethod.Push:
        return js.js('#.push(#)', [receiver, args]);

      case BuiltinMethod.Pop:
        return js.js('#.pop()', [receiver]);

      case BuiltinMethod.SetLength:
        return js.js('#.length = #', [receiver, args[0]]);
    }
  }

  @override
  js.Expression visitAwait(tree_ir.Await node) {
    return new js.Await(visitExpression(node.input));
  }

  /// Ensures that parameter defaults will be emitted.
  ///
  /// Ideally, this should be done when generating the relevant stub methods,
  /// since those are the ones that actually reference the constants, but those
  /// are created by the emitter when it is too late to register new constants.
  ///
  /// For non-static methods, we have no way of knowing if the defaults are
  /// actually used, so we conservatively register them all.
  void registerDefaultParameterValues(ExecutableElement element) {
    if (element is! FunctionElement) return;
    FunctionElement function = element;
    if (function.isStatic) return; // Defaults are inlined at call sites.
    function.functionSignature.forEachOptionalParameter((param) {
      ConstantValue constant = glue.getDefaultParameterValue(param);
      registry.registerCompileTimeConstant(constant);
    });
  }
}