Alternate if syntax support

Summary:
Support for statements of the style
```
if ($v < 0):
  ++$v;
elseif ($v < 1):
  ++$v;
else:
  ++$v;
endif;
```
in the full fidelity parser.

Reviewed By: jamesjwu

Differential Revision: D6965574

fbshipit-source-id: ea416b5835bbca40cdde7de5ab57b530ec378e54

hphp/hack/src/hackfmt/hack_format.ml

@@ -816,17 +816,17 @@ let rec t (env: Env.t) (node: Syntax.t) : Doc.t =
        ]
      | _ -> handle_possible_compound_statement env x.else_statement
    ]
  | Syntax.IfEndIfStatement {
      if_endif_keyword = kw;
      if_endif_left_paren = left_p;
      if_endif_condition = condition;
      if_endif_right_paren = right_p;
      if_endif_colon = colon;
      if_endif_statement = if_body;
      if_endif_elseif_colon_clauses = elseif_clauses;
      if_endif_else_colon_clause = else_clause;
      if_endif_endif_keyword = endif_kw;
      if_endif_semicolon = semicolon; } ->
  | Syntax.AlternateIfStatement {
      alternate_if_keyword = kw;
      alternate_if_left_paren = left_p;
      alternate_if_condition = condition;
      alternate_if_right_paren = right_p;
      alternate_if_colon = colon;
      alternate_if_statement = if_body;
      alternate_if_elseif_clauses = elseif_clauses;
      alternate_if_else_clause = else_clause;
      alternate_if_endif_keyword = endif_kw;
      alternate_if_semicolon = semicolon; } ->
    Concat [
      t env kw;
      Space;
@@ -839,30 +839,30 @@ let rec t (env: Env.t) (node: Syntax.t) : Doc.t =
      t env semicolon;
      Newline;
    ]
  | Syntax.ElseifColonClause {
      elseif_colon_keyword = kw;
      elseif_colon_left_paren = left_p;
      elseif_colon_condition = condition;
      elseif_colon_right_paren = right_p;
      elseif_colon_colon = colon;
      elseif_colon_statement = body; } ->
  | Syntax.AlternateElseifClause {
      alternate_elseif_keyword = kw;
      alternate_elseif_left_paren = left_p;
      alternate_elseif_condition = condition;
      alternate_elseif_right_paren = right_p;
      alternate_elseif_colon = colon;
      alternate_elseif_statement = body; } ->
    Concat [
      t env kw;
      Space;
      transform_condition env left_p condition right_p;
      t env colon;
      handle_possible_compound_statement env body;
    ]
  | Syntax.ElseColonClause x ->
  | Syntax.AlternateElseClause x ->
    Concat [
      t env x.else_colon_keyword;
      match Syntax.syntax x.else_colon_statement with
      t env x.alternate_else_keyword;
      match Syntax.syntax x.alternate_else_statement with
      | Syntax.IfStatement _ -> Concat [
          Space;
          t env x.else_colon_statement;
          t env x.alternate_else_statement;
          Space;
        ]
      | _ -> handle_possible_compound_statement env x.else_colon_statement
      | _ -> handle_possible_compound_statement env x.alternate_else_statement
    ]
  | Syntax.TryStatement {
      try_keyword = kw;

hphp/hack/src/parser/full_fidelity_ast.ml

@@ -1502,33 +1502,44 @@ and pStmt : stmt parser = fun node env ->
    , List.concat @@ couldMap ~f:pSwitchSection sections env
    )
  | IfStatement
    { if_condition; if_statement; if_elseif_clauses; if_else_clause; _ } ->
    { if_condition=cond;
      if_statement=stmt;
      if_elseif_clauses=elseif_clause;
      if_else_clause=else_clause; _ }
  | AlternateIfStatement
    { alternate_if_condition=cond;
      alternate_if_statement=stmt;
      alternate_if_elseif_clauses=elseif_clause;
      alternate_if_else_clause=else_clause; _ } ->
    (* Because consistency is for the weak-willed, Parser_hack does *not*
     * produce `Noop`s for compound statements **in if statements**
     *)
    let de_noop = function
    | [p, Block [_, Noop]] -> [p, Block []]
    | stmts -> stmts
    in
    let if_condition = pExpr if_condition env in
    let if_statement = de_noop (pStmtUnsafe if_statement env) in
    let if_condition = pExpr cond env in
    let if_statement = de_noop (pStmtUnsafe stmt env) in
    let if_elseif_statement =
      let pElseIf : (block -> block) parser = fun node env ->
        match syntax node with
        | ElseifClause { elseif_condition; elseif_statement; _ } ->
        | ElseifClause { elseif_condition=ei_cond; elseif_statement=ei_stmt; _ }
        | AlternateElseifClause { alternate_elseif_condition=ei_cond;
          alternate_elseif_statement=ei_stmt; _ } ->
          fun next_clause ->
            let elseif_condition = pExpr elseif_condition env in
            let elseif_statement = de_noop (pStmtUnsafe elseif_statement env) in
            let elseif_condition = pExpr ei_cond env in
            let elseif_statement = de_noop (pStmtUnsafe ei_stmt env) in
            [ pos, If (elseif_condition, elseif_statement, next_clause) ]
        | _ -> missing_syntax "elseif clause" node env
      in
      List.fold_right ~f:(@@)
          (couldMap ~f:pElseIf if_elseif_clauses env)
          ~init:( match syntax if_else_clause with
            | ElseClause { else_statement; _ } ->
              de_noop (pStmtUnsafe else_statement env)
          (couldMap ~f:pElseIf elseif_clause env)
          ~init:( match syntax else_clause with
            | ElseClause { else_statement=e_stmt; _ }
            | AlternateElseClause { alternate_else_statement=e_stmt; _ } ->
              de_noop (pStmtUnsafe e_stmt env)
            | Missing -> [Pos.none, Noop]
            | _ -> missing_syntax "else clause" if_else_clause env
            | _ -> missing_syntax "else clause" else_clause env
          )
    in
    pos, If (if_condition, if_statement, if_elseif_statement)
@@ -1545,6 +1556,8 @@ and pStmt : stmt parser = fun node env ->
    handle_loop_body pos compound_statements tail env
  | AlternateLoopStatement { alternate_loop_statements; _ } ->
    handle_loop_body pos alternate_loop_statements [] env
  | SyntaxList _ ->
    handle_loop_body pos node [] env
  | ThrowStatement { throw_expression; _ } ->
    pos, Throw (pExpr throw_expression env)
  | DoStatement { do_body; do_condition; _ } ->

hphp/hack/src/parser/full_fidelity_parser_helpers.ml

@@ -856,6 +856,12 @@ module WithParser(Parser : Parser_S) = struct
    let predicate parser = peek_token_kind parser != terminator in
    parse_list_while parser parse_item predicate

  let parse_alternate_if_block parser parse_item =
    parse_list_while parser parse_item (fun parser ->
      match peek_token_kind parser with
      | TokenKind.Elseif | TokenKind.Else | TokenKind.Endif -> false
      | _ -> true)

  let parse_list_until_none parser parse_item =
    let rec aux parser acc =
      let (parser, maybe_item) = parse_item parser in

hphp/hack/src/parser/full_fidelity_pretty_printer.ml

@@ -732,20 +732,21 @@ let rec get_doc node =
    let statement = x.else_statement in
    handle_compound_brace_prefix_indent keyword statement indt
    |> add_break
  | IfEndIfStatement
    { if_endif_keyword; if_endif_colon; if_endif_left_paren; if_endif_condition;
      if_endif_right_paren; if_endif_statement; if_endif_elseif_colon_clauses;
      if_endif_else_colon_clause; if_endif_endif_keyword; if_endif_semicolon }->
    let keyword = get_doc if_endif_keyword in
    let left = get_doc if_endif_left_paren in
    let condition = get_doc if_endif_condition in
    let right = get_doc if_endif_right_paren in
    let colon = get_doc if_endif_colon in
    let if_stmt = if_endif_statement in
    let elseif_clause = get_doc if_endif_elseif_colon_clauses in
    let else_clause = get_doc if_endif_else_colon_clause in
    let end_kw = get_doc if_endif_endif_keyword in
    let semicolon = get_doc if_endif_semicolon in
  | AlternateIfStatement
    { alternate_if_keyword; alternate_if_colon; alternate_if_left_paren;
      alternate_if_condition; alternate_if_right_paren; alternate_if_statement;
      alternate_if_elseif_clauses; alternate_if_else_clause;
      alternate_if_endif_keyword; alternate_if_semicolon }->
    let keyword = get_doc alternate_if_keyword in
    let left = get_doc alternate_if_left_paren in
    let condition = get_doc alternate_if_condition in
    let right = get_doc alternate_if_right_paren in
    let colon = get_doc alternate_if_colon in
    let if_stmt = alternate_if_statement in
    let elseif_clause = get_doc alternate_if_elseif_clauses in
    let else_clause = get_doc alternate_if_else_clause in
    let end_kw = get_doc alternate_if_endif_keyword in
    let semicolon = get_doc alternate_if_semicolon in
    let left_part = group_doc (keyword ^^| left) in
    let right_part = group_doc (right ^^^ colon) in
    let end_block = group_doc (end_kw ^^^ semicolon) in
@@ -754,23 +755,23 @@ let rec get_doc node =
      handle_compound_brace_prefix_indent start_block if_stmt indt in
    let if_statement = add_break if_statement in
    group_doc (if_statement ^| elseif_clause ^| else_clause ^| end_block)
  | ElseifColonClause
    { elseif_colon_keyword; elseif_colon_left_paren; elseif_colon_condition;
      elseif_colon_right_paren; elseif_colon_colon; elseif_colon_statement }  ->
    let keyword = get_doc elseif_colon_keyword in
    let left = get_doc elseif_colon_left_paren in
    let condition = get_doc elseif_colon_condition in
    let right = get_doc elseif_colon_right_paren in
    let colon = get_doc elseif_colon_colon in
    let elif_statement_syntax = elseif_colon_statement in
  | AlternateElseifClause
    { alternate_elseif_keyword; alternate_elseif_left_paren; alternate_elseif_condition;
      alternate_elseif_right_paren; alternate_elseif_colon; alternate_elseif_statement }  ->
    let keyword = get_doc alternate_elseif_keyword in
    let left = get_doc alternate_elseif_left_paren in
    let condition = get_doc alternate_elseif_condition in
    let right = get_doc alternate_elseif_right_paren in
    let colon = get_doc alternate_elseif_colon in
    let elif_statement_syntax = alternate_elseif_statement in
    let left_part = group_doc (keyword ^^| left) in
    let right_part = group_doc (right ^^^ colon) in
    let start_block = indent_block_no_space left_part condition right_part indt in
    handle_compound_brace_prefix_indent start_block elif_statement_syntax indt
    |> add_break
  | ElseColonClause x ->
    let keyword = get_doc x.else_colon_keyword in
    let statement = x.else_colon_statement in
  | AlternateElseClause x ->
    let keyword = get_doc x.alternate_else_keyword in
    let statement = x.alternate_else_statement in
    handle_compound_brace_prefix_indent keyword statement indt
    |> add_break
  | TryStatement

hphp/hack/src/parser/full_fidelity_statement_parser.ml

@@ -469,18 +469,29 @@ module WithExpressionAndDeclAndTypeParser
  and parse_if_statement parser =
    (* SPEC:
  if-statement:
    if   (   expression   )   statement   elseif-clauses-opt   else-clause-opt
    if   (   expression   )   statement   elseif-clauses-opt    else-clause-opt
    if   (   expression   ):  statement   alt-elif-clauses-opt  alt-else-clause-opt endif;

  elseif-clauses:
    elseif-clause
    elseif-clauses   elseif-clause

  alt-elif-clauses:
    alt-elif-clause
    alt-elif-clauses   alt-elif-clause

  elseif-clause:
    elseif   (   expression   )   statement

  alt-elif-clause:
    elseif   (   expression   ):  statement

  else-clause:
    else   statement

  alt-else-clause:
    else:  statement

    *)

    (* parses the "( expr ) statement" segment of If, Elseif or Else clauses.
@@ -489,18 +500,48 @@ module WithExpressionAndDeclAndTypeParser
    let parse_if_body_helper parser_body =
      let (parser_body, left_paren_token, expr_node, right_paren_token) =
        parse_paren_expr parser_body in
      let (parser_body, statement_node) = parse_statement parser_body in
        (parser_body, left_paren_token, expr_node, right_paren_token,
        statement_node)
      let parser1, opening_token = next_token parser_body in
      let opening_token_syntax = make_token opening_token in
      let (parser_body, statement_node) = match Token.kind opening_token with
      | Colon -> parse_alternate_if_block parser1 parse_statement
      | _ -> parse_statement parser_body in
      ( parser_body
      , left_paren_token
      , expr_node
      , right_paren_token
      , opening_token
      , opening_token_syntax
      , statement_node
      )
    in
    let parse_elseif_opt parser_elseif =
      if peek_token_kind parser_elseif = Elseif then
        let (parser_elseif, elseif_token) = assert_token parser_elseif Elseif in
        let (parser_elseif, elseif_left_paren, elseif_condition_expr,
          elseif_right_paren, elseif_statement) =
        let ( parser_elseif
            , elseif_left_paren
            , elseif_condition_expr
            , elseif_right_paren
            , elseif_opening_token
            , elseif_opening_token_syntax
            , elseif_statement
            ) =
          parse_if_body_helper parser_elseif in
        let elseif_syntax = make_elseif_clause elseif_token elseif_left_paren
          elseif_condition_expr elseif_right_paren elseif_statement in
        let elseif_syntax = match Token.kind elseif_opening_token with
        | Colon ->
          make_alternate_elseif_clause
            elseif_token
            elseif_left_paren
            elseif_condition_expr
            elseif_right_paren
            elseif_opening_token_syntax
            elseif_statement
        | _ ->
          make_elseif_clause
            elseif_token
            elseif_left_paren
            elseif_condition_expr
            elseif_right_paren
            elseif_statement in
        (parser_elseif, Some elseif_syntax)
      else
        (parser_elseif, None)
@@ -511,19 +552,59 @@ module WithExpressionAndDeclAndTypeParser
      if is_missing else_token then
        (parser_else, else_token)
      else
        let (parser_else, else_consequence) = parse_statement parser_else in
        let else_syntax = make_else_clause else_token else_consequence in
        (parser_else, else_syntax)
        let parser1, opening_token = next_token parser_else in
        match Token.kind opening_token with
        | Colon ->
          let opening_token_syntax = make_token opening_token in
          let (parser_else, else_consequence) =
            parse_alternate_if_block parser1 parse_statement in
          (parser_else, make_alternate_else_clause else_token opening_token_syntax else_consequence)
        | _ ->
          let (parser_else, else_consequence) = parse_statement parser_else in
          (parser_else, make_else_clause else_token else_consequence)
    in
    let (parser, if_keyword_token) = assert_token parser If in
    let (parser, if_left_paren, if_expr, if_right_paren, if_consequence) =
    let ( parser
        , if_left_paren
        , if_expr
        , if_right_paren
        , if_opening_token
        , if_opening_token_syntax
        , if_consequence
        ) =
      parse_if_body_helper parser in
    let (parser, elseif_syntax) =
      parse_list_until_none parser parse_elseif_opt in
    let (parser, else_syntax) = parse_else_opt parser in
    let syntax = make_if_statement if_keyword_token if_left_paren if_expr
      if_right_paren if_consequence elseif_syntax else_syntax in
    (parser, syntax)
    match Token.kind if_opening_token with
    | Colon ->
      let (parser, closing_token) = require_token parser Endif
        (SyntaxError.error1059 Endif) in
      let (parser, semicolon_token) = require_semicolon parser in
      ( parser
      , make_alternate_if_statement
          if_keyword_token
          if_left_paren
          if_expr
          if_right_paren
          if_opening_token_syntax
          if_consequence
          elseif_syntax
          else_syntax
          closing_token
          semicolon_token
      )
    | _ ->
      ( parser
      , make_if_statement
          if_keyword_token
          if_left_paren
          if_expr
          if_right_paren
          if_consequence
          elseif_syntax
          else_syntax
      )

  and parse_switch_statement parser =
    (* SPEC: