Use the calling frame's name to produce a name for the NewProtocol

Author: msullivan

tests/test_call.py

@@ -17,8 +17,9 @@ def test_call_1():
     ret = eval_call(func, a=1, b=2, c="aaa")
     fmt = format_helper.format_class(ret)
 
+    # XXX: Do we like this name?
     assert fmt == textwrap.dedent("""\
-        class Protocol:
+        class __annotate__:
             a: int
             b: int
             c: int

tests/test_type_dir.py

@@ -81,11 +81,12 @@ def sbase[Z](cls, a: int | Literal['gotcha!'] | Z | None, b: ~K) -> dict[str, in
 def test_type_dir_2():
     d = eval_typing(OptionalFinal)
 
-    # XXX: the class should probably be named something like "AllOptional__T"
+    # XXX: should the class name be further mangled to something like
+    #      "AllOptional__T"?
     # XXX: `DirProperties` skips methods, true to its name. Perhaps we just need
     #      `Dir` that would iterate over everything
     assert format_helper.format_class(d) == textwrap.dedent("""\
-        class Protocol:
+        class AllOptional:
             last: int | typing.Literal[True] | None
             iii: str | int | typing.Literal['gotcha!'] | None
             t: dict[str, str | int | typing.Literal['gotcha!']] | None

tests/test_type_eval.py

@@ -52,11 +52,11 @@ def test_eval_types_2():
     assert evaled.__annotations__["a"].__args__[0] is evaled
 
     assert format_helper.format_class(evaled) == textwrap.dedent("""\
-        class Protocol:
+        class MapRecursive:
             n: int | typing.Literal['gotcha!']
             m: str | typing.Literal['gotcha!']
             t: typing.Literal[False] | typing.Literal['gotcha!']
-            a: abc.Protocol | typing.Literal['gotcha!']
+            a: tests.test_type_eval.MapRecursive | typing.Literal['gotcha!']
             fff: int | typing.Literal['gotcha!']
             control: float
         """)

typemap/typing.py

@@ -88,9 +88,24 @@ def __getitem__(cls, val: list[Property]):
         dct = {}
         dct["__annotations__"] = {prop.name: prop.type for prop in val}
 
+        frame = inspect.currentframe()
+
+        module_name = __name__
+        name = "Protocol"
+
+        # Peak at the calling frame and use that to produce
+        # a better name than Protocol.
+        # This is probably a 3.14 special?
+        if frame and (prev := frame.f_back):
+            name = prev.f_code.co_name
+            module_name = inspect.getmodule(prev.f_code).__name__
+            # qualname??
+
+        dct["__module__"] = module_name
+
         mcls = type(typing.Protocol)
-        # TODO: Replace the "Protocol" name with the type alias name
-        return mcls("Protocol", (typing.Protocol,), dct)
+        cls = mcls(name, (typing.Protocol,), dct)
+        return cls
 
 
 class NewProtocol(metaclass=NewProtocolMeta):