cleanup

Author: randolf-scholz

mypy/argmap.py

@@ -34,8 +34,6 @@
 
 IterableType = NewType("IterableType", Instance)
 """Represents an instance of `Iterable[T]`."""
-TupleInstance = NewType("TupleInstance", Instance)
-"""Represents an instance of `builtins.tuple[T, ...]`."""
 
 
 def map_actuals_to_formals(
@@ -284,16 +282,6 @@ def is_iterable(self, typ: Type) -> bool:
 
         return is_subtype(typ, self.context.iterable_type)
 
-    def is_iterable_instance_subtype(self, typ: Type) -> TypeGuard[Instance]:
-        from mypy.subtypes import is_subtype
-
-        p_t = get_proper_type(typ)
-        return (
-            isinstance(p_t, Instance)
-            and bool(p_t.args)
-            and is_subtype(p_t, self.context.iterable_type)
-        )
-
     def is_iterable_instance_type(self, typ: Type) -> TypeGuard[IterableType]:
         """Check if the type is an Iterable[T] or a subtype of it."""
         p_t = get_proper_type(typ)
@@ -303,10 +291,6 @@ def _make_iterable_instance_type(self, arg: Type) -> IterableType:
         value = Instance(self.context.iterable_type.type, [arg])
         return cast(IterableType, value)
 
-    def _make_tuple_instance_type(self, arg: Type) -> TupleInstance:
-        value = Instance(self.context.tuple_type.type, [arg])
-        return cast(TupleInstance, value)
-
     def _solve_as_iterable(self, typ: Type) -> IterableType | AnyType:
         r"""Use the solver to cast a type as Iterable[T].
 

mypy/checkexpr.py

@@ -2288,7 +2288,6 @@ def argument_infer_context(self) -> ArgumentInferContext:
                 self.chk.named_type("typing.Mapping"),
                 self.chk.named_type("typing.Iterable"),
                 self.chk.named_type("builtins.function"),
-                self.chk.named_type("builtins.tuple"),
             )
         return self._arg_infer_context_cache
 
@@ -5252,12 +5251,10 @@ def visit_tuple_expr(self, e: TupleExpr) -> Type:
                     ctx = ctx_item.type
                 else:
                     ctx = None
-
-                arg_type_expander = ArgTypeExpander(self.argument_infer_context())
                 original_arg_type = self.accept(item.expr, ctx)
                 # convert arg type to one of TupleType, IterableType, AnyType or
+                arg_type_expander = ArgTypeExpander(self.argument_infer_context())
                 star_args_type = arg_type_expander.parse_star_args_type(original_arg_type)
-
                 if isinstance(star_args_type, TupleType):
                     if find_unpack_in_list(star_args_type.items) is not None:
                         if seen_unpack_in_items:

mypy/constraints.py

@@ -1014,13 +1014,15 @@ def visit_instance(self, template: Instance) -> list[Constraint]:
                 if isinstance(item, UnpackType):
                     unpacked = get_proper_type(item.type)
                     if isinstance(unpacked, TypeVarTupleType):
-                        # Cannot infer anything for T from [T, ...] <: *Ts
-                        continue
-                    assert (
-                        isinstance(unpacked, Instance)
-                        and unpacked.type.fullname == "builtins.tuple"
-                    )
-                    item = unpacked.args[0]
+                        # Iterable[T] :> tuple[*Ts] => T :> Union[*Ts]
+                        # Since Union[*Ts] is currently not available, use Any instead.
+                        item = AnyType(TypeOfAny.from_omitted_generics)
+                    else:
+                        assert (
+                            isinstance(unpacked, Instance)
+                            and unpacked.type.fullname == "builtins.tuple"
+                        )
+                        item = unpacked.args[0]
                 cb = infer_constraints(template.args[0], item, SUPERTYPE_OF)
                 res.extend(cb)
             return res

mypy/infer.py

@@ -29,7 +29,6 @@ class ArgumentInferContext(NamedTuple):
     mapping_type: Instance
     iterable_type: Instance
     function_type: Instance
-    tuple_type: Instance
 
 
 def infer_function_type_arguments(

test-data/unit/check-kwargs.test

@@ -498,6 +498,20 @@ f(**m)
 g(**m)  # E: Argument 1 to "g" has incompatible type "**Mapping[str, object]"; expected "int"
 [builtins fixtures/dict.pyi]
 
+[case testStarArgsTupleExpressionVersusTypeVarTuple]
+# flags: --enable-incomplete-feature=PreciseTupleTypes
+# https://github.com/python/mypy/issues/19665
+from typing import Unpack, TypeVarTuple
+
+Ts = TypeVarTuple('Ts')
+
+def as_tuple(*args: Unpack[Ts]) -> tuple[Unpack[Ts]]: return args
+
+def test(one: int, many: tuple[int, ...]) -> None:
+    reveal_type( (one, *many, one) )           # N: Revealed type is "tuple[builtins.int, Unpack[builtins.tuple[builtins.int, ...]], builtins.int]"
+    reveal_type( as_tuple(one, *many, one) )   # N: Revealed type is "tuple[builtins.int, Unpack[builtins.tuple[builtins.int, ...]], builtins.int]"
+[builtins fixtures/tuple.pyi]
+
 [case testTupleConversionWithUnionStarArgs]
 from typing import Union, List, Set, Tuple, Unpack, TypeVarTuple
 
@@ -805,47 +819,42 @@ def test_union_recursive(x: Union[list[Union[NESTED, None]], list[NESTED]]) -> N
 [builtins fixtures/primitives.pyi]
 
 
-[case testStarArgsWithPaddedTypeVarTuple]
-# https://github.com/python/mypy/issues/19659
-from typing import Union, TypeVarTuple
+[case testStarArgsWithPaddedTupleArgument]
+from typing import Union, TypeVarTuple, Unpack
 
 class A: pass
 Ts = TypeVarTuple('Ts')
 
-def test_union_typevartuple(
-    padded_tuple: tuple[A, *Ts, A],
-    padded_union: Union[tuple[A, *Ts, A], tuple[None, None, None]],
-) -> None:
+def test_padded_tuple(padded_tuple: tuple[A, Unpack[Ts], A]) -> None:
     # technically, this should be ``typ[A | None | Union[*Ts]]``
     reveal_type( (*padded_tuple,) )  # N: Revealed type is "tuple[__main__.A, Unpack[Ts`-1], __main__.A]"
     reveal_type( [*padded_tuple] )   # N: Revealed type is "builtins.list[builtins.object]"
     reveal_type( {*padded_tuple} )   # N: Revealed type is "builtins.set[builtins.object]"
+
+def test_padded_union(padded_union: Union[tuple[A, Unpack[Ts], A], tuple[None, None, None]]) -> None:
     reveal_type( (*padded_union,) )  # N: Revealed type is "builtins.tuple[builtins.object, ...]"
     reveal_type( [*padded_union] )   # N: Revealed type is "builtins.list[builtins.object]"
     reveal_type( {*padded_union} )   # N: Revealed type is "builtins.set[builtins.object]"
 [builtins fixtures/primitives.pyi]
 
-[case testStarArgsWithParamSpec]
-# https://github.com/python/mypy/issues/19663
-from typing import Union, ParamSpec, Callable
 
-P = ParamSpec('P')
+[case testStarArgsWithPaddedTupleArgumentUpcast]
+# https://github.com/python/mypy/issues/19659
+from typing import Iterable, TypeVarTuple, Unpack, Union, TypeVar
 
-def test_paramspec(
-    a: A,  # E: Name "A" is not defined
-    dummy: Callable[P, None],  # ensure P is bound
-    /,
-    *args: P.args,
-    **kwargs: P.kwargs,
-) -> None:
-    # technically, this should be ``typ[A | None | Union[*Ts]]``
-    reveal_type( args     )  # N: Revealed type is "P.args`-1"
-    reveal_type( (*args,) )  # N: Revealed type is "builtins.tuple[P.args`-1, ...]"
-    reveal_type( [*args]  )  # N: Revealed type is "builtins.list[P.args`-1]"
-    reveal_type( {*args}  )  # N: Revealed type is "builtins.set[P.args`-1]"
+class A: pass
+Ts = TypeVarTuple('Ts')
+T = TypeVar('T')
+
+def upcast(arg: Iterable[T]) -> Iterable[T]: return arg
 
-    # test padded tuple expression
-    reveal_type( (a, *args, a) )  # N: Revealed type is "builtins.tuple[__main__.A, Unpack[builtins.tuple[P.args`-1, ...]], __main__.A]"
+def test_padded_tuple(padded_tuple: tuple[A, Unpack[Ts], A]) -> None:
+    as_iterable = upcast(padded_tuple)
+    reveal_type(as_iterable)  # N: Revealed type is "typing.Iterable[Any]"
+
+def test_padded_union(padded_union: Union[tuple[A, Unpack[Ts], A], tuple[None, None, None]]) -> None:
+    as_iterable = upcast(padded_union)
+    reveal_type(as_iterable)  # N: Revealed type is "typing.Iterable[Any]"
 [builtins fixtures/primitives.pyi]
 
 [case testStarArgsWithUnion]
@@ -973,7 +982,6 @@ def test_bad_case(
            # E: Argument 1 to "g" has incompatible type "*tuple[Union[A, B, C, None], ...]"; expected "Optional[D]"
 [builtins fixtures/tuple.pyi]
 
-
 [case testListExpressionWithListSubtypeStarArgs]
 # https://github.com/python/mypy/issues/19662
 class MyList(list[int]): ...
@@ -983,8 +991,6 @@ def test(x: MyList, y: list[int]) -> None:
     reveal_type( [*y] )  # N: Revealed type is "builtins.list[builtins.int]"
 [builtins fixtures/list.pyi]
 
-
-
 [case testPassingEmptyDictWithStars]
 def f(): pass
 def g(x=1): pass

test-data/unit/lib-stub/builtins.pyi

@@ -23,13 +23,17 @@ class function:
     __name__: str
 class ellipsis: pass
 
-from typing import Generic, Iterator, Sequence, TypeVar
+from typing import Generic, Iterator, Sequence, TypeVar, Iterable
 _T = TypeVar('_T')
 class list(Generic[_T], Sequence[_T]):
     def __contains__(self, item: object) -> bool: pass
     def __getitem__(self, key: int) -> _T: pass
     def __iter__(self) -> Iterator[_T]: pass
 
-class dict: pass
+# class tuple(Generic[_T], Sequence[_T]):
+#     def __contains__(self, item: object) -> bool: pass
+#     def __getitem__(self, key: int) -> _T: pass
+#     def __iter__(self) -> Iterator[_T]: pass
 
+class dict: pass
 # Definition of None is implicit