WIP

Author: sobolevn

classes/_registry.py

@@ -1,4 +1,3 @@
-from types import MethodType
 from typing import Callable, Dict, NoReturn, Optional
 
 TypeRegistry = Dict[type, Callable]
@@ -11,7 +10,7 @@ def choose_registry(  # noqa: WPS211
     typ: type,
     is_protocol: bool,
     delegate: Optional[type],
-    concretes: TypeRegistry,
+    delegates: TypeRegistry,
     instances: TypeRegistry,
     protocols: TypeRegistry,
 ) -> TypeRegistry:
@@ -21,12 +20,12 @@ def choose_registry(  # noqa: WPS211
     It depends on how ``instance`` method is used and also on the type itself.
     """
     if is_protocol and delegate is not None:
-        raise ValueError('Both `is_protocol` and `delegated` are passed')
+        raise ValueError('Both `is_protocol` and `delegate` are passed')
 
     if is_protocol:
         return protocols
     elif delegate is not None:
-        return concretes
+        return delegates
     return instances
 
 

classes/_typeclass.py

@@ -312,7 +312,7 @@ class _TypeClass(  # noqa: WPS214
         '_associated_type',
 
         # Registry:
-        '_concretes',
+        '_delegates',
         '_instances',
         '_protocols',
 
@@ -361,7 +361,7 @@ def __init__(
         self._associated_type = associated_type
 
         # Registries:
-        self._concretes: TypeRegistry = {}
+        self._delegates: TypeRegistry = {}
         self._instances: TypeRegistry = {}
         self._protocols: TypeRegistry = {}
 
@@ -418,13 +418,13 @@ def __call__(
         And all typeclasses that match ``Callable[[int, int], int]`` signature
         will typecheck.
         """
-        # At first, we try all our concrete types,
-        # we don't cache it, because we cannot.
+        # At first, we try all our delegate types,
+        # we don't cache it, because it is impossible.
         # We only have runtime type info: `type([1]) == type(['a'])`.
         # It might be slow!
-        # Don't add concrete types unless
+        # Don't add any delegate types unless
         # you are absolutely know what you are doing.
-        impl = self._dispatch_concrete(instance)
+        impl = self._dispatch_delegate(instance)
         if impl is not None:
             return impl(instance, *args, **kwargs)
 
@@ -499,21 +499,21 @@ def supports(
         See also: https://www.python.org/dev/peps/pep-0647
         """
         # Here we first check that instance is already in the cache
-        # and only then we check concrete types.
+        # and only then we check delegate types.
         # Why?
         # Because if some type is already in the cache,
-        # it means that it is not concrete.
+        # it means that it is not a delegate.
         # So, this is simply faster.
         instance_type = type(instance)
         if instance_type in self._dispatch_cache:
             return True
 
-        # We never cache concrete types.
-        if self._dispatch_concrete(instance) is not None:
+        # We never cache delegate types.
+        if self._dispatch_delegate(instance) is not None:
             return True
 
         # This only happens when we don't have a cache in place
-        # and this is not a concrete generic:
+        # and this is not a delegate type:
         impl = self._dispatch(instance, instance_type)
         if impl is None:
             return False
@@ -535,7 +535,8 @@ def instance(
 
         Args:
             is_protocol - required when passing protocols.
-            delegate - required when using concrete generics like ``List[str]``.
+            delegate - required when using delegate types, for example,
+                when working with concrete generics like ``List[str]``.
 
         Returns:
             Decorator for instance handler.
@@ -570,7 +571,7 @@ def decorator(implementation):
                 typ=typ,
                 is_protocol=is_protocol,
                 delegate=delegate,
-                concretes=self._concretes,
+                delegates=self._delegates,
                 instances=self._instances,
                 protocols=self._protocols,
             )
@@ -600,9 +601,9 @@ def _dispatch(self, instance, instance_type: type) -> Optional[Callable]:
 
         return _find_impl(instance_type, self._instances)
 
-    def _dispatch_concrete(self, instance) -> Optional[Callable]:
-        for concrete, callback in self._concretes.items():
-            if isinstance(instance, concrete):
+    def _dispatch_delegate(self, instance) -> Optional[Callable]:
+        for delegate, callback in self._delegates.items():
+            if isinstance(instance, delegate):
                 return callback
         return None
 

classes/contrib/mypy/features/typeclass.py

@@ -16,6 +16,7 @@
 
 from classes.contrib.mypy.typeops import (
     call_signatures,
+    fallback,
     instance_args,
     mro,
     type_loader,
@@ -184,10 +185,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)

classes/contrib/mypy/typeops/instance_context.py

@@ -18,7 +18,12 @@
 
 @final
 class InstanceContext(NamedTuple):
-    """"""
+    """
+    Instance definition context.
+
+    We use it to store all important types and data in one place
+    to help with validation and type manipulations.
+    """
 
     # Signatures:
     typeclass_signature: CallableType
@@ -41,8 +46,12 @@ class InstanceContext(NamedTuple):
     # Mypy context:
     ctx: MethodContext
 
-    @classmethod
-    def build(
+    @classmethod  # noqa: WPS211
+    def build(  # noqa: WPS211
+        # It has a lot of arguments, but I don't see how I can simply it.
+        # I don't want to add steps or intermediate types.
+        # It is okay for this method to have a lot arguments,
+        # because it store a lot of data.
         cls,
         typeclass_signature: CallableType,
         instance_signature: CallableType,
@@ -51,6 +60,12 @@ def build(
         fullname: str,
         ctx: MethodContext,
     ) -> 'InstanceContext':
+        """
+        Builds instance context.
+
+        It also infers several missing parts from the present data.
+        Like real ``instance_type`` and arg types.
+        """
         runtime_type = inference.infer_runtime_type_from_context(
             fallback=passed_args.items[0],
             fullname=fullname,
@@ -129,7 +144,41 @@ def _infer_instance_type(
     runtime_type: MypyType,
     delegate: Optional[MypyType],
 ) -> MypyType:
-    # TODO: document
+    """
+    Infers real instance type.
+
+    We have three options here.
+    First one, ``delegate`` is not set at all:
+
+    .. code:: python
+
+        @some.instance(list)
+        def _some_list(instance: list) -> int:
+            ...
+
+    Then, infered instance type is just ``list``.
+
+    Second, we have a delegate of its own:
+
+    .. code:: python
+
+        @some.instance(list, delegate=SomeDelegate)
+        def _some_list(instance: list) -> int:
+            ...
+
+    Then, infered instance type is ``list`` as well.
+
+    Lastly, we can have this case,
+    when ``delegate`` type is used for instance annotation:
+
+    .. code:: python
+
+        @some.instance(list, delegate=SomeDelegate)
+        def _some_list(instance: SomeDelegate) -> int:
+            ...
+
+    In this case, we will use runtime type ``list`` for instance type.
+    """
     if delegate is not None and is_same_type(instance_type, delegate):
         return runtime_type
     return instance_type

classes/contrib/mypy/typeops/mro.py

@@ -2,10 +2,9 @@
 
 from mypy.plugin import MethodContext
 from mypy.subtypes import is_equivalent
-from mypy.types import Instance
+from mypy.types import Instance, ProperType
 from mypy.types import Type as MypyType
 from mypy.types import TypeVarType, UnionType, union_items
-from mypy.sametypes import is_same_type
 from typing_extensions import final
 
 from classes.contrib.mypy.typeops import type_loader
@@ -68,7 +67,7 @@ class MetadataInjector(object):
 
     def __init__(
         self,
-        associated_type: Instance,
+        associated_type: MypyType,
         instance_type: MypyType,
         delegate: Optional[MypyType],
         ctx: MethodContext,
@@ -80,12 +79,16 @@ def __init__(
         It supports ``Instance`` and ``Union`` types.
         """
         self._associated_type = associated_type
-        self._instance_types = union_items(instance_type)
         self._delegate = delegate
         self._ctx = ctx
 
-        if delegate is not None:
-            self._instance_types.append(delegate)
+        # If delegate is passed, we don't add any types to `instance`'s mro.
+        # Why? See our `Delegate` docs.
+        if delegate is None:
+            self._instance_types = union_items(instance_type)
+        else:
+            assert isinstance(delegate, ProperType)
+            self._instance_types = [delegate]
 
         # Why do we store added types in a mutable global state?
         # Because, these types are hard to replicate without the proper context.
@@ -98,7 +101,8 @@ def add_supports_metadata(self) -> None:
             return
 
         for instance_type in self._instance_types:
-            assert isinstance(instance_type, Instance)
+            if not isinstance(instance_type, Instance):
+                continue
 
             supports_type = _load_supports_type(
                 associated_type=self._associated_type,
@@ -117,7 +121,6 @@ def add_supports_metadata(self) -> None:
                 # This is the first time this type is referenced in
                 # a typeclass'es instance defintinion.
                 # Just inject `Supports` with no extra steps:
-                print(instance_type, supports_type)
                 instance_type.type.bases.append(supports_type)
 
             if supports_type.type not in instance_type.type.mro:
@@ -132,8 +135,8 @@ def remove_supports_metadata(self) -> None:
             return
 
         for instance_type in self._instance_types:
-            assert isinstance(instance_type, Instance)
-            self._clean_instance_type(instance_type)
+            if isinstance(instance_type, Instance):
+                self._clean_instance_type(instance_type)
         self._added_types = []
 
     def _clean_instance_type(self, instance_type: Instance) -> None:
@@ -204,6 +207,10 @@ def _load_supports_type(
     delegate: Optional[MypyType],
     ctx: MethodContext,
 ) -> Instance:
+    # Why do have to modify args of `associated_type`?
+    # Because `mypy` requires `type_var.id` to match,
+    # otherwise, they would be treated as different variables.
+    # That's why we copy the typevar definition from instance itself.
     supports_spec = associated_type.copy_modified(args=[
         TypeVarType(var_def)
         for var_def in instance_type.type.defn.type_vars

classes/contrib/mypy/validation/validate_instance/__init__.py

@@ -7,6 +7,7 @@
 
 
 def check_type(instance_context: InstanceContext) -> bool:
+    """Checks that instance definition is correct."""
     return all([
         validate_signature.check_type(instance_context),
         validate_runtime.check_type(instance_context),

classes/contrib/mypy/validation/validate_instance/validate_runtime.py

@@ -45,7 +45,7 @@
 
 
 def check_type(
-    instance_context: InstanceContext
+    instance_context: InstanceContext,
 ) -> bool:
     """
     Checks runtime type.
@@ -122,10 +122,10 @@ def _check_runtime_protocol(
     runtime_type: MypyType,
     ctx: MethodContext,
     *,
-    is_protocol: bool,
+    is_protocol: Optional[bool],
 ) -> bool:
     if isinstance(runtime_type, Instance) and runtime_type.type:
-        if not is_protocol and runtime_type.type.is_protocol:
+        if is_protocol is False and runtime_type.type.is_protocol:
             ctx.api.fail(_IS_PROTOCOL_MISSING_MSG, ctx.context)
             return False
         elif is_protocol and not runtime_type.type.is_protocol:
@@ -193,7 +193,7 @@ def _check_tuple_size(
     delegate: Optional[MypyType],
     ctx: MethodContext,
 ) -> bool:
-    if delegate is None and isinstance(instance_type, TupleType):
+    if isinstance(instance_type, TupleType):
         ctx.api.fail(
             _TUPLE_LENGTH_MSG.format(instance_type.items[0], instance_type),
             ctx.context,

docs/conf.py

@@ -19,17 +19,6 @@
 
 sys.path.insert(0, os.path.abspath('..'))
 
-# TODO: Removes the whole if statement when the below PR is merged:
-# https://github.com/mgaitan/sphinxcontrib-mermaid/pull/71
-# From `sphinx>=4` the `ENOENT` constant was fully deprecated,
-# in order to make the things work with `sphinxcontrib-mermaid`
-# we need to mokey patch that constant.
-if sphinx.version_info[0] >= 4:
-    import errno  # noqa: WPS433
-
-    import sphinx.util.osutil  # noqa: I003, WPS301, WPS433
-    sphinx.util.osutil.ENOENT = errno.ENOENT
-
 
 # -- Project information -----------------------------------------------------