[flow][tuples] Implement tuple type spread reversal

Summary: Changelog: [feature] You can have a tuple spread of a generic in the parameter of a function and not have to supply the relevant type argument if that spread is the only spread in that tuple, and it is the last element of that tuple.

Reviewed By: SamChou19815

Differential Revision: D55721533

fbshipit-source-id: a8fbd9e09fd40839e8e7bff0fd02b99dbe1ab801

Author: gkz

src/typing/flow_js_utils.ml

@@ -2685,7 +2685,7 @@ let mk_tuple_type cx ?trace ~id ~mk_type_destructor reason elements =
         match (el, first_spread) with
         | (UnresolvedArg (el, generic), None) ->
           ((el, generic) :: resolved, unresolved, first_spread)
-        | (UnresolvedSpreadArg t, None) -> (resolved, unresolved, Some (reason, t))
+        | (UnresolvedSpreadArg t, None) -> (resolved, unresolved, Some (reason_of_t t, t))
         | (_, Some _) -> (resolved, el :: unresolved, first_spread)
     )
   in

src/typing/implicit_instantiation.ml

@@ -278,7 +278,27 @@ module Make (Observer : OBSERVER) (Flow : Flow_common.S) : S = struct
                |> merge_lower_bounds cx
                |> use_t_result_of_t_option
            )
-      | SpreadTupleType _ -> UpperNonT u)
+      | SpreadTupleType { reason_tuple = _; reason_spread; resolved; unresolved } ->
+        let is_spread = function
+          | ResolvedArg _ -> false
+          | ResolvedSpreadArg _
+          | ResolvedAnySpreadArg _ ->
+            true
+        in
+        (* Reverse if the spread is the last item in the tuple and there are
+           no other spreads. *)
+        (match (unresolved, Base.List.exists ~f:is_spread resolved) with
+        | ([], false) ->
+          let n = List.length resolved in
+          merge_lower_or_upper_bounds r (OpenT tout)
+          |> bind_use_t_result ~f:(fun t ->
+                 Tvar.mk_where cx reason_spread (fun t' ->
+                     Flow.flow cx (t, ArrRestT (unknown_use, reason_spread, n, t'))
+                 )
+                 |> merge_lower_bounds cx
+                 |> use_t_result_of_t_option
+             )
+        | _ -> UpperNonT u))
     | UseT (_, t) -> UpperT t
     | ArrRestT (_, _, i, tout) ->
       (match get_t cx tout with

tests/tuples/spread.js

@@ -86,6 +86,29 @@ type WithTail<T> = [1, ...T];
 [1, 2, 3] as WithTail<[2, 3]>; // OK
 [1, 2, 66] as WithTail<[2, 3]>; // ERROR
 
-declare function f<T>(xs: [1, ...T]): void;
-f([1, 2, 3]); // ERROR: annotation required - reversal not yet implemented
-f<[2, 3]>([ 1, 2, 3]); // OK
+// Tuple-like array spread
+{
+  const x = [1, 2];
+  type TupleArrSpread = [0, ...typeof x]; // OK
+  [0, 1, 2] as TupleArrSpread; // OK
+}
+
+declare function tail<T>(xs: [1, ...T]): T;
+tail<[2, 3]>([ 1, 2, 3]); // OK
+{
+  const x = tail([1]); // OK
+  x as []; // OK
+}
+{
+  const x = tail([1, 2, 3]);
+  x as [2, 3]; // OK
+  x as [1, 2, 3]; // ERROR
+}
+tail([666, 2, 3]); // ERROR
+tail([]); // ERROR
+
+declare function noReversal1<T>(xs: [1, ...T, 2]): T;
+noReversal1([1, 9, 2]); // ERROR
+
+declare function noReversal2<T>(xs: [...T, ...any]): T;
+noReversal2([1, 2, 3]); // ERROR

tests/tuples/tuples.exp

@@ -1211,22 +1211,94 @@ References:
                                   ^ [2]
 
 
-Error --------------------------------------------------------------------------------------------------- spread.js:90:1
+Error --------------------------------------------------------------------------------------------------- spread.js:92:8
 
-Cannot call `f` because `T` [1] is underconstrained by call of `f` [2]. Either add explicit type arguments or cast the
-expression to your expected type. [underconstrained-implicit-instantiation]
+Cannot declare `TupleArrSpread` [1] because the name is already bound. [name-already-bound]
 
-   spread.js:90:1
-   90| f([1, 2, 3]); // ERROR: annotation required - reversal not yet implemented
-       ^
+   spread.js:92:8
+   92|   type TupleArrSpread = [0, ...typeof x]; // OK
+              ^^^^^^^^^^^^^^
 
 References:
-   spread.js:89:20
-   89| declare function f<T>(xs: [1, ...T]): void;
-                          ^ [1]
-   spread.js:90:1
-   90| f([1, 2, 3]); // ERROR: annotation required - reversal not yet implemented
-       ^^^^^^^^^^^^ [2]
+   spread.js:80:8
+   80|   type TupleArrSpread = [0, ...typeof x]; // OK
+              ^^^^^^^^^^^^^^ [1]
+
+
+Error -------------------------------------------------------------------------------------------------- spread.js:105:3
+
+Cannot cast `x` to tuple type because `T` [1] has 2 elements but tuple type [2] has 3 elements. [invalid-tuple-arity]
+
+   spread.js:105:3
+   105|   x as [1, 2, 3]; // ERROR
+          ^
+
+References:
+   spread.js:96:37
+    96| declare function tail<T>(xs: [1, ...T]): T;
+                                            ^ [1]
+   spread.js:105:8
+   105|   x as [1, 2, 3]; // ERROR
+               ^^^^^^^^^ [2]
+
+
+Error -------------------------------------------------------------------------------------------------- spread.js:107:7
+
+Cannot call `tail` with array literal bound to `xs` because number [1] is incompatible with number literal `1` [2] in
+index 0. [incompatible-call]
+
+   spread.js:107:7
+   107| tail([666, 2, 3]); // ERROR
+              ^^^ [1]
+
+References:
+   spread.js:96:31
+    96| declare function tail<T>(xs: [1, ...T]): T;
+                                      ^ [2]
+
+
+Error -------------------------------------------------------------------------------------------------- spread.js:108:6
+
+Cannot determine type of empty array literal. Please provide an annotation. [missing-empty-array-annot]
+
+   108| tail([]); // ERROR
+             ^^
+
+
+Error -------------------------------------------------------------------------------------------------- spread.js:111:1
+
+Cannot call `noReversal1` because `T` [1] is underconstrained by call of `noReversal1` [2]. Either add explicit type
+arguments or cast the expression to your expected type. [underconstrained-implicit-instantiation]
+
+   spread.js:111:1
+   111| noReversal1([1, 9, 2]); // ERROR
+        ^^^^^^^^^^^
+
+References:
+   spread.js:110:30
+   110| declare function noReversal1<T>(xs: [1, ...T, 2]): T;
+                                     ^ [1]
+   spread.js:111:1
+   111| noReversal1([1, 9, 2]); // ERROR
+        ^^^^^^^^^^^^^^^^^^^^^^ [2]
+
+
+Error -------------------------------------------------------------------------------------------------- spread.js:114:1
+
+Cannot call `noReversal2` because `T` [1] is underconstrained by call of `noReversal2` [2]. Either add explicit type
+arguments or cast the expression to your expected type. [underconstrained-implicit-instantiation]
+
+   spread.js:114:1
+   114| noReversal2([1, 2, 3]); // ERROR
+        ^^^^^^^^^^^
+
+References:
+   spread.js:113:30
+   113| declare function noReversal2<T>(xs: [...T, ...any]): T;
+                                     ^ [1]
+   spread.js:114:1
+   114| noReversal2([1, 2, 3]); // ERROR
+        ^^^^^^^^^^^^^^^^^^^^^^ [2]
 
 
 Error --------------------------------------------------------------------------------------------------- too-few.js:5:5
@@ -1998,4 +2070,4 @@ References:
 
 
 
-Found 125 errors
+Found 130 errors