Fix CI

python · Gobot1234 · Jul 15, 2022 · Jul 15, 2022 · Jul 17, 2022 · Jul 17, 2022
commit fe0eea78ff32dea526f41e6efa47d8a49f17858c
diff --git a/mypy/semanal.py b/mypy/semanal.py
@@ -712,18 +712,17 @@ def prepare_method_signature(self, func: FuncDef, info: TypeInfo) -> None:
 
                 leading_type = func.type.arg_types[0]
                 proper_leading_type = get_proper_type(leading_type)
-                if isinstance(proper_leading_type, Instance):  # method[[Self, ...], Self] case
+                if isinstance(proper_leading_type, Instance):  # method[[Instance, ...], Any] case
                     proper_leading_type = self_type_type = SelfType("Self", proper_leading_type)
-                    func.type = replace_implicit_first_type(func.type, proper_leading_type)
+                    func.type.variables = [self_type_type, *func.type.variables]
                 elif (
                     isinstance(proper_leading_type, TypeType) and isinstance(proper_leading_type.item, Instance)
-                ):  # classmethod[[type[Self], ...], Self] case
+                ):  # classmethod[[type[Instance], ...], Any] case
                     self_type_type = SelfType("Self", proper_leading_type.item)
                     proper_leading_type = self.class_type(self_type_type)
-                    func.type = replace_implicit_first_type(func.type, proper_leading_type)
-                elif self.is_self_type(proper_leading_type):
+                    func.type.variables = [self_type_type, *func.type.variables]
+                elif self.is_self_type(proper_leading_type):  # method[[Self, ...], Self] case
                     proper_leading_type = self_type_type = SelfType("Self", self.named_type(info.fullname))
-                    func.type = replace_implicit_first_type(func.type, proper_leading_type)
                 elif isinstance(proper_leading_type, UnboundType):
                     # classmethod[[type[Self], ...], Self] case
                     node = self.lookup(proper_leading_type.name, func)
@@ -735,21 +734,15 @@ def prepare_method_signature(self, func: FuncDef, info: TypeInfo) -> None:
                     ):
                         self_type_type = SelfType("Self", self.named_type(info.fullname))
                         proper_leading_type = self.class_type(self_type_type)
-                        func.type = replace_implicit_first_type(func.type, proper_leading_type)
+                    else:
+                        return
+                else:
+                    return
+                func.type = replace_implicit_first_type(func.type, proper_leading_type)
 
-                    # bind any SelfTypes in args and return types
+                # bind any SelfTypes in args and return types
                 for idx, arg in enumerate(func.type.arg_types):
                     if self.is_self_type(arg):
-                        if func.is_static:
-                            self.fail(
-                                "Self-type annotations of staticmethods are not supported, "
-                                "please replace the type with {}".format(self_type.type.name),
-                                func
-                            )
-                            func.type.arg_types[idx] = self.named_type(
-                                self_type.type.name
-                            )  # we replace them here for them
-                            continue
                         if self_type_type.fullname == self_type_type.name:
                             assert isinstance(arg, UnboundType)
                             table_node = self.lookup(arg.name, func)
@@ -765,14 +758,6 @@ def prepare_method_signature(self, func: FuncDef, info: TypeInfo) -> None:
                         )
                         assert isinstance(table_node, SymbolTableNode) and table_node.node
                         self_type_type.fullname = table_node.node.fullname
-                    if func.is_static:
-                        self.fail(
-                            "Self-type annotations of staticmethods are not supported, "
-                            "please replace the type with {}".format(self_type.type.name),
-                            func,
-                        )
-                        func.type.ret_type = self.named_type(self_type.type.name)
-                        return
                     func.type.ret_type = self_type_type
 
     def set_original_def(self, previous: Optional[Node], new: Union[FuncDef, Decorator]) -> bool:
@@ -5607,7 +5592,7 @@ def has_placeholder(typ: Type) -> bool:
     return typ.accept(HasPlaceholders())
 
 
-FunctionLikeT = TypeVar("FunctionLikeT", bound=FunctionLike)
+FunctionLikeT = TypeVar("FunctionLikeT", CallableType, Overloaded)
 
 
 def replace_implicit_first_type(sig: FunctionLikeT, new: Type) -> FunctionLikeT:

diff --git a/mypy/subtypes.py b/mypy/subtypes.py
@@ -330,6 +330,8 @@ def visit_instance(self, left: Instance) -> bool:
             return False
 
     def visit_type_var(self, left: TypeVarType) -> bool:
+        if isinstance(left, SelfType):
+            return self.visit_self_type(left)
         right = self.right
         if isinstance(right, TypeVarType) and left.id == right.id:
             return True

diff --git a/mypy/typeanal.py b/mypy/typeanal.py
@@ -1143,11 +1143,16 @@ def bind_function_type_variables(
         """Find the type variables of the function type and bind them in our tvar_scope"""
         if fun_type.variables:
             for var in fun_type.variables:
-                var_node = self.lookup_qualified(var.name, defn)
-                assert var_node, "Binding for function type variable not found within function"
-                var_expr = var_node.node
-                assert isinstance(var_expr, TypeVarLikeExpr)
-                self.tvar_scope.bind_new(var.name, var_expr)
+                if not isinstance(var, SelfType):
+                    var_node = self.lookup_qualified(var.name, defn)
+                    assert var_node, "Binding for function type variable not found within function"
+                    var_expr = var_node.node
+                    # if isinstance(var_expr, Var) and var_expr.fullname in SELF_TYPE_NAMES:
+                    #     var_expr = TypeVarExpr("Self", var_expr.fullname, [], var.upper_bound)
+                    assert isinstance(var_expr, TypeVarLikeExpr)
+                    self.tvar_scope.bind_new(var.name, var_expr)
+                else:
+                    self.tvar_scope.bind_existing(var)
             return fun_type.variables
         typevars = self.infer_type_variables(fun_type)
         # Do not define a new type variable if already defined in scope.
@@ -1209,7 +1214,7 @@ def anal_type(self, t: Type, nested: bool = True, *, allow_param_spec: bool = Fa
         return analyzed
 
     def anal_var_def(self, var_def: TypeVarLikeType) -> TypeVarLikeType:
-        if isinstance(var_def, TypeVarType):
+        if isinstance(var_def, TypeVarType) and not isinstance(var_def, SelfType):
             return TypeVarType(
                 var_def.name,
                 var_def.fullname,

diff --git a/mypy/types.py b/mypy/types.py
@@ -500,7 +500,7 @@ def deserialize(cls, data: JsonDict) -> 'TypeVarLikeType':
 class TypeVarType(TypeVarLikeType):
     """Type that refers to a type variable."""
 
-    __slots__ = ('values', 'variance')
+    __slots__ = ('values', 'variance', 'stack')
 
     values: List[Type]  # Value restriction, empty list if no restriction
     variance: int
@@ -512,6 +512,7 @@ def __init__(self, name: str, fullname: str, id: Union[TypeVarId, int], values:
         assert values is not None, "No restrictions must be represented by empty list"
         self.values = values
         self.variance = variance
+        self.stack = inspect.stack()
 
     @staticmethod
     def new_unification_variable(old: 'TypeVarType') -> 'TypeVarType':
@@ -555,21 +556,26 @@ def deserialize(cls, data: JsonDict) -> 'TypeVarType':
         )
 
 
+SELF_ID = TypeVarId(0.5)  # type: ignore
+# this is a hack cause I need a way to represent a number that's constant and can't be +ve or -ve
+# and using TypeVarId.new() would quickly hit a huge number which is harder to read.
+
+
 class SelfType(TypeVarType):
     __slots__ = ()
     upper_bound: 'Instance'
 
     def __init__(self, fullname: str, upper_bound: 'Instance', line: int = -1, column: int = -1) -> None:
         super().__init__(
-            "Self", fullname, -1, [], upper_bound, line=line, column=column
+            "Self",
+            fullname,
+            SELF_ID,
+            [],
+            upper_bound,
+            line=line,
+            column=column,
         )
 
-    def accept(self, visitor: 'TypeVisitor[T]') -> T:
-        from mypy.subtypes import SubtypeVisitor
-        if isinstance(visitor, (TypeStrVisitor, SubtypeVisitor)):
-            return visitor.visit_self_type(self)
-        return super().accept(visitor)
-
     def __hash__(self) -> int:
         return hash(self.upper_bound)
 
@@ -1119,6 +1125,7 @@ def deserialize(cls, data: JsonDict) -> 'DeletedType':
 
 # Fake TypeInfo to be used as a placeholder during Instance de-serialization.
 NOT_READY: Final = mypy.nodes.FakeInfo("De-serialization failure: TypeInfo not fixed")
+import inspect
 

 class Instance(ProperType):
@@ -1152,12 +1159,13 @@ def try_getting_instance_fallback(typ: ProperType) -> Optional[Instance]:
 
     """
 
-    __slots__ = ('type', 'args', 'invalid', 'type_ref', 'last_known_value', '_hash')
+    __slots__ = ('type', 'args', 'invalid', 'type_ref', 'last_known_value', '_hash', 'stack')
 
     def __init__(self, typ: mypy.nodes.TypeInfo, args: Sequence[Type],
                  line: int = -1, column: int = -1, *,
                  last_known_value: Optional['LiteralType'] = None) -> None:
         super().__init__(line, column)
+        # self.stack = inspect.stack()
         self.type = typ
         self.args = tuple(args)
         self.type_ref: Optional[str] = None
@@ -1516,6 +1524,7 @@ class CallableType(FunctionLike):
                  'type_guard',  # T, if -> TypeGuard[T] (ret_type is bool in this case).
                  'from_concatenate',  # whether this callable is from a concatenate object
                                       # (this is used for error messages)
+                                      'stack',
                  )
 
     def __init__(self,
@@ -1539,6 +1548,7 @@ def __init__(self,
                  type_guard: Optional[Type] = None,
                  from_concatenate: bool = False
                  ) -> None:
+        self.stack = inspect.stack()
         super().__init__(line, column)
         assert len(arg_types) == len(arg_kinds) == len(arg_names)
         if variables is None:
@@ -2614,12 +2624,10 @@ def get_proper_types(it: Iterable[Optional[Type]]
 # to make it easier to gradually get modules working with mypyc.
 # Import them here, after the types are defined.
 # This is intended as a re-export also.
-from mypy.type_visitor import (  # noqa
-    TypeVisitor as TypeVisitor,
-    SyntheticTypeVisitor as SyntheticTypeVisitor,
-    TypeTranslator as TypeTranslator,
-    TypeQuery as TypeQuery,
-)
+from mypy.type_visitor import SyntheticTypeVisitor as SyntheticTypeVisitor
+from mypy.type_visitor import TypeQuery as TypeQuery
+from mypy.type_visitor import TypeTranslator as TypeTranslator
+from mypy.type_visitor import TypeVisitor as TypeVisitor  # noqa
 
 
 class TypeStrVisitor(SyntheticTypeVisitor[str]):
@@ -2693,6 +2701,8 @@ def visit_instance(self, t: Instance) -> str:
         return s
 
     def visit_type_var(self, t: TypeVarType) -> str:
+        if isinstance(t, SelfType):
+            return self.visit_self_type(t)
         if t.name is None:
             # Anonymous type variable type (only numeric id).
             s = f'`{t.id}'