tmp

Author: hauntsaninja

docs/source/error_code_list2.rst

@@ -82,25 +82,6 @@ Example:
         # Error: Redundant cast to "int"  [redundant-cast]
         return cast(int, x)
 
-Check that methods do not have redundant Self annotations [redundant-self]
---------------------------------------------------------------------------
-
-Such annotations are allowed by :pep:`673` but are redundant, so if you want
-warnings about them, enable this error code.
-
-Example:
-
-.. code-block:: python
-
-   # mypy: enable-error-code="redundant-self"
-
-   from typing import Self
-
-   class C:
-       # Error: Redundant Self annotation on method first argument
-       def copy(self: Self) -> Self:
-           return type(self)()
-
 Check that comparisons are overlapping [comparison-overlap]
 -----------------------------------------------------------
 

docs/source/generics.rst

@@ -264,8 +264,15 @@ Generic methods and generic self
 You can also define generic methods — just use a type variable in the
 method signature that is different from class type variables. In particular,
 ``self`` may also be generic, allowing a method to return the most precise
-type known at the point of access. In this way, for example, you can typecheck
-chaining of setter methods:
+type known at the point of access.
+
+.. note::
+
+   This feature is experimental. Checking code with type annotations for self
+   arguments is still not fully implemented. Mypy may disallow valid code or
+   allow unsafe code.
+
+In this way, for example, you can typecheck chaining of setter methods:
 
 .. code-block:: python
 
@@ -326,69 +333,8 @@ or a deserialization method returns the actual type of self. Therefore
 you may need to silence mypy inside these methods (but not at the call site),
 possibly by making use of the ``Any`` type.
 
-Note that this feature may accept some unsafe code for the purpose of
-*practicality*. For example:
-
-.. code-block:: python
-
-   from typing import TypeVar
-
-   T = TypeVar("T")
-   class Base:
-       def compare(self: T, other: T) -> bool:
-           return False
-
-   class Sub(Base):
-       def __init__(self, x: int) -> None:
-           self.x = x
-
-       # This is unsafe (see below), but allowed because it is
-       # a common pattern, and rarely causes issues in practice.
-       def compare(self, other: Sub) -> bool:
-           return self.x > other.x
-
-   b: Base = Sub(42)
-   b.compare(Base())  # Runtime error here: 'Base' object has no attribute 'x'
-
 For some advanced uses of self-types see :ref:`additional examples <advanced_self>`.
 
-Automatic self types using typing.Self
-**************************************
-
-The patterns described above are quite common, so there is a syntactic sugar
-for them introduced in :pep:`673`. Instead of defining a type variable and
-using an explicit ``self`` annotation, you can import a magic type ``typing.Self``
-that is automatically transformed into a type variable with an upper bound of
-current class, and you don't need an annotation for ``self`` (or ``cls`` for
-class methods). The above example can thus be rewritten as:
-
-.. code-block:: python
-
-   from typing import Self
-
-   class Friend:
-       other: Self | None = None
-
-       @classmethod
-       def make_pair(cls) -> tuple[Self, Self]:
-           a, b = cls(), cls()
-           a.other = b
-           b.other = a
-           return a, b
-
-   class SuperFriend(Friend):
-       pass
-
-   a, b = SuperFriend.make_pair()
-
-This is more compact than using explicit type variables, plus additionally
-you can use ``Self`` in attribute annotations, not just in methods.
-
-.. note::
-
-   To use this feature on versions of Python before 3.11, you will need to
-   import ``Self`` from ``typing_extensions`` version 4.0 or newer.
-
 .. _variance-of-generics:
 
 Variance of generic types
@@ -602,7 +548,7 @@ Note that class decorators are handled differently than function decorators in
 mypy: decorating a class does not erase its type, even if the decorator has
 incomplete type annotations.
 
-Suppose we have the following decorator, not type annotated yet,
+Suppose we have the following decorator, not type annotated yet, 
 that preserves the original function's signature and merely prints the decorated function's name:
 
 .. code-block:: python

docs/source/more_types.rst

@@ -804,10 +804,9 @@ classes are generic, self-type allows giving them precise signatures:
 .. code-block:: python
 
    T = TypeVar('T')
+   Q = TypeVar('Q', bound='Base[Any]')
 
    class Base(Generic[T]):
-       Q = TypeVar('Q', bound='Base[T]')
-
        def __init__(self, item: T) -> None:
            self.item = item
 

mypy/applytype.py

@@ -4,14 +4,13 @@
 
 import mypy.subtypes
 from mypy.expandtype import expand_type, expand_unpack_with_variables
-from mypy.nodes import ARG_STAR, Context
+from mypy.nodes import ARG_POS, ARG_STAR, Context
 from mypy.types import (
     AnyType,
     CallableType,
     Parameters,
     ParamSpecType,
     PartialType,
-    TupleType,
     Type,
     TypeVarId,
     TypeVarLikeType,
@@ -20,7 +19,6 @@
     UnpackType,
     get_proper_type,
 )
-from mypy.typevartuples import find_unpack_in_list, replace_starargs
 
 
 def get_target_type(
@@ -75,7 +73,6 @@ def apply_generic_arguments(
     report_incompatible_typevar_value: Callable[[CallableType, Type, str, Context], None],
     context: Context,
     skip_unsatisfied: bool = False,
-    allow_erased_callables: bool = False,
 ) -> CallableType:
     """Apply generic type arguments to a callable type.
 
@@ -116,69 +113,46 @@ def apply_generic_arguments(
     # Apply arguments to argument types.
     var_arg = callable.var_arg()
     if var_arg is not None and isinstance(var_arg.typ, UnpackType):
+        expanded = expand_unpack_with_variables(var_arg.typ, id_to_type)
+        assert isinstance(expanded, list)
+        # Handle other cases later.
+        for t in expanded:
+            assert not isinstance(t, UnpackType)
         star_index = callable.arg_kinds.index(ARG_STAR)
-        callable = callable.copy_modified(
-            arg_types=(
-                [
-                    expand_type(at, id_to_type, allow_erased_callables)
-                    for at in callable.arg_types[:star_index]
-                ]
-                + [callable.arg_types[star_index]]
-                + [
-                    expand_type(at, id_to_type, allow_erased_callables)
-                    for at in callable.arg_types[star_index + 1 :]
-                ]
-            )
+        arg_kinds = (
+            callable.arg_kinds[:star_index]
+            + [ARG_POS] * len(expanded)
+            + callable.arg_kinds[star_index + 1 :]
         )
-
-        unpacked_type = get_proper_type(var_arg.typ.type)
-        if isinstance(unpacked_type, TupleType):
-            # Assuming for now that because we convert prefixes to positional arguments,
-            # the first argument is always an unpack.
-            expanded_tuple = expand_type(unpacked_type, id_to_type)
-            if isinstance(expanded_tuple, TupleType):
-                # TODO: handle the case where the tuple has an unpack. This will
-                # hit an assert below.
-                expanded_unpack = find_unpack_in_list(expanded_tuple.items)
-                if expanded_unpack is not None:
-                    callable = callable.copy_modified(
-                        arg_types=(
-                            callable.arg_types[:star_index]
-                            + [expanded_tuple]
-                            + callable.arg_types[star_index + 1 :]
-                        )
-                    )
-                else:
-                    callable = replace_starargs(callable, expanded_tuple.items)
-            else:
-                # TODO: handle the case for if we get a variable length tuple.
-                assert False, f"mypy bug: unimplemented case, {expanded_tuple}"
-        elif isinstance(unpacked_type, TypeVarTupleType):
-            expanded_tvt = expand_unpack_with_variables(var_arg.typ, id_to_type)
-            assert isinstance(expanded_tvt, list)
-            for t in expanded_tvt:
-                assert not isinstance(t, UnpackType)
-            callable = replace_starargs(callable, expanded_tvt)
-        else:
-            assert False, "mypy bug: unhandled case applying unpack"
-    else:
-        callable = callable.copy_modified(
-            arg_types=[
-                expand_type(at, id_to_type, allow_erased_callables) for at in callable.arg_types
-            ]
+        arg_names = (
+            callable.arg_names[:star_index]
+            + [None] * len(expanded)
+            + callable.arg_names[star_index + 1 :]
         )
+        arg_types = (
+            [expand_type(at, id_to_type) for at in callable.arg_types[:star_index]]
+            + expanded
+            + [expand_type(at, id_to_type) for at in callable.arg_types[star_index + 1 :]]
+        )
+    else:
+        arg_types = [expand_type(at, id_to_type) for at in callable.arg_types]
+        arg_kinds = callable.arg_kinds
+        arg_names = callable.arg_names
 
     # Apply arguments to TypeGuard if any.
     if callable.type_guard is not None:
-        type_guard = expand_type(callable.type_guard, id_to_type, allow_erased_callables)
+        type_guard = expand_type(callable.type_guard, id_to_type)
     else:
         type_guard = None
 
     # The callable may retain some type vars if only some were applied.
     remaining_tvars = [tv for tv in tvars if tv.id not in id_to_type]
 
     return callable.copy_modified(
-        ret_type=expand_type(callable.ret_type, id_to_type, allow_erased_callables),
+        arg_types=arg_types,
+        ret_type=expand_type(callable.ret_type, id_to_type),
         variables=remaining_tvars,
         type_guard=type_guard,
+        arg_kinds=arg_kinds,
+        arg_names=arg_names,
     )

mypy/checker.py

@@ -39,7 +39,7 @@
 from mypy.erasetype import erase_type, erase_typevars, remove_instance_last_known_values
 from mypy.errorcodes import TYPE_VAR, UNUSED_AWAITABLE, UNUSED_COROUTINE, ErrorCode
 from mypy.errors import Errors, ErrorWatcher, report_internal_error
-from mypy.expandtype import expand_self_type, expand_type, expand_type_by_instance
+from mypy.expandtype import expand_type, expand_type_by_instance
 from mypy.join import join_types
 from mypy.literals import Key, literal, literal_hash
 from mypy.maptype import map_instance_to_supertype
@@ -1178,17 +1178,12 @@ def check_func_def(
                         if isinstance(arg_type, ParamSpecType):
                             pass
                         elif isinstance(arg_type, UnpackType):
-                            if isinstance(get_proper_type(arg_type.type), TupleType):
-                                # Instead of using Tuple[Unpack[Tuple[...]]], just use
-                                # Tuple[...]
-                                arg_type = arg_type.type
-                            else:
-                                arg_type = TupleType(
-                                    [arg_type],
-                                    fallback=self.named_generic_type(
-                                        "builtins.tuple", [self.named_type("builtins.object")]
-                                    ),
-                                )
+                            arg_type = TupleType(
+                                [arg_type],
+                                fallback=self.named_generic_type(
+                                    "builtins.tuple", [self.named_type("builtins.object")]
+                                ),
+                            )
                         else:
                             # builtins.tuple[T] is typing.Tuple[T, ...]
                             arg_type = self.named_generic_type("builtins.tuple", [arg_type])
@@ -2493,10 +2488,6 @@ class C(B, A[int]): ...  # this is unsafe because...
                 second_sig = self.bind_and_map_method(second, second_type, ctx, base2)
                 ok = is_subtype(first_sig, second_sig, ignore_pos_arg_names=True)
         elif first_type and second_type:
-            if isinstance(first.node, Var):
-                first_type = expand_self_type(first.node, first_type, fill_typevars(ctx))
-            if isinstance(second.node, Var):
-                second_type = expand_self_type(second.node, second_type, fill_typevars(ctx))
             ok = is_equivalent(first_type, second_type)
             if not ok:
                 second_node = base2[name].node
@@ -3077,8 +3068,6 @@ def lvalue_type_from_base(
         if base_var:
             base_node = base_var.node
             base_type = base_var.type
-            if isinstance(base_node, Var) and base_type is not None:
-                base_type = expand_self_type(base_node, base_type, fill_typevars(expr_node.info))
             if isinstance(base_node, Decorator):
                 base_node = base_node.func
                 base_type = base_node.type