I think this works properly now

python · Gobot1234 · Aug 28, 2021 · Oct 2, 2021 · Nov 5, 2021 · Dec 5, 2021
commit ff779e8f30eed84b98c1d374c9d5666ac3b29b73
diff --git a/mypy/checkmember.py b/mypy/checkmember.py
@@ -146,6 +146,7 @@ def _analyze_member_access(name: str,
     if isinstance(typ, Instance):
         return analyze_instance_member_access(name, typ, mx, override_info)
     elif isinstance(typ, SelfType):
+        mx.self_type = typ.instance
         return analyze_instance_member_access(name, typ.instance, mx, override_info)
     elif isinstance(typ, AnyType):
         # The base object has dynamic type.
@@ -340,7 +341,7 @@ def analyze_none_member_access(name: str, typ: NoneType, mx: MemberContext) -> T
         return _analyze_member_access(name, mx.named_type('builtins.object'), mx)
 
 
-def analyze_member_var_access(name: str,
+def analyze_member_var_access(name: str,  # what here?
                               itype: Instance,
                               info: TypeInfo,
                               mx: MemberContext) -> Type:

diff --git a/mypy/server/deps.py b/mypy/server/deps.py
@@ -967,6 +967,7 @@ def visit_self_type(self, typ: SelfType) -> List[str]:
             triggers.append(make_trigger(typ.fullname))
         if typ.instance:
             triggers.extend(self.get_type_triggers(typ.instance))
+        return triggers
 
     def visit_typeddict_type(self, typ: TypedDictType) -> List[str]:
         triggers = []

diff --git a/mypy/type_visitor.py b/mypy/type_visitor.py
@@ -370,3 +370,82 @@ def query_types(self, types: Iterable[Type]) -> T:
                 self.seen_aliases.add(t)
             res.append(t.accept(self))
         return self.strategy(res)
+
+
+TypeT = TypeVar("TypeT", bound=Type)
+
+
+class SelfTypeVisitor(TypeVisitor[Any]):
+    def __init__(self, self_type: Instance) -> None:
+        # NOTE this visitor will mutate `func`
+        self.self_type = self_type
+
+    def visit_unbound_type(self, t: UnboundType) -> None:
+        pass
+
+    def visit_any(self, t: AnyType) -> None:
+        pass
+
+    def visit_none_type(self, t: NoneType) -> None:
+        pass
+
+    def visit_uninhabited_type(self, t: UninhabitedType) -> None:
+        pass
+
+    def visit_erased_type(self, t: ErasedType) -> None:
+        pass
+
+    def visit_deleted_type(self, t: DeletedType) -> None:
+        pass
+
+    def visit_type_var(self, t: TypeVarType) -> None:
+        pass
+
+    def visit_self_type(self, t: SelfType) -> None:
+        pass  # should this raise?
+
+    def visit_param_spec(self, t: ParamSpecType) -> None:
+        pass
+
+    def visit_instance(self, t: Instance) -> None:
+        t.args = self.replace(t.args)
+
+    def visit_callable_type(self, t: CallableType) -> None:
+        t.arg_types = self.replace(t.arg_types)
+        t.ret_type, = self.replace([t.ret_type])
+
+    def visit_overloaded(self, t: Overloaded) -> None:
+        for item in t.items:
+            item.accept(self)
+
+    def visit_tuple_type(self, t: TupleType) -> None:
+        t.items = self.replace(t.items)
+
+    def visit_typeddict_type(self, t: TypedDictType) -> None:
+        for key, value in zip(t.items, self.replace(t.items.values())):
+            t.items[key] = value
+
+    def visit_literal_type(self, t: LiteralType) -> None:
+        pass
+
+    def visit_union_type(self, t: UnionType) -> None:
+        t.items = self.replace(t.items)
+
+    def visit_partial_type(self, t: PartialType) -> None:
+        pass
+
+    def visit_type_type(self, t: TypeType) -> None:
+        t.item, = self.replace([t.item])
+
+    def visit_type_alias_type(self, t: TypeAliasType) -> None:
+        pass  # TODO this is probably invalid
+
+    def replace(self, types: Iterable[TypeT]) -> List[TypeT]:
+        ret: List[TypeT] = []
+        for type in types:
+            if isinstance(type, SelfType):
+                type = self.self_type
+            else:
+                type.accept(self)
+            ret.append(type)  # type: ignore  # not sure if this is actually unsafe
+        return ret
diff --git a/mypy/typeanal.py b/mypy/typeanal.py
@@ -375,10 +375,11 @@ def try_analyze_special_unbound_type(self, t: UnboundType, fullname: str) -> Opt
                 return AnyType(TypeOfAny.from_error)
             return RequiredType(self.anal_type(t.args[0]), required=False)
         elif fullname in ('typing_extensions.Self', 'typing.Self'):
-            try:
-                bound = self.named_type(self.api.type.fullname)  # type: ignore
-            except AttributeError:
+            from mypy.semanal import SemanticAnalyzer  # circular import
+
+            if not isinstance(self.api, SemanticAnalyzer):
                 return self.fail("Self is unbound", t)
+            bound = self.named_type(self.api.type.fullname)
             return SelfType(bound, fullname, line=t.line, column=t.column)
         elif self.anal_type_guard_arg(t, fullname) is not None:
             # In most contexts, TypeGuard[...] acts as an alias for bool (ignoring its args)

diff --git a/mypy/typeops.py b/mypy/typeops.py
@@ -9,6 +9,7 @@
 from typing_extensions import Type as TypingType
 import itertools
 import sys
+from mypy.type_visitor import SelfTypeVisitor
 
 from mypy.types import (
     TupleType, Instance, FunctionLike, Type, CallableType, TypeVarLikeType, Overloaded,
@@ -253,15 +254,7 @@ def expand(target: Type) -> Type:
                              variables=variables,
                              ret_type=ret_type,
                              bound_args=[original_type])
-    for arg_type in res.arg_types:
-        if isinstance(arg_type, UnionType):
-            for idx, item in enumerate(arg_type.items):
-                if isinstance(item, SelfType):
-                    assert original_type is not None
-                    arg_type.items[idx] = original_type
-    if isinstance(res.ret_type, SelfType):
-        assert original_type is not None
-        res.ret_type = original_type
+    res.accept(SelfTypeVisitor(original_type))
     return cast(F, res)
 
 

diff --git a/mypy/typeshed/stdlib/typing.pyi b/mypy/typeshed/stdlib/typing.pyi
@@ -86,7 +86,8 @@ if sys.version_info >= (3, 10):
 
 if sys.version_info >= (3, 11):
     # Self is also a (non-subscriptable) special form.
-    Self: object = ...
+    ...
+Self: object = ...
 
 # These type variables are used by the container types.
 _S = TypeVar("_S")

diff --git a/runner.py b/runner.py
@@ -8,6 +8,6 @@
 options = Options()
 options.show_traceback = True
 options.raise_exceptions = True
-options.verbosity = 10
+# options.verbosity = 10
 result = build([BuildSource("test.py", None, )], options, stderr=sys.stderr, stdout=sys.stdout)
 print(*result.errors, sep="\n")
diff --git a/test.py b/test.py
@@ -1,38 +1,28 @@
 from __future__ import annotations
 
-from typing import Self, TypeVar, Protocol
+from typing import Generic, TypeVar
+from typing_extensions import Self
+from abc import ABC
 
 T = TypeVar("T")
+K = TypeVar("K")
 
 
-class InstanceOf(Protocol[T]):
-    @property  # type: ignore
-    def __class__(self) -> T: ...  # type: ignore
+class ItemSet(Generic[T]):
+    def first(self) -> T: ...
 
 
-class MyMetaclass(type):
-    bar: str
+class BaseItem(ABC):
+    @property
+    def set(self) -> ItemSet[Self]: ...
 
-    def __new__(mcs: type[MyMetaclass], *args, **kwargs) -> MyMetaclass:
-        cls = super().__new__(mcs, *args, **kwargs)
-        cls.bar = "Hello"
-        return cls
 
-    def __mul__(
-        cls,
-        count: int,
-    ) -> list[InstanceOf[Self]]:
-        print(cls)
-        return [cls()] * count
+class FooItem(BaseItem):
+    name: str
 
-    def __call__(cls, *args, **kwargs) -> InstanceOf[Self]:
-        return super().__call__(*args, **kwargs)
+    def test(self) -> None: ...
 
 
-class Foo(metaclass=MyMetaclass):
-    THIS: int
-
-reveal_type(Foo)
-reveal_type(Foo())
-foos = Foo * 3
-reveal_type(foos)
+reveal_type(FooItem().set.first().name)
+reveal_type(BaseItem().set)
+reveal_type(FooItem().set.first().test())