Replace local tuple variadics.

Summary: We are yet to support `Callable` or `Union`.

Reviewed By: grievejia

Differential Revision: D26520885

fbshipit-source-id: 29c1ed0895a0e2e399900d930a6e7fc48546c321

Author: pradeep90

source/analysis/test/typeTest.ml

@@ -1691,6 +1691,9 @@ let test_convert_all_escaped_free_variables_to_anys _ =
 let test_replace_all _ =
   let free_variable = Type.Variable (Type.Variable.Unary.create "T") in
   let annotation = Type.parametric "p" ![free_variable; Type.integer] in
+  let assert_equal actual expected =
+    assert_equal ~cmp:Type.equal ~printer:Type.show expected actual
+  in
   assert_equal
     (Type.Variable.GlobalTransforms.Unary.replace_all (fun _ -> Some Type.integer) annotation)
     (Type.parametric "p" ![Type.integer; Type.integer]);
@@ -1727,6 +1730,53 @@ let test_replace_all _ =
          CallableParameters
            (Defined [Named { name = "p"; annotation = Type.integer; default = false }]);
        ]);
+
+  (* Variadic tuples. *)
+  let variadic = Type.Variable.Variadic.Tuple.create "Ts" in
+  let variadic2 = Type.Variable.Variadic.Tuple.create "Ts2" in
+  let assert_replaced ~replace annotation expected =
+    let aliases ?replace_unbound_parameters_with_any:_ = function
+      | "Ts" -> Some (Type.VariableAlias (Type.Variable.TupleVariadic variadic))
+      | "Ts2" -> Some (Type.VariableAlias (Type.Variable.TupleVariadic variadic2))
+      | _ -> None
+    in
+    assert_equal
+      (Type.Variable.GlobalTransforms.TupleVariadic.replace_all
+         replace
+         (Type.create ~aliases (parse_single_expression ~preprocess:true annotation)))
+      (Type.create ~aliases (parse_single_expression ~preprocess:true expected))
+  in
+  let replace_with_concrete given =
+    Option.some_if
+      (Type.Variable.Variadic.Tuple.equal given variadic)
+      (Type.OrderedTypes.Concrete [Type.bool; Type.bool])
+  in
+  let replace_with_concatenation _ =
+    Some
+      (Type.OrderedTypes.Concatenation
+         (Type.OrderedTypes.Concatenation.create ~prefix:[Type.bool] ~suffix:[Type.bool] variadic))
+  in
+  assert_replaced
+    ~replace:replace_with_concrete
+    "Foo[int, pyre_extensions.Unpack[Ts], str]"
+    "Foo[int, bool, bool, str]";
+  assert_replaced
+    ~replace:replace_with_concatenation
+    "Foo[int, pyre_extensions.Unpack[Ts], str]"
+    "Foo[int, bool, pyre_extensions.Unpack[Ts], bool, str]";
+  assert_replaced
+    ~replace:replace_with_concrete
+    "Foo[Bar[int, pyre_extensions.Unpack[Ts], str], Bar[int, pyre_extensions.Unpack[Ts2], str]]"
+    "Foo[Bar[int, bool, bool, str], Bar[int, pyre_extensions.Unpack[Ts2], str]]";
+  assert_replaced ~replace:replace_with_concrete "typing.Tuple[int, str]" "typing.Tuple[int, str]";
+  assert_replaced
+    ~replace:replace_with_concrete
+    "typing.Tuple[int, pyre_extensions.Unpack[Ts], str]"
+    "typing.Tuple[int, bool, bool, str]";
+  assert_replaced
+    ~replace:replace_with_concatenation
+    "typing.Tuple[int, pyre_extensions.Unpack[Ts], str]"
+    "typing.Tuple[int, bool, pyre_extensions.Unpack[Ts], bool, str]";
   ()
 
 

source/analysis/type.ml

@@ -3757,8 +3757,32 @@ end = struct
         | _ -> []
 
 
-      (* TODO(T84854853): Implement. *)
-      let local_replace _ annotation = Some annotation
+      let local_replace replacement = function
+        | Parametric ({ parameters; _ } as parametric) ->
+            let replace parameter =
+              let replaced =
+                match parameter with
+                | Parameter.Unpacked (Variadic variadic) ->
+                    replacement variadic >>| OrderedTypes.to_parameters
+                | _ -> None
+              in
+              Option.value ~default:[parameter] replaced
+            in
+            Parametric { parametric with parameters = List.concat_map parameters ~f:replace }
+            |> Option.some
+        | Tuple (Bounded (Concatenation { prefix; middle = Variadic variadic; suffix })) ->
+            let expand_ordered_type_within_concatenation = function
+              | OrderedTypes.Concrete annotations ->
+                  OrderedTypes.Concrete (prefix @ annotations @ suffix)
+              | Concatenation { prefix = new_prefix; middle; suffix = new_suffix } ->
+                  Concatenation
+                    { prefix = prefix @ new_prefix; middle; suffix = new_suffix @ suffix }
+            in
+            replacement variadic
+            >>| expand_ordered_type_within_concatenation
+            >>| fun ordered_type -> Tuple (Bounded ordered_type)
+        | _ -> None
+
 
       let dequalify ({ name; _ } as variable) ~dequalify_map =
         { variable with name = dequalify_identifier dequalify_map name }