Fix Unpack Alias not being subscriptable, causing nested Unpacks to fail

Author: Daraan

src/test_typing_extensions.py

@@ -5779,6 +5779,49 @@ class D(Protocol[T1, T2, Unpack[Ts]]): pass
                     with self.assertRaises(TypeError):
                         klass[int]
 
+    def test_substitution(self):
+        Ts = TypeVarTuple("Ts")
+        unpacked_str = Unpack[Ts][str]
+        with self.subTest("Check full unpack"):
+            self.assertIs(unpacked_str, str)
+
+    @skipUnless(TYPING_3_11_0, "Needs Issue #103 first")
+    def test_nested_unpack(self):
+        T = TypeVar('T')
+        Ts = TypeVarTuple("Ts")
+        Variadic = TypeAliasType("Variadic", Tuple[int, Unpack[Ts]], type_params=(Ts,))
+        Variadic[int, Tuple[str, int]]
+
+        TupleAliasTs = Variadic[Tuple[Unpack[Ts], int]]
+
+        # if this fails all below are likely to fail too
+        # Tuple[int, Tuple[str, int]]
+        TupleAliasTs[str]
+
+        TupleAliasTsT = Variadic[Tuple[Unpack[Ts], T]]
+        with self.subTest("Single parameter for tuple alias"):
+            # Tuple[int, Tuple[str, object]]
+            nested_tuple_A = TupleAliasTsT[str, object]
+            nested_tuple_A_unpack = TupleAliasTsT[Unpack[Tuple[str]], object]
+            self.assertEqual(nested_tuple_A, nested_tuple_A_unpack)
+
+        with self.subTest("Test invalid args", args=([str, int], object)):
+            # TypeError on some versions as types should be passed
+            invalid_nested_tuple = TupleAliasTsT[[str, int], object]  # invalid form
+        with self.subTest("With Callable Ts"):
+            # Tuple[int, (str, int) -> object]
+            CallableAliasTsT = Variadic[Callable[[Unpack[Ts]], T]]
+            CallableAliasTsT[[str, int], object]  # valid nested tuple
+
+        # Equivalent Forms
+        with self.subTest("Equivalence of variadic arguments"):
+            nested_tuple_bare = TupleAliasTsT[str, int, object]
+            nested_tuple_B_1xUnpack = TupleAliasTsT[Unpack[Tuple[str, int]], object]
+            nested_tuple_B_2xUnpack = TupleAliasTsT[Unpack[Tuple[str]], Unpack[Tuple[int]], object]
+            self.assertEqual(nested_tuple_B_1xUnpack, nested_tuple_bare)
+            self.assertEqual(nested_tuple_B_1xUnpack, nested_tuple_B_2xUnpack)
+            self.assertNotEqual(invalid_nested_tuple, nested_tuple_B_1xUnpack)
+
 
 class TypeVarTupleTests(BaseTestCase):
 

src/typing_extensions.py

@@ -2424,6 +2424,17 @@ def __typing_unpacked_tuple_args__(self):
                 return arg.__args__
             return None
 
+        @property
+        def __typing_is_unpacked_typevartuple__(self):
+            assert self.__origin__ is Unpack
+            assert len(self.__args__) == 1
+            return isinstance(self.__args__[0], TypeVarTuple)
+
+        def __getitem__(self, args):
+            if self.__typing_is_unpacked_typevartuple__:
+                return args
+            return super().__getitem__(args)
+
     @_UnpackSpecialForm
     def Unpack(self, parameters):
         item = typing._type_check(parameters, f'{self._name} accepts only a single type.')
@@ -2436,6 +2447,17 @@ def _is_unpack(obj):
     class _UnpackAlias(typing._GenericAlias, _root=True):
         __class__ = typing.TypeVar
 
+        @property
+        def __typing_is_unpacked_typevartuple__(self):
+            assert self.__origin__ is Unpack
+            assert len(self.__args__) == 1
+            return isinstance(self.__args__[0], TypeVarTuple)
+
+        def __getitem__(self, args):
+            if self.__typing_is_unpacked_typevartuple__:
+                return args
+            return super().__getitem__(args)
+
     class _UnpackForm(_ExtensionsSpecialForm, _root=True):
         def __getitem__(self, parameters):
             item = typing._type_check(parameters,