Recover from parsing two postfix ops (#2228)

* WIP: Recover from parsing two postfix ops

fixes #126

* Tests and refactor

Author: anmonteiro

formatTest/unit_tests/expected_output/infix.re

@@ -1311,3 +1311,10 @@ let not = x => !x;
 let other = x => not(x);
 
 let derefInsideArray = [|a^|];
+
+/* https://github.com/facebook/reason/issues/126 */
+foo^ ^;
+
+let x = foo^ ^;
+
+foo ^^ bar;

formatTest/unit_tests/input/infix.re

@@ -1004,3 +1004,10 @@ let not = (x) => !x;
 let other = (x) => not(x);
 
 let derefInsideArray = [|a^|];
+
+/* https://github.com/facebook/reason/issues/126 */
+foo^^;
+
+let x = foo^^;
+
+foo^^bar;

src/reason-parser/reason_syntax_util.ml

@@ -518,4 +518,9 @@ let location_contains loc1 loc2 =
   loc1.loc_start.Lexing.pos_cnum <= loc2.loc_start.Lexing.pos_cnum &&
   loc1.loc_end.Lexing.pos_cnum >= loc2.loc_end.Lexing.pos_cnum
 
+let explode_str str =
+  let rec loop acc i =
+    if i < 0 then acc else loop (str.[i] :: acc) (i - 1)
+  in
+    loop [] (String.length str - 1)
 (* #end *)

src/reason-parser/reason_syntax_util.mli

@@ -108,4 +108,5 @@ val location_is_before : Ast_404.Location.t -> Ast_404.Location.t -> bool
 
 val location_contains : Ast_404.Location.t -> Ast_404.Location.t -> bool
 
+val explode_str : string -> char list
 (* #end *)

src/reason-parser/reason_toolchain.ml

@@ -607,6 +607,17 @@ module Reason_syntax = struct
   let offer_normalize checkpoint triple =
     normalize_checkpoint (I.offer checkpoint triple)
 
+  let offer_normalize_many checkpoint triples =
+    let rec loop acc xs = match xs with
+    | [] -> Some acc
+    | triple :: xs ->
+      begin match normalize_checkpoint (I.offer acc triple) with
+      | I.InputNeeded _ as checkpoint' -> loop checkpoint' xs
+      | _ -> None
+      end
+    in
+    loop checkpoint triples
+
   (* Insert a semicolon before submitting a token to the parser *)
   let try_inserting_semi_on = function
     | Reason_parser.LET
@@ -662,6 +673,21 @@ module Reason_syntax = struct
           Some (offer_normalize checkpoint' (token, pos, pos))
     | _ -> None
 
+  let try_inserting_postfix checkpoint infix ((_, pos, _) as triple) =
+    (* we know that the infix was exclusively composed of '^' *)
+    let rec mk_postfixes acc i =
+      if i < 0 then
+        acc
+      else
+        let triple = (Reason_parser.POSTFIXOP "^", pos, pos) in
+        mk_postfixes (triple :: acc) (i - 1)
+    in
+    let infixes = mk_postfixes [] (String.length infix - 1) in
+    match offer_normalize_many checkpoint infixes with
+    | Some (I.InputNeeded _ as checkpoint') ->
+        Some (offer_normalize checkpoint' triple)
+    | _ -> None
+
   (* Offer and insert a semicolon in case of failure *)
   let offer_normalize checkpoint triple =
     match offer_normalize checkpoint triple with
@@ -784,6 +810,40 @@ module Reason_syntax = struct
       in
       handle_inputs_needed supplier (List.map process_checkpoint checkpoints)
 
+    (*
+     * This catches the `foo^^` case (which the parser thinks is an error – infix
+     * without 2nd operand) and inserts as many postfix ops as there are carets
+     * in the operator. We catch the token here and don't actually fork checkpoints
+     * because catching this in `handle_other` would be too late – we would only
+     * see the token where the error was (e.g. semicolon).
+     *)
+    | Reason_parser.INFIXOP1 op, _, _ as triple
+      when List.for_all (fun x -> x == '^') (Reason_syntax_util.explode_str op) ->
+      let rec process_checkpoints inputs_needed checkpoints =
+        match checkpoints with
+        | [] -> handle_inputs_needed supplier inputs_needed
+        | (invalid_docstrings, checkpoint) :: tl ->
+          begin match offer_normalize checkpoint triple with
+          | I.InputNeeded _ as checkpoint' ->
+            let next_triple = read supplier in
+            begin match offer_normalize checkpoint' next_triple with
+            | I.HandlingError _ ->
+              begin match try_inserting_postfix checkpoint op next_triple with
+              | Some (I.Accepted _ as cp) -> handle_other supplier cp
+              | Some cp ->
+                process_checkpoints ((invalid_docstrings, cp) :: inputs_needed) tl
+              | None ->
+                process_checkpoints ((invalid_docstrings, checkpoint') :: inputs_needed) tl
+              end
+            | checkpoint'' ->
+              process_checkpoints ((invalid_docstrings, checkpoint'') :: inputs_needed) tl
+            end
+          | checkpoint' ->
+              process_checkpoints ((invalid_docstrings, checkpoint') :: inputs_needed) tl
+          end
+      in
+      process_checkpoints [] checkpoints
+
     | triple ->
       begin match checkpoints with
         | [] -> assert false