parseAssignmentExpression_(allowIn) {
    if (this.allowYield_ && peek(YIELD))
      return this.parseYieldExpression_(allowIn);

    let start = this.getTreeStartLocation_();

    let validAsyncParen = false;

    if (this.options_.asyncFunctions && this.peekPredefinedString_(ASYNC)) {
      let asyncToken = peekToken();
      let maybeOpenParenToken = peekTokenLookahead();
      validAsyncParen = maybeOpenParenToken.type === OPEN_PAREN &&
          asyncToken.location.end.line ===
              maybeOpenParenToken.location.start.line;
    }

    let left = this.parseConditional_(allowIn);
    let type = peekType();

    if (this.options_.asyncFunctions && left.type === IDENTIFIER_EXPRESSION &&
        left.identifierToken.value === ASYNC && type === IDENTIFIER) {
      if (peekTokenNoLineTerminator() !== null) {
        let bindingIdentifier = this.parseBindingIdentifier_();
        let asyncToken = left.identifierToken;
        return this.parseArrowFunction_(start, bindingIdentifier,
            asyncToken);
      }
    }

    if (type === ARROW && peekTokenNoLineTerminator() !== null) {
      if (left.type === COVER_FORMALS || left.type === IDENTIFIER_EXPRESSION)
        return this.parseArrowFunction_(start, left, null);

      if (validAsyncParen && left.type === CALL_EXPRESSION) {
        let asyncToken = left.operand.identifierToken;
        return this.parseArrowFunction_(start, left.args, asyncToken);
      }
    }

    left = this.coverFormalsToParenExpression_(left);

    if (this.peekAssignmentOperator_(type)) {
      if (type === EQUAL)
        left = this.transformLeftHandSideExpression_(left);

      this.validateAssignmentTarget_(left, 'assignment');

      let operator = nextToken();
      let right = this.parseAssignmentExpression_(allowIn);

      return new BinaryExpression(this.getTreeLocation_(start), left, operator, right);
    }

    return left;
  }
AssignmentExpression :
  ConditionalExpression
  YieldExpression
  ArrowFunction
  AsyncArrowFunction
  LeftHandSideExpression = AssignmentExpression
  LeftHandSideExpression AssignmentOperator AssignmentExpression

AssignmentExpressionNoIn :
  ConditionalExpressionNoIn
  YieldExpression
  ArrowFunction
  AsyncArrowFunction
  LeftHandSideExpression = AssignmentExpressionNoIn
  LeftHandSideExpression AssignmentOperator AssignmentExpressionNoIn

@param {boolean} allowIn
@return {ParseTree}