Move function type construction to get_local_defns.

Author: dnwpark

typemap/type_eval/_apply_generic.py

@@ -15,6 +15,7 @@
 
 if typing.TYPE_CHECKING:
     from typing import Any, Mapping
+    from typemap.typing import GenericCallable, Overloaded
 
 
 @dataclasses.dataclass(frozen=True)
@@ -324,10 +325,18 @@ def get_local_defns(
 ) -> tuple[
     dict[str, Any],
     dict[
-        str, types.FunctionType | classmethod | staticmethod | WrappedOverloads
+        str,
+        type[
+            typing.Callable
+            | classmethod
+            | staticmethod
+            | GenericCallable
+            | Overloaded
+        ],
     ],
 ]:
-    from typemap.typing import GenericCallable
+    from typemap.typing import GenericCallable, Overloaded
+    from ._eval_operators import _function_type
 
     annos: dict[str, Any] = {}
     dct: dict[str, Any] = {}
@@ -339,6 +348,9 @@ def get_local_defns(
         if name in EXCLUDED_ATTRIBUTES:
             continue
 
+        if orig is typing._no_init_or_replace_init:  # type: ignore[attr-defined]
+            continue
+
         stuff = inspect.unwrap(orig)
 
         if isinstance(stuff, types.FunctionType):
@@ -405,7 +417,36 @@ def lam(*vs):
                 elif orig.__class__ is staticmethod:
                     local_fn = staticmethod(local_fn)
 
-                dct[name] = local_fn
+                if isinstance(
+                    local_fn,
+                    (
+                        types.FunctionType,
+                        types.MethodType,
+                        staticmethod,
+                        classmethod,
+                    ),
+                ):
+                    dct[name] = _function_type(
+                        local_fn, receiver_type=boxed.alias_type()
+                    )
+
+                elif isinstance(local_fn, WrappedOverloads):
+                    overload_types: typing.Sequence[
+                        type[
+                            typing.Callable
+                            | classmethod
+                            | staticmethod
+                            | GenericCallable
+                        ]
+                    ] = [
+                        _function_type(
+                            _eval_typing.eval_typing(of),
+                            receiver_type=boxed.alias_type(),
+                        )
+                        for of in local_fn.functions
+                    ]
+
+                    dct[name] = Overloaded[*overload_types]  # type: ignore[valid-type]
 
     return annos, dct
 

typemap/type_eval/_eval_operators.py

@@ -41,7 +41,6 @@
     Member,
     Members,
     NewProtocol,
-    Overloaded,
     Param,
     RaiseError,
     Slice,
@@ -154,35 +153,12 @@ def get_annotated_method_hints(cls, *, ctx):
 
         _, dct = _apply_generic.get_local_defns(abox)
         for name, attr in dct.items():
-            if isinstance(
+            hints[name] = (
                 attr,
-                (
-                    types.FunctionType,
-                    types.MethodType,
-                    staticmethod,
-                    classmethod,
-                ),
-            ):
-                if attr is typing._no_init_or_replace_init:
-                    continue
-
-                hints[name] = (
-                    _function_type(attr, receiver_type=acls),
-                    ("ClassVar",),
-                    object,
-                    acls,
-                )
-            elif isinstance(attr, _apply_generic.WrappedOverloads):
-                overloads = [
-                    _function_type(_eval_types(of, ctx), receiver_type=acls)
-                    for of in attr.functions
-                ]
-                hints[name] = (
-                    Overloaded[*overloads],
-                    ("ClassVar",),
-                    object,
-                    acls,
-                )
+                ("ClassVar",),
+                object,
+                acls,
+            )
 
     return hints
 
@@ -763,7 +739,9 @@ def _ann(x):
     return f
 
 
-def _function_type(func, *, receiver_type):
+def _function_type(
+    func, *, receiver_type
+) -> type[typing.Callable | classmethod | staticmethod | GenericCallable]:
     root = inspect.unwrap(func)
     sig = inspect.signature(root)
     f = _function_type_from_sig(sig, func, receiver_type=receiver_type)
@@ -772,7 +750,7 @@ def _function_type(func, *, receiver_type):
         # Must store a lambda that performs type variable substitution
         type_params = root.__type_params__
         callable_lambda = _create_generic_callable_lambda(f, type_params)
-        f = GenericCallable[tuple[*type_params], callable_lambda]
+        f = GenericCallable[tuple[*type_params], callable_lambda]  # type: ignore[misc,valid-type]
     return f