parseArrowFunction_(start, tree, asyncToken) {
    let formals;
    let kind = FUNCTION_STATE_ARROW;
    if (asyncToken && asyncToken.value === ASYNC) {
      kind |= FUNCTION_STATE_ASYNC;
    }
    let fs = this.pushFunctionState_(kind);
    let makeFormals = (tree) => {
      return new FormalParameterList(this.getTreeLocation_(start),
          [new FormalParameter(tree.location,
              new BindingElement(tree.location, tree, null), null, [])]);
    };
    switch (tree.type) {
      case IDENTIFIER_EXPRESSION:
        formals = makeFormals(
              new BindingIdentifier(tree.location, tree.identifierToken));
        break;
      case BINDING_IDENTIFIER:
        formals = makeFormals(tree);
        break;
      case FORMAL_PARAMETER_LIST:
        formals = tree;
        break;
      default:
        formals = this.toFormalParameters_(start, tree, asyncToken);
    }

    this.eat_(ARROW);
    let body = this.parseConciseBody_(formals);
    this.popFunctionState_(fs);
    return new ArrowFunction(this.getTreeLocation_(start),
        asyncToken, formals, body);
  }
Parses arrow functions and paren expressions as well as delegates to
{@code parseGeneratorComprehension_} if this begins a generator
comprehension.

Arrow function support, see:
http://wiki.ecmascript.org/doku.php?id=strawman:arrow_function_syntax

Generator comprehensions syntax is in the ES6 draft,
11.1.7 Generator Comprehensions

ArrowFunction :
  ArrowParameters => ConciseBody

ArrowParameters :
  BindingIdentifer
  CoverParenthesizedExpressionAndArrowParameterList

CoverParenthesizedExpressionAndArrowParameterList :
  ( Expression )
  ( )
  ( ... BindingIdentifier )
  ( Expression , ... BindingIdentifier )

ConciseBody :
  [lookahead not {] AssignmentExpression
  { FunctionBody }


@param {number} start
@param {ParseTree} tree
@param {Token}
@return {ParseTree}
@private