Use proper_type plugin

returns/contrib/mypy/_features/curry.py

@@ -6,7 +6,7 @@
 from mypy.plugin import FunctionContext
 from mypy.types import AnyType, CallableType, FunctionLike, Overloaded
 from mypy.types import Type as MypyType
-from mypy.types import TypeOfAny
+from mypy.types import TypeOfAny, get_proper_type
 
 from returns.contrib.mypy._structures.args import FuncArg
 from returns.contrib.mypy._typeops.transform_callable import (
@@ -20,14 +20,14 @@
 
 def analyze(ctx: FunctionContext) -> MypyType:
  """Returns proper type for curried functions."""
- if not isinstance(ctx.arg_types[0][0], CallableType):
- return ctx.default_return_type
- if not isinstance(ctx.default_return_type, CallableType):
- return ctx.default_return_type
+ default_return = get_proper_type(ctx.default_return_type)
+ arg_type = get_proper_type(ctx.arg_types[0][0])
+ if not isinstance(arg_type, CallableType):
+ return default_return
+ if not isinstance(default_return, CallableType):
+ return default_return
 
- return _CurryFunctionOverloads(
- ctx.arg_types[0][0], ctx,
- ).build_overloads()
+ return _CurryFunctionOverloads(arg_type, ctx).build_overloads()
 
 
 @final
@@ -147,7 +147,7 @@ def _build_overloads_from_argtree(self, argtree: _ArgTree) -> None:
  # Will take `2` and apply its type to the previous function `1`.
  # Will result in `def x -> y -> A`
  # We also overloadify existing return types.
- ret_type = argtree.case.ret_type
+ ret_type = get_proper_type(argtree.case.ret_type)
  temp_any = isinstance(
  ret_type, AnyType,
  ) and ret_type.type_of_any == TypeOfAny.implementation_artifact

returns/contrib/mypy/_features/do_notation.py

@@ -36,22 +36,23 @@ def analyze(ctx: MethodContext) -> MypyType:
  if generator expression has ``if`` conditions inside.
 
  """
+ default_return = get_proper_type(ctx.default_return_type)
  if not ctx.args or not ctx.args[0]:
- return ctx.default_return_type
+ return default_return
 
  expr = ctx.args[0][0]
  if not isinstance(expr, GeneratorExpr):
  ctx.api.fail(_LITERAL_GENERATOR_EXPR_REQUIRED, expr)
- return ctx.default_return_type
+ return default_return
  if not isinstance(ctx.type, CallableType):
- return ctx.default_return_type
- if not isinstance(ctx.default_return_type, Instance):
- return ctx.default_return_type
+ return default_return
+ if not isinstance(default_return, Instance):
+ return default_return
 
  return _do_notation(
  expr=expr,
  type_info=ctx.type.type_object(),
- default_return_type=ctx.default_return_type,
+ default_return_type=default_return,
  ctx=ctx,
  )
 

returns/contrib/mypy/_features/flow.py

@@ -1,5 +1,6 @@
 from mypy.plugin import FunctionContext
 from mypy.types import Type as MypyType
+from mypy.types import get_proper_type
 
 from returns.contrib.mypy._typeops.inference import PipelineInference
 
@@ -46,7 +47,7 @@ def analyze(ctx: FunctionContext) -> MypyType:
  )
 
  return PipelineInference(
- ctx.arg_types[0][0],
+ get_proper_type(ctx.arg_types[0][0]),
  ).from_callable_sequence(
  real_arg_types,
  ctx.arg_kinds[1],

returns/contrib/mypy/_features/kind.py

@@ -39,7 +39,7 @@ def attribute_access(ctx: AttributeContext) -> MypyType:
 
  """
  assert isinstance(ctx.type, Instance)
- instance = ctx.type.args[0]
+ instance = get_proper_type(ctx.type.args[0])
 
  if isinstance(instance, TypeVarType):
  bound = get_proper_type(instance.upper_bound)
@@ -78,18 +78,15 @@ def dekind(ctx: FunctionContext) -> MypyType:
  So, ``dekind(KindN[T, int])`` will fail.
  """
  kind = get_proper_type(ctx.arg_types[0][0])
- correct_args = (
- isinstance(kind, Instance) and
- isinstance(kind.args[0], Instance)
- )
+ assert isinstance(kind, Instance) # mypy requires these lines
 
- if not correct_args:
+ kind_inst = get_proper_type(kind.args[0])
+
+ if not isinstance(kind_inst, Instance):
  ctx.api.fail(_KindErrors.dekind_not_instance, ctx.context)
  return AnyType(TypeOfAny.from_error)
 
- assert isinstance(kind, Instance) # mypy requires these lines
- assert isinstance(kind.args[0], Instance)
- return kind.args[0].copy_modified(args=_crop_kind_args(kind))
+ return kind_inst.copy_modified(args=_crop_kind_args(kind))
 
 
 @asserts_fallback_to_any
@@ -101,9 +98,10 @@ def kinded_signature(ctx: MethodSigContext) -> CallableType:
  See :class:`returns.primitives.hkt.Kinded` for more information.
  """
  assert isinstance(ctx.type, Instance)
- assert isinstance(ctx.type.args[0], FunctionLike)
 
- wrapped_method = ctx.type.args[0]
+ wrapped_method = get_proper_type(ctx.type.args[0])
+ assert isinstance(wrapped_method, FunctionLike)
+
  if isinstance(wrapped_method, Overloaded):
  return ctx.default_signature
 
@@ -138,10 +136,11 @@ def kinded_get_descriptor(ctx: MethodContext) -> MypyType:
  We do this due to ``__get__`` descriptor magic.
  """
  assert isinstance(ctx.type, Instance)
- assert isinstance(ctx.type.args[0], CallableType)
 
- wrapped_method = ctx.type.args[0]
- self_type = wrapped_method.arg_types[0]
+ wrapped_method = get_proper_type(ctx.type.args[0])
+ assert isinstance(wrapped_method, CallableType)
+
+ self_type = get_proper_type(wrapped_method.arg_types[0])
  signature = bind_self(
  wrapped_method,
  is_classmethod=isinstance(self_type, TypeType),

returns/contrib/mypy/_features/partial.py

@@ -2,9 +2,15 @@
 
 from mypy.nodes import ARG_STAR, ARG_STAR2
 from mypy.plugin import FunctionContext
-from mypy.types import CallableType, FunctionLike, Instance, Overloaded
-from mypy.types import Type as MypyType
-from mypy.types import TypeType
+from mypy.types import (
+ CallableType,
+ FunctionLike,
+ Instance,
+ Overloaded,
+ ProperType,
+ TypeType,
+ get_proper_type,
+)
 
 from returns.contrib.mypy._structures.args import FuncArg
 from returns.contrib.mypy._typeops.analtype import (
@@ -27,7 +33,7 @@
 )
 
 
-def analyze(ctx: FunctionContext) -> MypyType:
+def analyze(ctx: FunctionContext) -> ProperType:
  """
  This hook is used to make typed curring a thing in `returns` project.
 
@@ -40,26 +46,27 @@ def analyze(ctx: FunctionContext) -> MypyType:
  Internally we just reduce the original function's argument count.
  And drop some of them from function's signature.
  """
- if not isinstance(ctx.default_return_type, CallableType):
- return ctx.default_return_type
+ default_return = get_proper_type(ctx.default_return_type)
+ if not isinstance(default_return, CallableType):
+ return default_return
 
- function_def = ctx.arg_types[0][0]
+ function_def = get_proper_type(ctx.arg_types[0][0])
  func_args = _AppliedArgs(ctx)
 
  if len(list(filter(len, ctx.arg_types))) == 1:
  return function_def # this means, that `partial(func)` is called
  elif not isinstance(function_def, _SUPPORTED_TYPES):
- return ctx.default_return_type
+ return default_return
  elif isinstance(function_def, (Instance, TypeType)):
  # We force `Instance` and similar types to coercse to callable:
  function_def = func_args.get_callable_from_context()
 
  is_valid, applied_args = func_args.build_from_context()
  if not isinstance(function_def, (CallableType, Overloaded)) or not is_valid:
- return ctx.default_return_type
+ return default_return
 
  return _PartialFunctionReducer(
- ctx.default_return_type,
+ default_return,
  function_def,
  applied_args,
  ctx,
@@ -118,7 +125,7 @@ def __init__(
  self._case_functions: List[CallableType] = []
  self._fallbacks: List[CallableType] = []
 
- def new_partial(self) -> MypyType:
+ def new_partial(self) -> ProperType:
  """
  Creates new partial functions.
 
@@ -182,7 +189,7 @@ def _create_partial_case(
  return detach_callable(partial)
  return partial.copy_modified(variables=[])
 
- def _create_new_partial(self) -> MypyType:
+ def _create_new_partial(self) -> ProperType:
  """
  Creates a new partial function-like from set of callables.
 
@@ -220,12 +227,12 @@ def __init__(self, function_ctx: FunctionContext) -> None:
  self._function_ctx.arg_kinds[1:],
  )
 
- def get_callable_from_context(self) -> MypyType:
+ def get_callable_from_context(self) -> ProperType:
  """Returns callable type from the context."""
- return safe_translate_to_function(
+ return get_proper_type(safe_translate_to_function(
  self._function_ctx.arg_types[0][0],
  self._function_ctx,
- )
+ ))
 
  def build_from_context(self) -> Tuple[bool, List[FuncArg]]:
  """

returns/contrib/mypy/_features/pipe.py

@@ -40,9 +40,9 @@
 
 from mypy.nodes import ARG_POS
 from mypy.plugin import FunctionContext, MethodContext, MethodSigContext
-from mypy.types import AnyType, CallableType, FunctionLike, Instance
+from mypy.types import AnyType, CallableType, FunctionLike, Instance, ProperType
 from mypy.types import Type as MypyType
-from mypy.types import TypeOfAny, UnionType, get_proper_type
+from mypy.types import TypeOfAny, UnionType, get_proper_type, get_proper_types
 
 from returns.contrib.mypy._typeops.analtype import translate_to_function
 from returns.contrib.mypy._typeops.inference import PipelineInference
@@ -51,21 +51,22 @@
 
 def analyze(ctx: FunctionContext) -> MypyType:
  """This hook helps when we create the pipeline from sequence of funcs."""
- if not isinstance(ctx.default_return_type, Instance):
- return ctx.default_return_type
+ default_return = get_proper_type(ctx.default_return_type)
+ if not isinstance(default_return, Instance):
+ return default_return
 
  if not ctx.arg_types[0]: # We do require to pass `*functions` arg.
  ctx.api.fail('Too few arguments for "pipe"', ctx.context)
- return ctx.default_return_type
+ return default_return
 
  arg_types = [arg_type[0] for arg_type in ctx.arg_types if arg_type]
  first_step, last_step = _get_pipeline_def(arg_types, ctx)
  if not isinstance(first_step, FunctionLike):
- return ctx.default_return_type
+ return default_return
  if not isinstance(last_step, FunctionLike):
- return ctx.default_return_type
+ return default_return
 
- return ctx.default_return_type.copy_modified(
+ return default_return.copy_modified(
  args=[
  # First type argument represents first function arguments type:
  _unify_type(first_step, _get_first_arg_type),
@@ -82,9 +83,9 @@ def infer(ctx: MethodContext) -> MypyType:
  if not isinstance(ctx.type, Instance):
  return ctx.default_return_type
 
- pipeline_functions = ctx.type.args[2:]
+ pipeline_functions = get_proper_types(ctx.type.args[2:])
  return PipelineInference(
- ctx.arg_types[0][0],
+ get_proper_type(ctx.arg_types[0][0]),
  ).from_callable_sequence(
  pipeline_functions,
  list((ARG_POS,) * len(pipeline_functions)),
@@ -117,12 +118,12 @@ def _unify_type(
 def _get_pipeline_def(
  arg_types: List[MypyType],
  ctx: FunctionContext,
-) -> Tuple[MypyType, MypyType]:
+) -> Tuple[ProperType, ProperType]:
  first_step = get_proper_type(arg_types[0])
  last_step = get_proper_type(arg_types[-1])
 
  if not isinstance(first_step, FunctionLike):
- first_step = translate_to_function(first_step, ctx) # type: ignore
+ first_step = translate_to_function(first_step, ctx)
  if not isinstance(last_step, FunctionLike):
- last_step = translate_to_function(last_step, ctx) # type: ignore
+ last_step = translate_to_function(last_step, ctx)
  return first_step, last_step

returns/contrib/mypy/_typeops/analtype.py

@@ -3,8 +3,9 @@
 
 from mypy.checkmember import analyze_member_access
 from mypy.nodes import ARG_NAMED, ARG_OPT
-from mypy.types import CallableType, FunctionLike
+from mypy.types import CallableType, FunctionLike, ProperType
 from mypy.types import Type as MypyType
+from mypy.types import get_proper_type
 from typing_extensions import Literal
 
 from returns.contrib.mypy._structures.args import FuncArg
@@ -99,17 +100,17 @@ def safe_translate_to_function(
 
 
 def translate_to_function(
- function_def: MypyType,
+ function_def: ProperType,
  ctx: CallableContext,
-) -> MypyType:
+) -> ProperType:
  """
  Tries to translate a type into callable by accessing ``__call__`` attr.
 
  This might fail with ``mypy`` errors and that's how it must work.
  This also preserves all type arguments as-is.
  """
  checker = ctx.api.expr_checker # type: ignore
- return analyze_member_access(
+ return get_proper_type(analyze_member_access(
  '__call__',
  function_def,
  ctx.context,
@@ -120,4 +121,4 @@ def translate_to_function(
  original_type=function_def,
  chk=checker.chk,
  in_literal_context=checker.is_literal_context(),
- )
+ ))