Refactor func_params.ml to give rest params their own field

Summary:
This is the first in a series of changes around how rest parameters
are handled. Up to now, we've been handling rest parameters using the `RestT`
type. A rest parameter is just a `RestT` type in a list of parameters. It
probably should be the last element in the list, but that's not really
enforced.

However the rest parameter shouldn't really be represented by a type. You can't
pass around a rest parameter. Nothing will ever resolve to a rest parameter. A
rest parameter is always immediately obvious syntactially. It's a bit of a hack
to use a type to represent it. Instead, it should be held separately from the
other params.

This diff splits the rest param from the other params in func_params.ml

Reviewed By: mroch

Differential Revision: D4372165

fbshipit-source-id: f3f42e2ace7f820b86af2b68e76d1bf7db5fe6f5

Author: gabelevi

src/typing/func_params.ml

@@ -10,14 +10,15 @@ type binding = string * Type.t * Loc.t
 type param =
   | Simple of Type.t * binding
   | Complex of Type.t * binding list
-  | Rest of Type.t * binding
 type t = {
   list: param list;
+  rest: (Type.t * binding) option;
   defaults: Ast.Expression.t Default.t SMap.t;
 }
 
 let empty = {
   list = [];
+  rest = None;
   defaults = SMap.empty
 }
 
@@ -47,7 +48,8 @@ let mk cx type_params_map ~expr func =
         (* TODO: assert (not optional) *)
         let binding = name, t, loc in
         { list = Simple (OptionalT t, binding) :: params.list;
-          defaults = SMap.add name (Default.Expr expr) params.defaults })
+          defaults = SMap.add name (Default.Expr expr) params.defaults;
+          rest = params.rest; })
     | loc, _ ->
       let reason = mk_reason RDestructuring loc in
       let typeAnnotation = type_of_pattern pattern in
@@ -74,7 +76,11 @@ let mk cx type_params_map ~expr func =
         | None -> t (* TODO: assert (not optional) *)
       in
       let param = Complex (t, List.rev !rev_bindings) in
-      { list = param :: params.list; defaults = !defaults }
+      {
+        list = param :: params.list;
+        defaults = !defaults;
+        rest = params.rest;
+      }
   ) in
   let add_rest params pattern =
     match pattern with
@@ -87,8 +93,7 @@ let mk cx type_params_map ~expr func =
       let t =
         Anno.mk_type_annotation cx type_params_map reason typeAnnotation
       in
-      let param = Rest (Anno.mk_rest cx t, (name, t, loc)) in
-      { params with list =  param :: params.list }
+      { params with rest = Some (Anno.mk_rest cx t, (name, t, loc)) }
     | loc, _ ->
       Flow_js.add_output cx
         Flow_error.(EInternal (loc, RestArgumentNotIdentifierPattern));
@@ -126,8 +131,7 @@ let convert cx type_params_map func = Ast.Type.Function.(
     | None -> "_"
     | Some (_, name) -> name in
     let t = Anno.convert cx type_params_map typeAnnotation in
-    let param = Rest (Anno.mk_rest cx t, (name, t, loc)) in
-    { params with list = param :: params.list }
+    { params with rest = Some (Anno.mk_rest cx t, (name, t, loc)) }
   in
   let (params, rest) = func.params in
   let params = List.fold_left add_param empty params in
@@ -139,22 +143,26 @@ let convert cx type_params_map func = Ast.Type.Function.(
 )
 
 let names params =
-  params.list |> List.map (function
-    | Simple (_, (name, _, _))
-    | Rest (_, (name, _, _)) -> name
-  | Complex _ -> "_")
+  let ret = params.list |> List.map (function
+    | Simple (_, (name, _, _)) -> name
+    | Complex _ -> "_") in
+  match params.rest with
+  | None -> ret
+  | Some (_, (name, _, _)) -> ret @ [name]
 
 let tlist params =
-  params.list |> List.map (function
+  let ret = params.list |> List.map (function
     | Simple (t, _)
-    | Complex (t, _)
-    | Rest (t, _) -> t)
+    | Complex (t, _) -> t) in
+  match params.rest with
+  | None -> ret
+  | Some (t, _) -> ret @ [t]
 
 let iter f params =
   params.list |> List.iter (function
-    | Simple (_, b)
-    | Rest (_, b) -> f b
-    | Complex (_, bs) -> List.iter f bs)
+    | Simple (_, b) -> f b
+    | Complex (_, bs) -> List.iter f bs);
+  params.rest |> Option.iter ~f:(fun (_, b) -> f b)
 
 let with_default name f params =
   match SMap.get name params.defaults with
@@ -168,7 +176,9 @@ let subst cx map params =
     | Simple (t, b) ->
       Simple (Flow.subst cx map t, subst_binding cx map b)
     | Complex (t, bs) ->
-      Complex (Flow.subst cx map t, List.map (subst_binding cx map) bs)
-    | Rest (t, b) ->
-      Rest (Flow.subst cx map t, subst_binding cx map b)) in
-  { params with list }
+      Complex (Flow.subst cx map t, List.map (subst_binding cx map) bs)) in
+  let rest = match params.rest with
+  | Some (rest_t, rest_binding) ->
+      Some (Flow.subst cx map rest_t, subst_binding cx map rest_binding)
+  | None -> None in
+  { params with list; rest; }