dry-python
diff --git a/Collapse file
‎classes/contrib/mypy/features/typeclass.py‎
Copy file name to clipboardExpand all lines: classes/contrib/mypy/features/typeclass.py
+5Lines changed: 5 additions & 0 deletions b/Collapse file
‎classes/contrib/mypy/features/typeclass.py‎
Copy file name to clipboardExpand all lines: classes/contrib/mypy/features/typeclass.py
+5Lines changed: 5 additions & 0 deletions
diff --git a/Collapse file
‎classes/contrib/mypy/typeops/fallback.py‎
Copy file name to clipboard
+31Lines changed: 31 additions & 0 deletions b/Collapse file
‎classes/contrib/mypy/typeops/fallback.py‎
Copy file name to clipboard
+31Lines changed: 31 additions & 0 deletions
diff --git a/Collapse file
‎typesafety/test_typeclass/test_typeclass.yml‎
Copy file name to clipboardExpand all lines: typesafety/test_typeclass/test_typeclass.yml
+20Lines changed: 20 additions & 0 deletions b/Collapse file
‎typesafety/test_typeclass/test_typeclass.yml‎
Copy file name to clipboardExpand all lines: typesafety/test_typeclass/test_typeclass.yml
+20Lines changed: 20 additions & 0 deletions
@@ -16,6 +16,7 @@
 
 from classes.contrib.mypy.typeops import (
     call_signatures,
+    fallback,
     instance_args,
     mro,
     type_loader,
@@ -154,6 +155,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',
+    })
     def __call__(self, ctx: MethodContext) -> MypyType:
         """Main entry point."""
         assert isinstance(ctx.type, Instance)
 
@@ -0,0 +1,31 @@
+from typing import Any, Callable, Mapping, Type
+
+from mypy.plugin import MethodContext
+from mypy.types import AnyType
+from mypy.types import Type as MypyType
+from mypy.types import TypeOfAny
+
+_MethodCallback = Callable[[Any, MethodContext], MypyType]  # type: ignore
+
+
+def error_to_any(
+    error_map: Mapping[Type[Exception], str],
+) -> Callable[[_MethodCallback], _MethodCallback]:
+    """
+    Decorator for ``mypy`` callbacks to catch given errors.
+
+    We use to show custom messages for given exceptions.
+    If other exceptions are present, then we show just an error message.
+    """
+    def decorator(func: _MethodCallback) -> _MethodCallback:
+        def factory(self, ctx: MethodContext) -> MypyType:
+            try:
+                return func(self, ctx)
+            except Exception as ex:
+                ctx.api.fail(
+                    error_map.get(type(ex), str(ex)),
+                    ctx.context,
+                )
+                return AnyType(TypeOfAny.from_error)
+        return factory
+    return decorator
@@ -66,3 +66,23 @@
     main:3: note:     def [_AssociatedType] typeclass(definition: Type[_AssociatedType]) -> _TypeClassDef[_AssociatedType]
     main:3: note:     def [_SignatureType, _InstanceType, _AssociatedType, _Fullname <: str] typeclass(signature: _SignatureType) -> _TypeClass[_InstanceType, _SignatureType, _AssociatedType, _Fullname]
     main:3: note: Possible overload variants:
+
+
+- case: typeclass_non_global_declaration
+  disable_cache: false
+  main: |
+    from classes import typeclass
+
+    def some():
+        @typeclass
+        def a(instance) -> str:
+            ...
+
+        @a.instance(int)
+        def _a_int(instance: int) -> str:
+            ...
+
+        reveal_type(_a_int)
+  out: |
+    main:8: error: Typeclass cannot be loaded, it must be a global declaration
+    main:12: note: Revealed type is "Any"