Ensure that GenericCallable is generated if typevars are present. by dnwpark · Pull Request #91 · vercel/python-typemap

dnwpark · 2026-02-10T01:50:08Z

Currently, we don't properly generate GenericCallable if a typevar in the signature is from outside a class. For example:

T = TypeVar('T')
class C:
    @staticmethod
    def f(x: T) -> T: ...

Previously, C.f would be typed as Callable[Param[Literal["x"], T], T] while it should correctly be typed something like GenericCallable[tuple[T], lambda T: Callable[Param[Literal["x"], T], T].

vercel · 2026-02-10T01:50:14Z

The latest updates on your projects. Learn more about Vercel for GitHub.

Project	Deployment	Actions	Updated (UTC)
python-typemap	Ready	Preview, Comment	Feb 12, 2026 5:30pm

msullivan · 2026-02-11T18:18:15Z

tests/test_type_dir.py

            ordinary: str
            def foo(self: Self, a: int | None, *, b: int = ...) -> dict[str, int]: ...
-            def base[Z](self: Self, a: int | Z | None, b: ~K) -> dict[str, int | Z]: ...
+            def base[Z, K](self: Self, a: int | Z | None, b: ~K) -> dict[str, int | Z]: ...


Maybe we should take that K out of Final. It doesn't really make sense.

other than the wacky formatting (K vs ~K), what would you expect this to look like?

msullivan · 2026-02-11T18:21:42Z

tests/test_type_eval.py

+        def member_method(
+            self, x: T
+        ) -> set[T] if IsAssignable[T, int] else T: ...


This case doesn't work in general, obviously, since one side could have a type var that the other doesn't.

We should at least document that somewhere.

I actually do have an insane plan that would allow solving this, involving repeatedly reexecuting the annotation with Bool et al rigged up to return different results, but Yury was horrified by the idea and we probably shouldn't do it.

Another wild approach would be to read the bytecode and look for all globals that might be read.

msullivan · 2026-02-11T18:24:24Z

typemap/type_eval/_apply_generic.py

+        # - pattern matched annotations: T | None, set[T], etc.
+        # - type vars in an expression: U if IsAssignable[T, int] else V


The first one we definitely need to handle, if we are handling any cases at all.

The second one we can hopefully ignore? At least, the solutions are all crazy.

msullivan · 2026-02-11T19:01:00Z

typemap/type_eval/_apply_generic.py

+                for tv in _find_annotation_type_vars(raw_args, rr, globs):
+                    if tv not in type_params:
+                        type_params.append(tv)
+                rr = _eval_raw_annotations(raw_args, rr, globs)


I don't think I understand the algorithm here. Is the split where we try _find_annotation_type_vars before _eval_raw_annotations being done just to support the case with an if or for?

If so I think maybe we should skip doing that and just try processing the result of _eval_raw_annotations, since we can't make for/if work without doing some horrible things in general...

The goal is to leave the bulk of the logic identical for get_annotations. At the same time, I break it into parts so that I am able to read the annotations that are used in intermediate computations. This is to find any type vars that were not declared by the function itself.

These new type vars are added to those declared by the function when generating the GenericCallable lambda.

This has nothing to do with for/if in particular.

OK, I guess the question here is (and I thought I half understood the answer): why can't we just call get_annotations and look for all the type variables in the result?

The short answer is that at this point in get_local_defns, we call get_annotations, which may return None if it gets stuck. In that situation, there is no result to look into.

It gets stuck because the externally defined type var doesn't get substituted anywhere and so results in the type var itself.

We want to detect all the type vars while also avoiding the stuck exception. Some ways I thought about doing this:

some sort of flag in the execution context that supresses stuck and then also store things in the context

a different type of execution context entirely

maybe looking at the annotate function globals

Ok also, we may or may not need to cover external type vars that are in if/for, but I was more thinking that if any annotation has if/for, then this will occur, even if the external type var is not in some complex expression

eg.

T = typevar("T") def f(self, x: T, y: int if IsAssignable[T,int] else str) -> T

msullivan · 2026-02-11T19:01:53Z

typemap/type_eval/_eval_operators.py

    return f


+def _find_function_type_vars(ty, *, seen=None):


This probably should recurse, right? Through all typealiases

Yes, but I wanted to keep this in sync with _eval_operators._collect_type_vars, which I didn't want to figure out yet.

dnwpark requested a review from msullivan February 10, 2026 01:50

dnwpark changed the base branch from main to generic-callable February 10, 2026 01:50

msullivan force-pushed the generic-callable branch 2 times, most recently from f6745ce to a3cb55c Compare February 10, 2026 02:50

dnwpark force-pushed the external-typevar branch from b957edd to c6323c0 Compare February 10, 2026 16:32

vercel bot deployed to Preview February 10, 2026 16:33 View deployment

Base automatically changed from generic-callable to main February 10, 2026 21:47

dnwpark force-pushed the external-typevar branch from c6323c0 to 6988ccc Compare February 10, 2026 23:02

vercel bot deployed to Preview February 10, 2026 23:04 View deployment

msullivan reviewed Feb 11, 2026

View reviewed changes

dnwpark added 7 commits February 12, 2026 09:10

Expand existing tests.

8f59ebd

Add tests.

a91ae7c

Extract type vars that are from outside the function.

f192a99

Pass receiver type to generic lambda.

ea37123

Find extra type vars in function types.

50c1ad1

Fix existing tests.

233fbc3

Use __name__ in format_helper.

fcfe2c0

dnwpark force-pushed the external-typevar branch from 6988ccc to fcfe2c0 Compare February 12, 2026 17:28

vercel bot deployed to Preview February 12, 2026 17:30 View deployment

dnwpark closed this Feb 13, 2026

		# - pattern matched annotations: T \| None, set[T], etc.
		# - type vars in an expression: U if IsAssignable[T, int] else V

Conversation

dnwpark commented Feb 10, 2026

Uh oh!

vercel bot commented Feb 10, 2026 • edited Loading Uh oh! There was an error while loading. Please reload this page.

Uh oh!

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

dnwpark Feb 12, 2026 • edited Loading Uh oh! There was an error while loading. Please reload this page.

Uh oh!

Choose a reason for hiding this comment

Uh oh!

dnwpark Feb 12, 2026 • edited Loading Uh oh! There was an error while loading. Please reload this page.

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Reviewers

Assignees

Labels

Projects

Milestone

Development

Uh oh!

2 participants

vercel bot commented Feb 10, 2026 •

edited

Loading

dnwpark Feb 12, 2026 •

edited

Loading

dnwpark Feb 12, 2026 •

edited

Loading