Fix most of the CI issues and respond to comments

python · Gobot1234 · Aug 28, 2021 · Oct 2, 2021 · Nov 5, 2021 · Dec 5, 2021
commit 0e6d128bbd00952b4ea3e5434c1ec1a91108c943
diff --git a/mypy/semanal.py b/mypy/semanal.py
@@ -673,6 +673,7 @@ def prepare_method_signature(self, func: FuncDef, info: TypeInfo) -> None:
                 self_type = leading_type.item if isinstance(leading_type, TypeType) else leading_type
                 fullname = None
                 # bind any SelfTypes
+                assert isinstance(func.type, CallableType)
                 for idx, arg in enumerate(func.type.arg_types):
                     if self.is_self_type(arg):
                         if func.is_static:
@@ -692,7 +693,9 @@ def prepare_method_signature(self, func: FuncDef, info: TypeInfo) -> None:
                 if self.is_self_type(func.type.ret_type):
                     if fullname is None:
                         self.lookup_qualified(func.type.ret_type.name, func.type.ret_type)
-                        fullname = self.lookup_qualified(func.type.ret_type.name, func.type.ret_type).node.fullname
+                        table_node = self.lookup_qualified(func.type.ret_type.name, func.type.ret_type)
+                        assert isinstance(table_node, SymbolTableNode) and table_node.node
+                        fullname = cast(str, table_node.node.fullname)
                     if func.is_static:
                         self.fail(
                             "Self types in the annotations of staticmethods are not supported, "
@@ -5159,7 +5162,6 @@ def visit_placeholder_type(self, t: PlaceholderType) -> bool:
 def has_placeholder(typ: Type) -> bool:
     """Check if a type contains any placeholder types (recursively)."""
     return typ.accept(HasPlaceholders())
-    return t
 
 
 def replace_implicit_first_type(sig: FunctionLike, new: Type) -> FunctionLike:

diff --git a/mypy/server/astdiff.py b/mypy/server/astdiff.py
@@ -57,7 +57,7 @@ class level -- these are handled at attribute level (say, 'mod.Cls.method'
     FuncBase, OverloadedFuncDef, FuncItem, MypyFile, UNBOUND_IMPORTED
 )
 from mypy.types import (
-    Type, TypeGuardType, TypeVisitor, UnboundType, AnyType, NoneType, UninhabitedType,
+    SelfType, Type, TypeGuardType, TypeVisitor, UnboundType, AnyType, NoneType, UninhabitedType,
     ErasedType, DeletedType, Instance, TypeVarType, CallableType, TupleType, TypedDictType,
     UnionType, Overloaded, PartialType, TypeType, LiteralType, TypeAliasType
 )
@@ -306,6 +306,12 @@ def visit_type_var(self, typ: TypeVarType) -> SnapshotItem:
                 snapshot_type(typ.upper_bound),
                 typ.variance)
 
+    def visit_self_type(self, typ: SelfType) -> SnapshotItem:
+        return ('SelfType',
+                typ.fullname,
+                snapshot_type(typ.instance)
+                )
+
     def visit_callable_type(self, typ: CallableType) -> SnapshotItem:
         # FIX generics
         return ('CallableType',

diff --git a/mypy/server/astmerge.py b/mypy/server/astmerge.py
@@ -56,7 +56,7 @@
 )
 from mypy.traverser import TraverserVisitor
 from mypy.types import (
-    Type, SyntheticTypeVisitor, Instance, AnyType, NoneType, CallableType, ErasedType, DeletedType,
+    SelfType, Type, SyntheticTypeVisitor, Instance, AnyType, NoneType, CallableType, ErasedType, DeletedType,
     TupleType, TypeType, TypeVarType, TypedDictType, UnboundType, UninhabitedType, UnionType,
     Overloaded, TypeVarType, TypeList, CallableArgument, EllipsisType, StarType, LiteralType,
     RawExpressionType, PartialType, PlaceholderType, TypeAliasType, TypeGuardType
@@ -410,6 +410,9 @@ def visit_type_var(self, typ: TypeVarType) -> None:
         for value in typ.values:
             value.accept(self)
 
+    def visit_self_type(self, typ: SelfType) -> None:
+        typ.instance.accept(self)
+
     def visit_typeddict_type(self, typ: TypedDictType) -> None:
         for value_type in typ.items.values():
             value_type.accept(self)

diff --git a/mypy/server/deps.py b/mypy/server/deps.py
@@ -96,7 +96,7 @@ class 'mod.Cls'. This can also refer to an attribute inherited from a
 )
 from mypy.traverser import TraverserVisitor
 from mypy.types import (
-    Type, Instance, AnyType, NoneType, TypeVisitor, CallableType, DeletedType, PartialType,
+    SelfType, Type, Instance, AnyType, NoneType, TypeVisitor, CallableType, DeletedType, PartialType,
     TupleType, TypeType, TypeVarType, TypedDictType, UnboundType, UninhabitedType, UnionType,
     FunctionLike, Overloaded, TypeOfAny, LiteralType, ErasedType, get_proper_type, ProperType,
     TypeAliasType, TypeGuardType
@@ -957,6 +957,14 @@ def visit_type_var(self, typ: TypeVarType) -> List[str]:
             triggers.extend(self.get_type_triggers(val))
         return triggers
 
+    def visit_self_type(self, typ: SelfType) -> List[str]:
+        triggers = []
+        if typ.fullname:
+            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 = []
         for item in typ.items.values():

diff --git a/mypy/type_visitor.py b/mypy/type_visitor.py
@@ -29,7 +29,7 @@
 
 @trait
 @mypyc_attr(allow_interpreted_subclasses=True)
-class TypeVisitor(Generic[T], metaclass=ABCMeta):
+class TypeVisitor(Generic[T]):
     """Visitor class for types (Type subclasses).
 
     The parameter T is the return type of the visit methods.

diff --git a/mypy/typeanal.py b/mypy/typeanal.py
@@ -355,7 +355,7 @@ def try_analyze_special_unbound_type(self, t: UnboundType, fullname: str) -> Opt
             return self.anal_type(t.args[0])
         elif fullname in ('typing_extensions.Self', 'typing.Self'):
             try:
-                bound = self.named_type(self.api.type.fullname)
+                bound = self.named_type(self.api.type.fullname)  # type: ignore
             except AttributeError:
                 return self.fail("Self is unbound", t)
             return SelfType(bound, fullname, line=t.line, column=t.column)

diff --git a/mypy/typeops.py b/mypy/typeops.py
@@ -276,8 +276,10 @@ def expand(target: Type) -> Type:
         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
     return cast(F, res)
 

diff --git a/mypy/types.py b/mypy/types.py
@@ -428,11 +428,14 @@ def deserialize(cls, data: JsonDict) -> 'TypeVarType':
 
 
 class SelfType(ProperType):
+    name: ClassVar[str] = 'Self'
+
+    __slots__ = ('fullname', 'instance')
+
     def __init__(self, instance: 'Instance', fullname: str, line: int = -1, column: int = -1) -> None:
         super().__init__(line, column)
-        self.name = "Self"
         self.fullname = fullname
-        self.instance: 'Instance' = instance
+        self.instance = instance
         self.line = line
         self.column = column
 
@@ -449,7 +452,9 @@ def serialize(self) -> JsonDict:
     @classmethod
     def deserialize(cls, data: JsonDict) -> 'SelfType':
         assert data['.class'] == 'SelfType'
-        return cls(deserialize_type(data['instance']), data['fullname'])
+        instance = deserialize_type(data['instance'])
+        assert isinstance(instance, Instance)
+        return cls(instance, data['fullname'])
 
 
 class ParamSpecType(TypeVarLikeType):

diff --git a/runner.py b/runner.py
@@ -0,0 +1,13 @@
+import sys
+
+from mypy.version import __version__
+from mypy.build import build, BuildSource, Options
+
+print(__version__)
+
+options = Options()
+options.show_traceback = True
+options.raise_exceptions = True
+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
@@ -0,0 +1,38 @@
+from __future__ import annotations
+
+from typing import Self, TypeVar, Protocol
+
+T = TypeVar("T")
+
+
+class InstanceOf(Protocol[T]):
+    @property  # type: ignore
+    def __class__(self) -> T: ...  # type: ignore
+
+
+class MyMetaclass(type):
+    bar: str
+
+    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
+
+    def __call__(cls, *args, **kwargs) -> InstanceOf[Self]:
+        return super().__call__(*args, **kwargs)
+
+
+class Foo(metaclass=MyMetaclass):
+    THIS: int
+
+reveal_type(Foo)
+reveal_type(Foo())
+foos = Foo * 3
+reveal_type(foos)