transformComprehension(tree, statement, isGenerator,
      prefix = undefined, suffix = undefined) {

    // This should really be a let but we don't support let in generators.
    // https://code.google.com/p/traceur-compiler/issues/detail?id=6
    let bindingKind = isGenerator || !this.options.blockBinding ? VAR : LET;

    let statements = prefix ? [prefix] : [];

    for (let i = tree.comprehensionList.length - 1; i >= 0; i--) {
      let item = tree.comprehensionList[i];
      switch (item.type) {
        case COMPREHENSION_IF: {
          let expression = this.transformAny(item.expression);
          statement = createIfStatement(expression, statement);
          break;
        }
        case COMPREHENSION_FOR: {
          let left = this.transformAny(item.left);
          let iterator = this.transformAny(item.iterator);
          let initializer = createVariableDeclarationList(bindingKind,
                                                          left, null);
          statement = createForOfStatement(initializer, iterator, statement);
          break;
        }
        default:
          throw new Error('Unreachable.');
      }
    }

    statement = alphaRenameThisAndArguments(this, statement);

    statements.push(statement);
    if (suffix)
      statements.push(suffix);

    let functionKind = isGenerator ? new Token(STAR, null) : null;

    let func = new FunctionExpression(null, null, functionKind,
                                      createEmptyParameterList(), null, [],
                                      createFunctionBody(statements));

    return createParenExpression(createCallExpression(func));
  }
transformArrayComprehension and transformGeneratorComprehension calls
this
@param {ArrayComprehension|GeneratorComprehension} tree
@param {ParseTree} statement The statement that goes inside the innermost
    loop (and if if present).
@param {boolean} isGenerator
@param {ParseTree=} prefix
@param {ParseTree=} suffix
@return {ParseTree}