WIP

Author: sobolevn

CHANGELOG.md

@@ -8,8 +8,9 @@ We follow Semantic Versions since the `0.1.0` release.
 ### Features
 
 - Adds support for concrete generic types like `List[str]` and `Set[int]` #24
+- Adds support for types that have `__instancecheck__` defined
+  via `delegate` argument #248
 - Adds support for multiple type arguments in `Supports` type #244
-- Adds support for types that have `__instancecheck__` defined #248
 
 ### Bugfixes
 

classes/_registry.py

@@ -25,15 +25,7 @@ def choose_registry(  # noqa: WPS211
 
     if is_protocol:
         return protocols
-
-    is_concrete = (
-        delegate is not None or
-        isinstance(getattr(typ, '__instancecheck__', None), MethodType)
-    )
-    if is_concrete:
-        # This means that this type has `__instancecheck__` defined,
-        # which allows dynamic checks of what `isinstance` of this type.
-        # That's why we also treat this type as a concrete.
+    elif delegate is not None:
         return concretes
     return instances
 

classes/contrib/mypy/features/typeclass.py

@@ -16,14 +16,14 @@
 
 from classes.contrib.mypy.typeops import (
     call_signatures,
-    fallback,
     instance_args,
     mro,
     type_loader,
 )
+from classes.contrib.mypy.typeops.instance_context import InstanceContext
 from classes.contrib.mypy.validation import (
     validate_associated_type,
-    validate_typeclass,
+    validate_instance,
     validate_typeclass_def,
 )
 
@@ -184,10 +184,10 @@ class InstanceDefReturnType(object):
 
     """
 
-    @fallback.error_to_any({
-        # TODO: later we can use a custom exception type for this:
-        KeyError: 'Typeclass cannot be loaded, it must be a global declaration',
-    })
+    # @fallback.error_to_any({
+    #     # TODO: later we can use a custom exception type for this:
+    #     KeyError: 'Typeclass cannot be loaded, it must be a global declaration',
+    # })
     def __call__(self, ctx: MethodContext) -> MypyType:
         """Main entry point."""
         assert isinstance(ctx.type, Instance)
@@ -201,33 +201,21 @@ def __call__(self, ctx: MethodContext) -> MypyType:
         if not isinstance(instance_signature, CallableType):
             return ctx.default_return_type
 
-        # We need to add `Supports` metadata before typechecking,
-        # because it will affect type hierarchies.
-        metadata = mro.MetadataInjector(
-            typeclass.args[2],
-            instance_signature.arg_types[0],
-            ctx,
-        )
-        metadata.add_supports_metadata()
-
-        is_proper_typeclass = validate_typeclass.check_typeclass(
+        instance_context = InstanceContext.build(
             typeclass_signature=typeclass.args[1],
             instance_signature=instance_signature,
+            passed_args=ctx.type.args[0],
+            associated_type=typeclass.args[2],
             fullname=fullname,
-            passed_types=ctx.type.args[0],
             ctx=ctx,
         )
-        if not is_proper_typeclass:
-            # Since the typeclass is not valid,
-            # we undo the metadata manipulation,
-            # otherwise we would spam with invalid `Supports[]` base types:
-            metadata.remove_supports_metadata()
+        if not self._run_validation(instance_context):
             return AnyType(TypeOfAny.from_error)
 
         # If typeclass is checked, than it is safe to add new instance types:
         self._add_new_instance_type(
             typeclass=typeclass,
-            new_type=instance_signature.arg_types[0],
+            new_type=instance_context.instance_type,
             ctx=ctx,
         )
         return ctx.default_return_type
@@ -247,6 +235,25 @@ def _load_typeclass(
         assert isinstance(typeclass, Instance)
         return typeclass, typeclass_ref.args[3].value
 
+    def _run_validation(self, instance_context: InstanceContext) -> bool:
+        # We need to add `Supports` metadata before typechecking,
+        # because it will affect type hierarchies.
+        metadata = mro.MetadataInjector(
+            associated_type=instance_context.associated_type,
+            instance_type=instance_context.instance_type,
+            delegate=instance_context.delegate,
+            ctx=instance_context.ctx,
+        )
+        metadata.add_supports_metadata()
+
+        is_proper_instance = validate_instance.check_type(instance_context)
+        if not is_proper_instance:
+            # Since the typeclass is not valid,
+            # we undo the metadata manipulation,
+            # otherwise we would spam with invalid `Supports[]` base types:
+            metadata.remove_supports_metadata()
+        return is_proper_instance
+
     def _add_new_instance_type(
         self,
         typeclass: Instance,

classes/contrib/mypy/typeops/instance_context.py

@@ -0,0 +1,135 @@
+from typing import NamedTuple, Optional, Tuple
+
+from mypy.plugin import MethodContext
+from mypy.sametypes import is_same_type
+from mypy.types import (
+    CallableType,
+    FunctionLike,
+    Instance,
+    LiteralType,
+    TupleType,
+)
+from mypy.types import Type as MypyType
+from mypy.types import UninhabitedType
+from typing_extensions import final
+
+from classes.contrib.mypy.typeops import inference
+
+
+@final
+class InstanceContext(NamedTuple):
+    """"""
+
+    # Signatures:
+    typeclass_signature: CallableType
+    instance_signature: CallableType
+    infered_signature: CallableType
+
+    # Instance / runtime types:
+    instance_type: MypyType
+    runtime_type: MypyType
+
+    # Passed arguments:
+    passed_args: TupleType
+    is_protocol: Optional[bool]
+    delegate: Optional[MypyType]
+
+    # Meta:
+    fullname: str
+    associated_type: MypyType
+
+    # Mypy context:
+    ctx: MethodContext
+
+    @classmethod
+    def build(
+        cls,
+        typeclass_signature: CallableType,
+        instance_signature: CallableType,
+        passed_args: TupleType,
+        associated_type: MypyType,
+        fullname: str,
+        ctx: MethodContext,
+    ) -> 'InstanceContext':
+        runtime_type = inference.infer_runtime_type_from_context(
+            fallback=passed_args.items[0],
+            fullname=fullname,
+            ctx=ctx,
+        )
+
+        infered_signature = inference.try_to_apply_generics(
+            signature=typeclass_signature,
+            runtime_type=runtime_type,
+            ctx=ctx,
+        )
+
+        is_protocol, delegate = _ArgumentInference(passed_args)()
+        instance_type = _infer_instance_type(
+            instance_type=instance_signature.arg_types[0],
+            runtime_type=runtime_type,
+            delegate=delegate,
+        )
+
+        return InstanceContext(
+            typeclass_signature=typeclass_signature,
+            instance_signature=instance_signature,
+            infered_signature=infered_signature,
+            instance_type=instance_type,
+            runtime_type=runtime_type,
+            passed_args=passed_args,
+            is_protocol=is_protocol,
+            delegate=delegate,
+            associated_type=associated_type,
+            fullname=fullname,
+            ctx=ctx,
+        )
+
+
+@final
+class _ArgumentInference(object):
+    __slots__ = ('_passed_args',)
+
+    def __init__(self, passed_args: TupleType) -> None:
+        self._passed_args = passed_args
+
+    def __call__(self) -> Tuple[Optional[bool], Optional[MypyType]]:
+        _, is_protocol, delegate = self._passed_args.items
+        return (
+            self._infer_protocol_arg(is_protocol),
+            self._infer_delegate_arg(delegate),
+        )
+
+    def _infer_protocol_arg(
+        self,
+        is_protocol: MypyType,
+    ) -> Optional[bool]:
+        if isinstance(is_protocol, UninhabitedType):
+            return False
+
+        is_protocol_bool = (
+            isinstance(is_protocol, Instance) and
+            isinstance(is_protocol.last_known_value, LiteralType) and
+            isinstance(is_protocol.last_known_value.value, bool)
+        )
+        if is_protocol_bool:
+            return is_protocol.last_known_value.value  # type: ignore
+        return None
+
+    def _infer_delegate_arg(
+        self,
+        delegate: MypyType,
+    ) -> Optional[MypyType]:
+        if isinstance(delegate, FunctionLike) and delegate.is_type_obj():
+            return delegate.items()[-1].ret_type
+        return None
+
+
+def _infer_instance_type(
+    instance_type: MypyType,
+    runtime_type: MypyType,
+    delegate: Optional[MypyType],
+) -> MypyType:
+    # TODO: document
+    if delegate is not None and is_same_type(instance_type, delegate):
+        return runtime_type
+    return instance_type