Adds support for nested KindN (#688)

* Adds support for nested KindN

* Fixes CI

* Fixes CI

* Adds type tests

* Fixes part of type tests

* Fixes type tests

* Fixes type tests

Author: sobolevn

returns/contrib/mypy/_features/kind.py

@@ -8,13 +8,13 @@
     MethodContext,
     MethodSigContext,
 )
-from mypy.typeops import bind_self, erase_to_bound
+from mypy.typeops import bind_self
 from mypy.types import AnyType, CallableType, FunctionLike, Instance, Overloaded
 from mypy.types import Type as MypyType
 from mypy.types import TypeOfAny, TypeType, TypeVarType, get_proper_type
 
-from returns.contrib.mypy._consts import TYPED_KINDN
 from returns.contrib.mypy._typeops.fallback import asserts_fallback_to_any
+from returns.contrib.mypy._typeops.visitor import translate_kind_instance
 
 # TODO: probably we can validate `KindN[]` creation during `get_analtype`
 
@@ -111,6 +111,8 @@ def kinded_signature(ctx: MethodSigContext) -> CallableType:
     return wrapped_method
 
 
+# TODO: we should raise an error if bound type does not have any `KindN`
+# instances, because that's not how `@kinded` and `Kinded[]` should be used.
 def kinded_call(ctx: MethodContext) -> MypyType:
     """
     Reveals the correct return type of ``Kinded.__call__`` method.
@@ -125,7 +127,7 @@ def kinded_call(ctx: MethodContext) -> MypyType:
 
     See :class:`returns.primitives.hkt.Kinded` for more information.
     """
-    return _process_kinded_type(ctx.default_return_type)
+    return translate_kind_instance(ctx.default_return_type)
 
 
 @asserts_fallback_to_any
@@ -164,27 +166,3 @@ def _crop_kind_args(
     if limit is None:
         limit = kind.args[0].args  # type: ignore
     return kind.args[1:len(limit) + 1]
-
-
-def _process_kinded_type(instance: MypyType) -> MypyType:
-    """Recursively process all type arguments in a kind."""
-    kind = get_proper_type(instance)
-    if not isinstance(kind, Instance) or not kind.args:
-        return instance
-
-    if kind.type.fullname != TYPED_KINDN:  # this is some other instance
-        return instance
-
-    real_type = get_proper_type(kind.args[0])
-    if isinstance(real_type, TypeVarType):
-        return erase_to_bound(real_type)
-    elif isinstance(real_type, Instance):
-        return real_type.copy_modified(args=[
-            # Let's check if there are any nested `KindN[]` instance,
-            # if so, it would be dekinded into a regular type following
-            # the same rules:
-            _process_kinded_type(type_arg)
-            for type_arg in kind.args[1:len(real_type.args) + 1]
-        ])
-    # This should never happen, probably can be an exception:
-    return AnyType(TypeOfAny.implementation_artifact)

returns/contrib/mypy/_typeops/visitor.py

@@ -0,0 +1,141 @@
+from typing import Iterable, List, Optional
+
+from mypy.typeops import erase_to_bound
+from mypy.types import (
+    AnyType,
+    CallableType,
+    DeletedType,
+    ErasedType,
+    Instance,
+    LiteralType,
+    NoneType,
+    Overloaded,
+    PartialType,
+    TupleType,
+    Type,
+    TypedDictType,
+    TypeOfAny,
+    TypeType,
+    TypeVarType,
+    UnboundType,
+    UninhabitedType,
+    UnionType,
+    get_proper_type,
+)
+
+from returns.contrib.mypy._consts import TYPED_KINDN
+
+# TODO: replace with real `TypeTranslator` in the next mypy release.
+_LEAF_TYPES = (
+    UnboundType,
+    AnyType,
+    NoneType,
+    UninhabitedType,
+    ErasedType,
+    DeletedType,
+    TypeVarType,
+    PartialType,
+)
+
+
+def translate_kind_instance(typ: Type) -> Type:  # noqa: WPS, C901
+    """
+    We use this ugly hack to translate ``KindN[x, y]`` into ``x[y]``.
+
+    This is required due to the fact that ``KindN``
+    can be nested in other types, like: ``List[KindN[...]]``.
+
+    We will refactor this code after ``TypeTranslator``
+    is released in ``mypy@0.800`` version.
+    """
+    typ = get_proper_type(typ)
+
+    if isinstance(typ, _LEAF_TYPES):  # noqa: WPS223
+        return typ
+    elif isinstance(typ, Instance):
+        last_known_value: Optional[LiteralType] = None
+        if typ.last_known_value is not None:
+            raw_last_known_value = translate_kind_instance(typ.last_known_value)
+            assert isinstance(raw_last_known_value, LiteralType)
+            last_known_value = raw_last_known_value
+        instance = Instance(
+            typ=typ.type,
+            args=_translate_types(typ.args),
+            line=typ.line,
+            column=typ.column,
+            last_known_value=last_known_value,
+        )
+        if typ.type.fullname == TYPED_KINDN:  # That's where we do the change
+            return _process_kinded_type(instance)
+        return instance
+
+    elif isinstance(typ, CallableType):
+        return typ.copy_modified(
+            arg_types=_translate_types(typ.arg_types),
+            ret_type=translate_kind_instance(typ.ret_type),
+        )
+    elif isinstance(typ, TupleType):
+        return TupleType(
+            _translate_types(typ.items),
+            translate_kind_instance(typ.partial_fallback),  # type: ignore
+            typ.line,
+            typ.column,
+        )
+    elif isinstance(typ, TypedDictType):
+        dict_items = {
+            item_name: translate_kind_instance(item_type)
+            for item_name, item_type in typ.items.items()
+        }
+        return TypedDictType(
+            dict_items,
+            typ.required_keys,
+            translate_kind_instance(typ.fallback),  # type: ignore
+            typ.line,
+            typ.column,
+        )
+    elif isinstance(typ, LiteralType):
+        fallback = translate_kind_instance(typ.fallback)
+        assert isinstance(fallback, Instance)
+        return LiteralType(
+            value=typ.value,
+            fallback=fallback,
+            line=typ.line,
+            column=typ.column,
+        )
+    elif isinstance(typ, UnionType):
+        return UnionType(_translate_types(typ.items), typ.line, typ.column)
+    elif isinstance(typ, Overloaded):
+        functions: List[CallableType] = []
+        for func in typ.items():
+            new = translate_kind_instance(func)
+            assert isinstance(new, CallableType)
+            functions.append(new)
+        return Overloaded(items=functions)
+    elif isinstance(typ, TypeType):
+        return TypeType.make_normalized(
+            translate_kind_instance(typ.item),
+            line=typ.line,
+            column=typ.column,
+        )
+    return typ
+
+
+def _translate_types(types: Iterable[Type]) -> List[Type]:
+    return [translate_kind_instance(typ) for typ in types]
+
+
+def _process_kinded_type(kind: Instance) -> Type:
+    """Recursively process all type arguments in a kind."""
+    if not kind.args:
+        return kind
+
+    real_type = get_proper_type(kind.args[0])
+    if isinstance(real_type, TypeVarType):
+        return erase_to_bound(real_type)
+    elif isinstance(real_type, Instance):
+        return real_type.copy_modified(
+            args=kind.args[1:len(real_type.args) + 1],
+        )
+
+    # This should never happen, probably can be an exception:
+    return AnyType(TypeOfAny.implementation_artifact)

returns/primitives/hkt.py

@@ -9,12 +9,12 @@
 
 _FunctionDefType = TypeVar(
     '_FunctionDefType',
-    bound=Callable[..., 'KindN'],
+    bound=Callable,
     covariant=True,  # This is a must! Otherwise it would not work.
 )
 _FunctionType = TypeVar(
     '_FunctionType',
-    bound=Callable[..., 'KindN'],
+    bound=Callable,
 )
 
 _UpdatedType = TypeVar('_UpdatedType')

setup.cfg

@@ -71,6 +71,8 @@ per-file-ignores =
   returns/contrib/mypy/*.py: S101, WPS201
   returns/contrib/pytest/plugin.py: WPS201, WPS430, WPS437, WPS609
   returns/contrib/hypothesis/*.py: WPS437, WPS609
+  # TODO: remove after mypy@0.800
+  returns/contrib/mypy/_typeops/visitor.py: S101, WPS232
   # There are multiple assert's in tests:
   tests/*.py: S101, WPS204, WPS218, WPS226, WPS432, WPS436
   # Some examples don't have any docs on purpose:

typesafety/test_converters/test_flatten.yml

@@ -26,7 +26,7 @@
 
     x: Result[Result[int, str], float]
     # TODO: I am pretty sure we can later fix this to be an error:
-    reveal_type(flatten(x))  # N: Revealed type is 'returns.result.Result*[builtins.int*, builtins.object*]'
+    reveal_type(flatten(x))  # N: Revealed type is 'returns.result.Result[builtins.int, builtins.object]'
 
 
 - case: flatten_custom_type
@@ -43,7 +43,7 @@
         ...
 
     x: MyClass[MyClass[int]]
-    reveal_type(flatten(x))  # N: Revealed type is 'main.MyClass*[builtins.int*]'
+    reveal_type(flatten(x))  # N: Revealed type is 'main.MyClass[builtins.int]'
 
 
 - case: flatten_wrong_flatten_error_type
@@ -66,7 +66,7 @@
     from returns.converters import flatten
     from returns.io import IO
 
-    reveal_type(flatten(IO(IO(1))))  # N: Revealed type is 'returns.io.IO*[builtins.int*]'
+    reveal_type(flatten(IO(IO(1))))  # N: Revealed type is 'returns.io.IO[builtins.int]'
 
 
 - case: flatten_maybe
@@ -75,7 +75,7 @@
     from returns.converters import flatten
     from returns.maybe import Some
 
-    reveal_type(flatten(Some(Some(1))))  # N: Revealed type is 'returns.maybe.Maybe*[builtins.int*]'
+    reveal_type(flatten(Some(Some(1))))  # N: Revealed type is 'returns.maybe.Maybe[builtins.int]'
 
 
 - case: flatten_result
@@ -87,7 +87,7 @@
     def returns_result() -> Result[Result[int, str], str]:
         ...
 
-    reveal_type(flatten(returns_result()))  # N: Revealed type is 'returns.result.Result*[builtins.int*, builtins.str*]'
+    reveal_type(flatten(returns_result()))  # N: Revealed type is 'returns.result.Result[builtins.int, builtins.str]'
 
 
 - case: flatten_ioresult
@@ -99,7 +99,7 @@
     def returns_ioresult() -> IOResult[IOResult[int, str], str]:
         ...
 
-    reveal_type(flatten(returns_ioresult()))  # N: Revealed type is 'returns.io.IOResult*[builtins.int*, builtins.str*]'
+    reveal_type(flatten(returns_ioresult()))  # N: Revealed type is 'returns.io.IOResult[builtins.int, builtins.str]'
 
 
 - case: flatten_context
@@ -110,7 +110,7 @@
 
     x: RequiresContext[RequiresContext[str, int], int]
 
-    reveal_type(flatten(x))  # N: Revealed type is 'returns.context.requires_context.RequiresContext*[builtins.str*, builtins.int*]'
+    reveal_type(flatten(x))  # N: Revealed type is 'returns.context.requires_context.RequiresContext[builtins.str, builtins.int]'
 
 
 - case: flatten_context_result
@@ -121,7 +121,7 @@
 
     x: RequiresContextResult[RequiresContextResult[str, int, float], int, float]
 
-    reveal_type(flatten(x))  # N: Revealed type is 'returns.context.requires_context_result.RequiresContextResult*[builtins.str*, builtins.int*, builtins.float*]'
+    reveal_type(flatten(x))  # N: Revealed type is 'returns.context.requires_context_result.RequiresContextResult[builtins.str, builtins.int, builtins.float]'
 
 
 - case: flatten_context_ioresult
@@ -132,7 +132,7 @@
 
     x: RequiresContextIOResult[RequiresContextIOResult[str, int, float], int, float]
 
-    reveal_type(flatten(x))  # N: Revealed type is 'returns.context.requires_context_ioresult.RequiresContextIOResult*[builtins.str*, builtins.int*, builtins.float*]'
+    reveal_type(flatten(x))  # N: Revealed type is 'returns.context.requires_context_ioresult.RequiresContextIOResult[builtins.str, builtins.int, builtins.float]'
 
 
 - case: flatten_context_ioresult
@@ -143,7 +143,7 @@
 
     x: RequiresContextIOResult[RequiresContextIOResult[str, int, float], int, float]
 
-    reveal_type(flatten(x))  # N: Revealed type is 'returns.context.requires_context_ioresult.RequiresContextIOResult*[builtins.str*, builtins.int*, builtins.float*]'
+    reveal_type(flatten(x))  # N: Revealed type is 'returns.context.requires_context_ioresult.RequiresContextIOResult[builtins.str, builtins.int, builtins.float]'
 
 
 - case: flatten_future_result
@@ -154,7 +154,7 @@
 
     x: ReaderFutureResult[ReaderFutureResult[int, bool, str], bool, str]
 
-    reveal_type(flatten(x))  # N: Revealed type is 'returns.context.requires_context_future_result.RequiresContextFutureResult*[builtins.int*, builtins.bool*, builtins.str*]'
+    reveal_type(flatten(x))  # N: Revealed type is 'returns.context.requires_context_future_result.RequiresContextFutureResult[builtins.int, builtins.bool, builtins.str]'
 
 
 - case: flatten_future_result
@@ -165,4 +165,4 @@
 
     x: FutureResult[FutureResult[int, str], str]
 
-    reveal_type(flatten(x))  # N: Revealed type is 'returns.future.FutureResult*[builtins.int*, builtins.str*]'
+    reveal_type(flatten(x))  # N: Revealed type is 'returns.future.FutureResult[builtins.int, builtins.str]'

typesafety/test_examples/test_pair4_reuse.yml

@@ -13,4 +13,4 @@
     reveal_type(map_(str)(my_pair))
   out: |
     main:5: note: Revealed type is 'test_pair4.Pair[builtins.str*, builtins.int]'
-    main:6: note: Revealed type is 'test_pair4.Pair*[builtins.str, builtins.int*]'
+    main:6: note: Revealed type is 'test_pair4.Pair[builtins.str, builtins.int]'