Resolve concatenation of tuples via unpacking.

Summary:
Problem: We used to resolve `(1, *(2, 3))` as `Tuple[int, unknown]`. This was because we correctly resolved `(2, 3)` as `Tuple[int, int]` and then dropped the ball on the `Starred` expression because there is no type to express a naked unpacked tuple.

With variadic tuples, we can handle different kinds of unpacked tuples.

Reviewed By: dkgi

Differential Revision: D26821042

fbshipit-source-id: 7aad420ca4b2775e32617077a4f1d0e965efff30

Author: pradeep90

source/analysis/analysisError.ml

@@ -217,6 +217,10 @@ and unsupported_operand_kind =
 and illegal_annotation_target_kind =
   | InvalidExpression
   | Reassignment
+
+and tuple_concatenation_problem =
+  | MultipleVariadics of { variadic_expressions: Expression.t list }
+  | UnpackingNonTuple of { annotation: Type.t }
 [@@deriving compare, eq, sexp, show, hash]
 
 type invalid_decoration = {
@@ -397,6 +401,7 @@ and kind =
       variable: Type.Variable.t;
       base: polymorphism_base_class;
     }
+  | TupleConcatenationError of tuple_concatenation_problem
   (* Additional errors. *)
   (* TODO(T38384376): split this into a separate module. *)
   | DeadStore of Identifier.t
@@ -465,6 +470,7 @@ let code = function
   | IncompatibleAsyncGeneratorReturnType _ -> 57
   | UnsupportedOperand _ -> 58
   | DuplicateTypeVariables _ -> 59
+  | TupleConcatenationError _ -> 60
   | ParserFailure _ -> 404
   (* Additional errors. *)
   | UnawaitedAwaitable _ -> 1001
@@ -534,6 +540,7 @@ let name = function
   | UnsupportedOperand _ -> "Unsupported operand"
   | UnusedIgnore _ -> "Unused ignore"
   | UnusedLocalMode _ -> "Unused local mode"
+  | TupleConcatenationError _ -> "Unable to concatenate tuple"
 
 
 let weaken_literals kind =
@@ -1924,6 +1931,14 @@ let rec messages ~concise ~signature location kind =
           (if provided > 1 then "were" else "was");
       ]
   | Top -> ["Problem with analysis."]
+  | TupleConcatenationError (UnpackingNonTuple { annotation }) ->
+      [Format.asprintf "Expected to unpack a tuple, but got `%a`." pp_type annotation]
+  | TupleConcatenationError (MultipleVariadics { variadic_expressions }) ->
+      [
+        Format.asprintf
+          "Concatenation not yet support for multiple variadic tuples: `%s`."
+          (String.concat ~sep:", " (List.map ~f:show_sanitized_expression variadic_expressions));
+      ]
   | TypedDictionaryAccessWithNonLiteral acceptable_keys ->
       let explanation =
         let acceptable_keys =
@@ -2409,6 +2424,7 @@ let due_to_analysis_limitations { kind; _ } =
   | PrivateProtocolProperty _
   | ProhibitedAny _
   | TooManyArguments _
+  | TupleConcatenationError _
   | TypedDictionaryAccessWithNonLiteral _
   | TypedDictionaryKeyNotFound _
   | TypedDictionaryInitializationError _
@@ -2727,6 +2743,7 @@ let less_or_equal ~resolution left right =
   | UnsafeCast _, _
   | TooManyArguments _, _
   | Top, _
+  | TupleConcatenationError _, _
   | TypedDictionaryAccessWithNonLiteral _, _
   | TypedDictionaryInvalidOperation _, _
   | TypedDictionaryInitializationError _, _
@@ -3152,6 +3169,7 @@ let join ~resolution left right =
     | RevealedType _, _
     | UnsafeCast _, _
     | TooManyArguments _, _
+    | TupleConcatenationError _, _
     | TypedDictionaryAccessWithNonLiteral _, _
     | TypedDictionaryKeyNotFound _, _
     | TypedDictionaryInvalidOperation _, _
@@ -3713,6 +3731,7 @@ let dequalify
             override = WeakenedPostcondition (dequalify_mismatch mismatch);
           }
     | InvalidDecoration expression -> InvalidDecoration expression
+    | TupleConcatenationError expressions -> TupleConcatenationError expressions
     | TypedDictionaryAccessWithNonLiteral expression ->
         TypedDictionaryAccessWithNonLiteral expression
     | TypedDictionaryKeyNotFound { typed_dictionary_name; missing_key } ->

source/analysis/analysisError.mli

@@ -208,6 +208,10 @@ and unsupported_operand_kind =
 and illegal_annotation_target_kind =
   | InvalidExpression
   | Reassignment
+
+and tuple_concatenation_problem =
+  | MultipleVariadics of { variadic_expressions: Expression.t list }
+  | UnpackingNonTuple of { annotation: Type.t }
 [@@deriving compare, eq, sexp, show, hash]
 
 type invalid_decoration_reason =
@@ -388,6 +392,7 @@ and kind =
       variable: Type.Variable.t;
       base: polymorphism_base_class;
     }
+  | TupleConcatenationError of tuple_concatenation_problem
   (* Additional errors. *)
   | DeadStore of Identifier.t
   | Deobfuscation of Source.t

source/analysis/test/integration/tupleTest.ml

@@ -592,12 +592,84 @@ let test_length context =
   ()
 
 
+let test_unpacking context =
+  let assert_type_errors = assert_type_errors ~context in
+  assert_type_errors
+    {|
+      from typing import Tuple
+
+      def foo(x: int, xs: Tuple[str, bool]) -> None:
+
+        y = (x, *xs)
+        reveal_type(y)
+    |}
+    ["Revealed type [-1]: Revealed type for `y` is `Tuple[int, str, bool]`."];
+  assert_type_errors
+    {|
+      from typing import Tuple
+
+      def foo(x: int, xs: str) -> None:
+
+        y = (x, *xs)
+        reveal_type(y)
+    |}
+    [
+      "Unable to concatenate tuple [60]: Expected to unpack a tuple, but got `str`.";
+      "Revealed type [-1]: Revealed type for `y` is `Tuple[int, typing.Any]`.";
+    ];
+  assert_type_errors
+    {|
+      from typing import Tuple
+
+      def foo() -> None:
+
+        y = (1, *(2, 3), *(4, 5, 6), 7)
+        reveal_type(y)
+    |}
+    [
+      "Revealed type [-1]: Revealed type for `y` is `Tuple[typing_extensions.Literal[1], \
+       typing_extensions.Literal[2], typing_extensions.Literal[3], typing_extensions.Literal[4], \
+       typing_extensions.Literal[5], typing_extensions.Literal[6], typing_extensions.Literal[7]]`.";
+    ];
+  assert_type_errors
+    {|
+      from typing import Tuple
+      from pyre_extensions import TypeVarTuple
+
+      Ts = TypeVarTuple("Ts")
+
+      def foo(x: int, xs: Tuple[str, *Ts, bool]) -> Tuple[int, str, *Ts, bool]:
+        y = (x, *xs)
+        reveal_type(y)
+        return y
+    |}
+    ["Revealed type [-1]: Revealed type for `y` is `typing.Tuple[int, str, *test.Ts, bool]`."];
+  assert_type_errors
+    {|
+      from typing import Tuple
+      from pyre_extensions import TypeVarTuple
+
+      Ts = TypeVarTuple("Ts")
+
+      def foo(xs: Tuple[str, *Ts, bool]) -> None:
+        y = ( *xs, *(2, 3), *xs)
+        reveal_type(y)
+    |}
+    [
+      "Unable to concatenate tuple [60]: Concatenation not yet support for multiple variadic \
+       tuples: `*xs, *xs`.";
+      "Revealed type [-1]: Revealed type for `y` is `typing.Tuple[typing.Any, ...]`.";
+    ];
+  ()
+
+
 let () =
   "tuple"
   >::: [
          "check_tuple" >:: test_check_tuple;
          "literal_access" >:: test_tuple_literal_access;
          "custom_tuple" >:: test_custom_tuple;
          "length" >:: test_length;
+         "unpacking" >:: test_unpacking;
        ]
   |> Test.run

source/analysis/typeCheck.ml

@@ -3527,22 +3527,64 @@ module State (Context : Context) = struct
           base = None;
         }
     | Tuple elements ->
-        let resolution, errors, resolved =
+        let resolution, errors, resolved_elements =
           let forward_element (resolution, errors, resolved) expression =
-            let { Resolved.resolution; resolved = new_resolved; errors = new_errors; _ } =
-              forward_expression ~resolution ~expression
+            let resolution, new_errors, resolved_element =
+              match expression with
+              | { Node.value = Expression.Starred (Starred.Once expression); _ } ->
+                  let { Resolved.resolution; resolved = resolved_element; errors = new_errors; _ } =
+                    forward_expression ~resolution ~expression
+                  in
+                  let ordered_type, new_errors =
+                    match resolved_element with
+                    | Type.Tuple ordered_type -> ordered_type, new_errors
+                    | _ ->
+                        ( Type.OrderedTypes.Concrete [Type.Any],
+                          emit_error
+                            ~errors:new_errors
+                            ~location
+                            ~kind:
+                              (Error.TupleConcatenationError
+                                 (UnpackingNonTuple { annotation = resolved_element })) )
+                  in
+                  resolution, new_errors, ordered_type
+              | _ ->
+                  let { Resolved.resolution; resolved = resolved_element; errors = new_errors; _ } =
+                    forward_expression ~resolution ~expression
+                  in
+                  resolution, new_errors, Type.OrderedTypes.Concrete [resolved_element]
             in
-            resolution, List.append new_errors errors, new_resolved :: resolved
+            resolution, List.append new_errors errors, resolved_element :: resolved
           in
           List.fold elements ~f:forward_element ~init:(resolution, [], [])
         in
-        {
-          resolution;
-          errors;
-          resolved = Type.tuple (List.rev resolved);
-          resolved_annotation = None;
-          base = None;
-        }
+        let resolved, errors =
+          let resolved_elements = List.rev resolved_elements in
+          let concatenated_elements =
+            let concatenate sofar next =
+              sofar >>= fun left -> Type.OrderedTypes.concatenate ~left ~right:next
+            in
+            List.fold resolved_elements ~f:concatenate ~init:(Some (Type.OrderedTypes.Concrete []))
+          in
+          match concatenated_elements with
+          | Some concatenated_elements -> Type.Tuple concatenated_elements, errors
+          | None ->
+              let variadic_expressions =
+                match List.zip elements resolved_elements with
+                | Ok pairs ->
+                    List.filter_map pairs ~f:(function
+                        | expression, Type.OrderedTypes.Concatenation _ -> Some expression
+                        | _ -> None)
+                | Unequal_lengths -> elements
+              in
+              ( Type.Tuple (Type.OrderedTypes.create_unbounded_concatenation Type.Any),
+                emit_error
+                  ~errors
+                  ~location
+                  ~kind:(Error.TupleConcatenationError (MultipleVariadics { variadic_expressions }))
+              )
+        in
+        { resolution; errors; resolved; resolved_annotation = None; base = None }
     | UnaryOperator ({ UnaryOperator.operand; _ } as operator) -> (
         match UnaryOperator.override operator with
         | Some expression -> forward_expression ~resolution ~expression