[Easy] Rename ResolveRestT to `ResolveSpreadT

Summary:
`ResolveRestT` is used to resolve a list of spread elements or
arguments. It is misnamed. This diff renames stuff to make it closer to what it
does.

Reviewed By: samwgoldman

Differential Revision: D4468923

fbshipit-source-id: 6b687d7ed8da684b6b985bafc704324cf21a5695

Author: gabelevi

src/typing/debug_js.ml

@@ -691,7 +691,7 @@ and _json_of_use_t_impl json_cx t = Hh_json.(
         ("refined_t", _json_of_t_impl json_cx t)
       ]
     ]
-  | ResolveRestT (_, {
+  | ResolveSpreadT (_, {
     rrt_id;
     rrt_resolved;
     rrt_unresolved;
@@ -701,11 +701,11 @@ and _json_of_use_t_impl json_cx t = Hh_json.(
       "id", JSON_Number (string_of_int rrt_id);
       "resolved", JSON_Array (List.map (fun param ->
         let kind, t = match param with
-        | ResolvedParam t -> "ResolvedParam", t
-        | ResolvedRestParam (at) ->
-          "ResolvedRestParam", ArrT (locationless_reason (RCustom "array"), at)
-        | ResolvedAnyRestParam ->
-          "ResolvedAnyRestParam", AnyT (locationless_reason (RAny))
+        | ResolvedArg t -> "ResolvedArg", t
+        | ResolvedSpreadArg (at) ->
+          "ResolvedSpreadArg", ArrT (locationless_reason (RCustom "array"), at)
+        | ResolvedAnySpreadArg ->
+          "ResolvedAnySpreadArg", AnyT (locationless_reason (RAny))
         in
         JSON_Object [
           "kind", JSON_String kind;
@@ -714,8 +714,8 @@ and _json_of_use_t_impl json_cx t = Hh_json.(
       ) rrt_resolved);
       "unresolved", JSON_Array (List.map (fun param ->
         let kind, t = match param with
-        | UnresolvedParam t -> "UnresolvedParam", t
-        | UnresolvedRestParam t -> "UnresolvedRestParam", t in
+        | UnresolvedArg t -> "UnresolvedArg", t
+        | UnresolvedSpreadArg t -> "UnresolvedSpreadArg", t in
         JSON_Object [
           "kind", JSON_String kind;
           "type", _json_of_t_impl json_cx t;
@@ -1570,7 +1570,7 @@ and dump_use_t_ (depth, tvars) cx t =
   | RefineT _ -> p t
   | ReposLowerT (_, arg) -> p ~extra:(use_kid arg) t
   | ReposUseT (_, _, arg) -> p ~extra:(kid arg) t
-  | ResolveRestT (_, {rrt_resolve_to; rrt_tout; _;}) ->
+  | ResolveSpreadT (_, {rrt_resolve_to; rrt_tout; _;}) ->
       p ~extra:(spf "%s, %s" (match rrt_resolve_to with
       | ResolveSpreadsToTuple -> "ResolveSpreadsToTuple"
       | ResolveSpreadsToArrayLiteral -> "ResolveSpreadsToArrayLiteral"

src/typing/flow_error.ml

@@ -232,7 +232,7 @@ let rec error_of_msg ~trace_reasons ~op ~source_file =
       | ObjectMapi -> "Expected object instead of")
     | ReactCreateElementT _ -> "Expected React component instead of"
     | CallLatentPredT _ -> "Expected predicated function instead of"
-    | ResolveRestT _ ->
+    | ResolveSpreadT _ ->
         "Expected rest element to be an array or tuple instead of"
     | TypeAppVarianceCheckT _ -> "Expected polymorphic type instead of"
     (* unreachable or unclassified use-types. until we have a mechanical way

src/typing/flow_js.ml

@@ -1497,25 +1497,25 @@ let rec __flow cx ((l: Type.t), (u: Type.use_t)) trace =
       prep_try_intersection cx trace reason unresolved (resolved @ [t]) u r rep
 
     (*************************)
-    (* Resolving rest params *)
+    (* Resolving spread args *)
     (*************************)
 
     | AnyT _,
-      ResolveRestT (reason_op, {
+      ResolveSpreadT (reason_op, {
         rrt_id = _;
         rrt_resolved;
         rrt_unresolved;
         rrt_resolve_to;
         rrt_tout;
       }) ->
 
-      let rrt_resolved = ResolvedAnyRestParam::rrt_resolved in
+      let rrt_resolved = ResolvedAnySpreadArg::rrt_resolved in
       resolve_spread_list_rec
         cx ~trace ~reason_op
         (rrt_resolved, rrt_unresolved) rrt_resolve_to rrt_tout
 
     | ArrT (_, arrtype),
-      ResolveRestT (reason_op, {
+      ResolveSpreadT (reason_op, {
         rrt_id;
         rrt_resolved;
         rrt_unresolved;
@@ -1539,22 +1539,22 @@ let rec __flow cx ((l: Type.t), (u: Type.use_t)) trace =
        * for (let x = 1; x < 3; x++) { foo = [...foo, x]; }
        *
        * where every time you spread foo, you flow another type into foo. So
-       * each time `l ~> ResolveRestT` is processed, it might produce a new
-       * `l ~> ResolveRestT` with a new `l`.
+       * each time `l ~> ResolveSpreadT` is processed, it might produce a new
+       * `l ~> ResolveSpreadT` with a new `l`.
        *
        * Here is how we avoid this:
        *
-       * 1. We use ConstFoldExpansion to detect when we see a ResolveRestT
+       * 1. We use ConstFoldExpansion to detect when we see a ResolveSpreadT
        *    upper bound multiple times
-       * 2. When a ResolveRestT upper bound multiple times, we change it into
-       *    a ResolveRestT upper bound that resolves to a more general type.
+       * 2. When a ResolveSpreadT upper bound multiple times, we change it into
+       *    a ResolveSpreadT upper bound that resolves to a more general type.
        *    This should prevent more distinct lower bounds from flowing in
        * 3. rec_flow caches (l,u) pairs.
        *)
       if ConstFoldExpansion.push_unless_loop id (reason_of_t elemt)
       then begin
         (* We haven't seen this ArrT yet, so no need to worry about loops *)
-        let rrt_resolved = ResolvedRestParam(arrtype)::rrt_resolved in
+        let rrt_resolved = ResolvedSpreadArg(arrtype)::rrt_resolved in
         resolve_spread_list_rec
           cx ~trace ~reason_op (rrt_resolved, rrt_unresolved) rrt_resolve_to rrt_tout;
         ConstFoldExpansion.pop id
@@ -1568,7 +1568,7 @@ let rec __flow cx ((l: Type.t), (u: Type.use_t)) trace =
              * an array. The rrt_id is the same so that we avoid creating many
              * distinct upper bounds, which would sabotage the (l,u) pair
              * caching that rec_flow does. *)
-            rec_flow cx trace (l, ResolveRestT (reason_op, {
+            rec_flow cx trace (l, ResolveSpreadT (reason_op, {
               rrt_id;
               rrt_resolved;
               rrt_unresolved;
@@ -8794,16 +8794,16 @@ and resolve_spread_list_rec
   | resolved, [] ->
       finish_resolve_spread_list
         cx ?trace ~reason_op (List.rev resolved) resolve_to tout
-  | resolved, UnresolvedParam(next)::unresolved ->
+  | resolved, UnresolvedArg(next)::unresolved ->
       resolve_spread_list_rec
         cx
         ?trace
         ~reason_op
-        (ResolvedParam(next)::resolved, unresolved)
+        (ResolvedArg(next)::resolved, unresolved)
         resolve_to
         tout
-  | resolved, UnresolvedRestParam(next)::unresolved ->
-      flow_opt cx ?trace (next, ResolveRestT (reason_op, {
+  | resolved, UnresolvedSpreadArg(next)::unresolved ->
+      flow_opt cx ?trace (next, ResolveSpreadT (reason_op, {
         rrt_id = mk_id();
         rrt_resolved = resolved;
         rrt_unresolved = unresolved;
@@ -8815,37 +8815,37 @@ and resolve_spread_list_rec
  * to resolve to. *)
 and finish_resolve_spread_list =
   (* Turn tuple rest params into single params *)
-  let flatten_rest_params list =
+  let flatten_spread_args list =
     list
     |> List.fold_left (fun acc param -> match param with
-      | ResolvedRestParam (arrtype) ->
+      | ResolvedSpreadArg (arrtype) ->
           begin match arrtype with
           | ArrayAT (_, Some tuple_types)
           | TupleAT (_, tuple_types) ->
               List.fold_left
-                (fun acc elem -> ResolvedParam(elem)::acc)
+                (fun acc elem -> ResolvedArg(elem)::acc)
                 acc
                 tuple_types
           | ArrayAT (_, None)
           | ROArrayAT (_) -> param::acc
           end
-      | ResolvedParam _ -> param::acc
-      | ResolvedAnyRestParam -> failwith "Should not be hit"
+      | ResolvedArg _ -> param::acc
+      | ResolvedAnySpreadArg -> failwith "Should not be hit"
       ) []
     |> List.rev
 
   in
 
-  let rest_resolved_to_any = List.exists (function
-    | ResolvedAnyRestParam -> true
-    | ResolvedParam _ | ResolvedRestParam _ -> false)
+  let spread_resolved_to_any = List.exists (function
+    | ResolvedAnySpreadArg -> true
+    | ResolvedArg _ | ResolvedSpreadArg _ -> false)
 
   in
 
   let finish_array cx ?trace ~reason_op ~resolve_to resolved tout =
     (* Did `any` flow to one of the rest parameters? If so, we need to resolve
      * to a type that is both a subtype and supertype of the desired type. *)
-    let result = if rest_resolved_to_any resolved
+    let result = if spread_resolved_to_any resolved
     then match resolve_to with
       (* Array<any> is a good enough any type for arrays *)
       | `Array -> ArrT (reason_op, ArrayAT (AnyT.why reason_op, None))
@@ -8858,7 +8858,7 @@ and finish_resolve_spread_list =
       | `Tuple -> AnyT.why reason_op
     else begin
       (* Spreads that resolve to tuples are flattened *)
-      let elems = flatten_rest_params resolved in
+      let elems = flatten_spread_args resolved in
 
       let tuple_types = match resolve_to with
       | `Literal
@@ -8868,9 +8868,9 @@ and finish_resolve_spread_list =
           |> List.fold_left (fun acc elem ->
               match (acc, elem) with
               | None, _ -> None
-              | _, ResolvedRestParam _ -> None
-              | Some tuple_types, ResolvedParam t -> Some (t::tuple_types)
-              | _, ResolvedAnyRestParam -> failwith "Should not be hit"
+              | _, ResolvedSpreadArg _ -> None
+              | Some tuple_types, ResolvedArg t -> Some (t::tuple_types)
+              | _, ResolvedAnySpreadArg -> failwith "Should not be hit"
             ) (Some [])
           |> Option.map ~f:List.rev
       | `Array -> None in
@@ -8879,12 +8879,12 @@ and finish_resolve_spread_list =
        * every element in the array *)
       let tset = List.fold_left (fun tset elem ->
         let elemt = match elem with
-        | ResolvedRestParam (
+        | ResolvedSpreadArg (
             (ArrayAT (elemt,_) | TupleAT (elemt,_) | ROArrayAT elemt )
           ) ->
             elemt
-        | ResolvedParam elemt -> elemt
-        | ResolvedAnyRestParam -> failwith "Should not be hit"
+        | ResolvedArg elemt -> elemt
+        | ResolvedAnySpreadArg -> failwith "Should not be hit"
         in
 
         TypeExSet.add elemt tset

src/typing/flow_js.mli

@@ -42,7 +42,7 @@ val mk_tvar_derivable_where: Context.t -> reason -> (Type.t -> unit) -> Type.t
 
 val get_builtin_typeapp: Context.t -> ?trace:Trace.t -> reason -> string -> Type.t list -> Type.t
 
-val resolve_spread_list: Context.t -> reason_op:Reason.t -> Type.unresolved_param list -> Type.rest_resolve -> Type.t -> unit
+val resolve_spread_list: Context.t -> reason_op:Reason.t -> Type.unresolved_param list -> Type.spread_resolve -> Type.t -> unit
 
 (* polymorphism *)
 

src/typing/gc_js.ml

@@ -289,24 +289,24 @@ and gc_use cx state = function
       gc cx state t2
     ) targs
 
-  | ResolveRestT (_, {
+  | ResolveSpreadT (_, {
     rrt_id=_;
     rrt_resolved;
     rrt_unresolved;
     rrt_resolve_to;
     rrt_tout;
   }) ->
       List.iter (function
-        | ResolvedParam t -> gc cx state t
-        | ResolvedRestParam (arraytype) ->
+        | ResolvedArg t -> gc cx state t
+        | ResolvedSpreadArg (arraytype) ->
             gc_arraytype cx state arraytype
-        | ResolvedAnyRestParam -> ()
+        | ResolvedAnySpreadArg -> ()
       ) rrt_resolved;
       List.iter (function
-        | UnresolvedParam t
-        | UnresolvedRestParam t -> gc cx state t
+        | UnresolvedArg t
+        | UnresolvedSpreadArg t -> gc cx state t
       ) rrt_unresolved;
-      gc_rest_resolve cx state rrt_resolve_to;
+      gc_spread_resolve cx state rrt_resolve_to;
       gc cx state rrt_tout
 
 
@@ -429,7 +429,7 @@ and gc_elem_action cx state = function
   | ReadElem t | WriteElem t -> gc cx state t
   | CallElem (_, fct) -> gc_funcalltype cx state fct
 
-and gc_rest_resolve _cx _state = function
+and gc_spread_resolve _cx _state = function
 | ResolveSpreadsToArray
 | ResolveSpreadsToArrayLiteral
 | ResolveSpreadsToTuple -> ()

src/typing/graph.ml

@@ -332,24 +332,24 @@ and parts_of_use_t cx = function
 | RefineT (_, _, t) -> ["t", Def t]
 | ReposLowerT (_, u) -> ["upper", Use u]
 | ReposUseT (_, _, l) ->  ["lower", Def l]
-| ResolveRestT (_, {
+| ResolveSpreadT (_, {
     rrt_id = _;
     rrt_resolved;
     rrt_unresolved;
     rrt_resolve_to;
     rrt_tout;
   }) ->
     let parts_of_resolved = List.mapi (fun i -> function
-      | ResolvedParam t -> [spf "resolved param #%d" i, Def t]
-      | ResolvedRestParam (arrtype) -> parts_of_arrtype arrtype
-      | ResolvedAnyRestParam -> []
+      | ResolvedArg t -> [spf "resolved param #%d" i, Def t]
+      | ResolvedSpreadArg (arrtype) -> parts_of_arrtype arrtype
+      | ResolvedAnySpreadArg -> []
     ) rrt_resolved
     |> List.flatten in
     let parts_of_unresolved = List.mapi (fun i -> function
-      | UnresolvedParam t -> spf "unresolved param #%d" i, Def t
-      | UnresolvedRestParam t -> spf "unresolved rest param #%d" i, Def t
+      | UnresolvedArg t -> spf "unresolved param #%d" i, Def t
+      | UnresolvedSpreadArg t -> spf "unresolved rest param #%d" i, Def t
     ) rrt_unresolved in
-    let parts_of_resolve_to = parts_of_rest_resolve rrt_resolve_to in
+    let parts_of_resolve_to = parts_of_spread_resolve rrt_resolve_to in
     parts_of_resolved @ parts_of_unresolved @ parts_of_resolve_to @ [
       "out", Def rrt_tout
     ]
@@ -373,7 +373,7 @@ and parts_of_arrtype = function
 | TupleAT (elemt, tuple_types) ->
   ("elem", Def elemt)::(list_parts tuple_types)
 
-and parts_of_rest_resolve = function
+and parts_of_spread_resolve = function
 | ResolveSpreadsToTuple
 | ResolveSpreadsToArrayLiteral
 | ResolveSpreadsToArray -> []

src/typing/statement.ml

@@ -2389,10 +2389,10 @@ and expression_or_spread cx = Ast.Expression.(function
 
 and expression_or_spread_list cx undef_loc = Ast.Expression.(
   List.map (function
-  | Some (Expression e) -> UnresolvedParam (expression cx e)
-  | None -> UnresolvedParam (EmptyT.at undef_loc)
+  | Some (Expression e) -> UnresolvedArg (expression cx e)
+  | None -> UnresolvedArg (EmptyT.at undef_loc)
   | Some (Spread (_, { SpreadElement.argument })) ->
-      UnresolvedRestParam (expression cx argument)
+      UnresolvedSpreadArg (expression cx argument)
   )
 )