Debian Codegraph @

Lib/test/test_type_params.py

raw
1 import annotationlib
2 import textwrap
3 import types
4 import unittest
5 import pickle
6 import weakref
7 from test.support import check_syntax_error, run_code, run_no_yield_async_fn
8
9 from typing import Generic, NoDefault, Sequence, TypeAliasType, TypeVar, TypeVarTuple, ParamSpec, get_args
10
11
12 class TypeParamsInvalidTest(unittest.TestCase):
13 def test_name_collisions(self):
14 check_syntax_error(self, 'def func[**A, A](): ...', "duplicate type parameter 'A'")
15 check_syntax_error(self, 'def func[A, *A](): ...', "duplicate type parameter 'A'")
16 check_syntax_error(self, 'def func[*A, **A](): ...', "duplicate type parameter 'A'")
17
18 check_syntax_error(self, 'class C[**A, A](): ...', "duplicate type parameter 'A'")
19 check_syntax_error(self, 'class C[A, *A](): ...', "duplicate type parameter 'A'")
20 check_syntax_error(self, 'class C[*A, **A](): ...', "duplicate type parameter 'A'")
21
22 def test_name_non_collision_02(self):
23 ns = run_code("""def func[A](A): return A""")
24 func = ns["func"]
25 self.assertEqual(func(1), 1)
26 A, = func.__type_params__
27 self.assertEqual(A.__name__, "A")
28
29 def test_name_non_collision_03(self):
30 ns = run_code("""def func[A](*A): return A""")
31 func = ns["func"]
32 self.assertEqual(func(1), (1,))
33 A, = func.__type_params__
34 self.assertEqual(A.__name__, "A")
35
36 def test_name_non_collision_04(self):
37 # Mangled names should not cause a conflict.
38 ns = run_code("""
39 class ClassA:
40 def func[__A](self, __A): return __A
41 """
42 )
43 cls = ns["ClassA"]
44 self.assertEqual(cls().func(1), 1)
45 A, = cls.func.__type_params__
46 self.assertEqual(A.__name__, "__A")
47
48 def test_name_non_collision_05(self):
49 ns = run_code("""
50 class ClassA:
51 def func[_ClassA__A](self, __A): return __A
52 """
53 )
54 cls = ns["ClassA"]
55 self.assertEqual(cls().func(1), 1)
56 A, = cls.func.__type_params__
57 self.assertEqual(A.__name__, "_ClassA__A")
58
59 def test_name_non_collision_06(self):
60 ns = run_code("""
61 class ClassA[X]:
62 def func(self, X): return X
63 """
64 )
65 cls = ns["ClassA"]
66 self.assertEqual(cls().func(1), 1)
67 X, = cls.__type_params__
68 self.assertEqual(X.__name__, "X")
69
70 def test_name_non_collision_07(self):
71 ns = run_code("""
72 class ClassA[X]:
73 def func(self):
74 X = 1
75 return X
76 """
77 )
78 cls = ns["ClassA"]
79 self.assertEqual(cls().func(), 1)
80 X, = cls.__type_params__
81 self.assertEqual(X.__name__, "X")
82
83 def test_name_non_collision_08(self):
84 ns = run_code("""
85 class ClassA[X]:
86 def func(self):
87 return [X for X in [1, 2]]
88 """
89 )
90 cls = ns["ClassA"]
91 self.assertEqual(cls().func(), [1, 2])
92 X, = cls.__type_params__
93 self.assertEqual(X.__name__, "X")
94
95 def test_name_non_collision_9(self):
96 ns = run_code("""
97 class ClassA[X]:
98 def func[X](self):
99 ...
100 """
101 )
102 cls = ns["ClassA"]
103 outer_X, = cls.__type_params__
104 inner_X, = cls.func.__type_params__
105 self.assertEqual(outer_X.__name__, "X")
106 self.assertEqual(inner_X.__name__, "X")
107 self.assertIsNot(outer_X, inner_X)
108
109 def test_name_non_collision_10(self):
110 ns = run_code("""
111 class ClassA[X]:
112 X: int
113 """
114 )
115 cls = ns["ClassA"]
116 X, = cls.__type_params__
117 self.assertEqual(X.__name__, "X")
118 self.assertIs(cls.__annotations__["X"], int)
119
120 def test_name_non_collision_13(self):
121 ns = run_code("""
122 X = 1
123 def outer():
124 def inner[X]():
125 global X
126 X = 2
127 return inner
128 """
129 )
130 self.assertEqual(ns["X"], 1)
131 outer = ns["outer"]
132 outer()()
133 self.assertEqual(ns["X"], 2)
134
135 def test_disallowed_expressions(self):
136 check_syntax_error(self, "type X = (yield)")
137 check_syntax_error(self, "type X = (yield from x)")
138 check_syntax_error(self, "type X = (await 42)")
139 check_syntax_error(self, "async def f(): type X = (yield)")
140 check_syntax_error(self, "type X = (y := 3)")
141 check_syntax_error(self, "class X[T: (yield)]: pass")
142 check_syntax_error(self, "class X[T: (yield from x)]: pass")
143 check_syntax_error(self, "class X[T: (await 42)]: pass")
144 check_syntax_error(self, "class X[T: (y := 3)]: pass")
145 check_syntax_error(self, "class X[T](y := Sequence[T]): pass")
146 check_syntax_error(self, "def f[T](y: (x := Sequence[T])): pass")
147 check_syntax_error(self, "class X[T]([(x := 3) for _ in range(2)] and B): pass")
148 check_syntax_error(self, "def f[T: [(x := 3) for _ in range(2)]](): pass")
149 check_syntax_error(self, "type T = [(x := 3) for _ in range(2)]")
150
151 def test_incorrect_mro_explicit_object(self):
152 with self.assertRaisesRegex(TypeError, r"\(MRO\) for bases object, Generic"):
153 class My[X](object): ...
154
155 def test_compile_error_in_type_param_bound(self):
156 # This should not crash, see gh-145187
157 check_syntax_error(
158 self,
159 "if True:\n class h[l:{7for*()in 0}]:2"
160 )
161
162
163 class TypeParamsNonlocalTest(unittest.TestCase):
164 def test_nonlocal_disallowed_01(self):
165 code = """
166 def outer():
167 X = 1
168 def inner[X]():
169 nonlocal X
170 return X
171 """
172 check_syntax_error(self, code)
173
174 def test_nonlocal_disallowed_02(self):
175 code = """
176 def outer2[T]():
177 def inner1():
178 nonlocal T
179 """
180 check_syntax_error(self, textwrap.dedent(code))
181
182 def test_nonlocal_disallowed_03(self):
183 code = """
184 class Cls[T]:
185 nonlocal T
186 """
187 check_syntax_error(self, textwrap.dedent(code))
188
189 def test_nonlocal_allowed(self):
190 code = """
191 def func[T]():
192 T = "func"
193 def inner():
194 nonlocal T
195 T = "inner"
196 inner()
197 assert T == "inner"
198 """
199 ns = run_code(code)
200 func = ns["func"]
201 T, = func.__type_params__
202 self.assertEqual(T.__name__, "T")
203
204
205 class TypeParamsAccessTest(unittest.TestCase):
206 def test_class_access_01(self):
207 ns = run_code("""
208 class ClassA[A, B](dict[A, B]):
209 ...
210 """
211 )
212 cls = ns["ClassA"]
213 A, B = cls.__type_params__
214 self.assertEqual(types.get_original_bases(cls), (dict[A, B], Generic[A, B]))
215
216 def test_class_access_02(self):
217 ns = run_code("""
218 class MyMeta[A, B](type): ...
219 class ClassA[A, B](metaclass=MyMeta[A, B]):
220 ...
221 """
222 )
223 meta = ns["MyMeta"]
224 cls = ns["ClassA"]
225 A1, B1 = meta.__type_params__
226 A2, B2 = cls.__type_params__
227 self.assertIsNot(A1, A2)
228 self.assertIsNot(B1, B2)
229 self.assertIs(type(cls), meta)
230
231 def test_class_access_03(self):
232 code = """
233 def my_decorator(a):
234 ...
235 @my_decorator(A)
236 class ClassA[A, B]():
237 ...
238 """
239
240 with self.assertRaisesRegex(NameError, "name 'A' is not defined"):
241 run_code(code)
242
243 def test_function_access_01(self):
244 ns = run_code("""
245 def func[A, B](a: dict[A, B]):
246 ...
247 """
248 )
249 func = ns["func"]
250 A, B = func.__type_params__
251 self.assertEqual(func.__annotations__["a"], dict[A, B])
252
253 def test_function_access_02(self):
254 code = """
255 def func[A](a = list[A]()):
256 ...
257 """
258
259 with self.assertRaisesRegex(NameError, "name 'A' is not defined"):
260 run_code(code)
261
262 def test_function_access_03(self):
263 code = """
264 def my_decorator(a):
265 ...
266 @my_decorator(A)
267 def func[A]():
268 ...
269 """
270
271 with self.assertRaisesRegex(NameError, "name 'A' is not defined"):
272 run_code(code)
273
274 def test_method_access_01(self):
275 ns = run_code("""
276 class ClassA:
277 x = int
278 def func[T](self, a: x, b: T):
279 ...
280 """
281 )
282 cls = ns["ClassA"]
283 self.assertIs(cls.func.__annotations__["a"], int)
284 T, = cls.func.__type_params__
285 self.assertIs(cls.func.__annotations__["b"], T)
286
287 def test_nested_access_01(self):
288 ns = run_code("""
289 class ClassA[A]:
290 def funcB[B](self):
291 class ClassC[C]:
292 def funcD[D](self):
293 return lambda: (A, B, C, D)
294 return ClassC
295 """
296 )
297 cls = ns["ClassA"]
298 A, = cls.__type_params__
299 B, = cls.funcB.__type_params__
300 classC = cls().funcB()
301 C, = classC.__type_params__
302 D, = classC.funcD.__type_params__
303 self.assertEqual(classC().funcD()(), (A, B, C, D))
304
305 def test_out_of_scope_01(self):
306 code = """
307 class ClassA[T]: ...
308 x = T
309 """
310
311 with self.assertRaisesRegex(NameError, "name 'T' is not defined"):
312 run_code(code)
313
314 def test_out_of_scope_02(self):
315 code = """
316 class ClassA[A]:
317 def funcB[B](self): ...
318
319 x = B
320 """
321
322 with self.assertRaisesRegex(NameError, "name 'B' is not defined"):
323 run_code(code)
324
325 def test_class_scope_interaction_01(self):
326 ns = run_code("""
327 class C:
328 x = 1
329 def method[T](self, arg: x): pass
330 """)
331 cls = ns["C"]
332 self.assertEqual(cls.method.__annotations__["arg"], 1)
333
334 def test_class_scope_interaction_02(self):
335 ns = run_code("""
336 class C:
337 class Base: pass
338 class Child[T](Base): pass
339 """)
340 cls = ns["C"]
341 self.assertEqual(cls.Child.__bases__, (cls.Base, Generic))
342 T, = cls.Child.__type_params__
343 self.assertEqual(types.get_original_bases(cls.Child), (cls.Base, Generic[T]))
344
345 def test_class_deref(self):
346 ns = run_code("""
347 class C[T]:
348 T = "class"
349 type Alias = T
350 """)
351 cls = ns["C"]
352 self.assertEqual(cls.Alias.__value__, "class")
353
354 def test_shadowing_nonlocal(self):
355 ns = run_code("""
356 def outer[T]():
357 T = "outer"
358 def inner():
359 nonlocal T
360 T = "inner"
361 return T
362 return lambda: T, inner
363 """)
364 outer = ns["outer"]
365 T, = outer.__type_params__
366 self.assertEqual(T.__name__, "T")
367 getter, inner = outer()
368 self.assertEqual(getter(), "outer")
369 self.assertEqual(inner(), "inner")
370 self.assertEqual(getter(), "inner")
371
372 def test_reference_previous_typevar(self):
373 def func[S, T: Sequence[S]]():
374 pass
375
376 S, T = func.__type_params__
377 self.assertEqual(T.__bound__, Sequence[S])
378
379 def test_super(self):
380 class Base:
381 def meth(self):
382 return "base"
383
384 class Child(Base):
385 # Having int in the annotation ensures the class gets cells for both
386 # __class__ and __classdict__
387 def meth[T](self, arg: int) -> T:
388 return super().meth() + "child"
389
390 c = Child()
391 self.assertEqual(c.meth(1), "basechild")
392
393 def test_type_alias_containing_lambda(self):
394 type Alias[T] = lambda: T
395 T, = Alias.__type_params__
396 self.assertIs(Alias.__value__(), T)
397
398 def test_class_base_containing_lambda(self):
399 # Test that scopes nested inside hidden functions work correctly
400 outer_var = "outer"
401 class Base[T]: ...
402 class Child[T](Base[lambda: (int, outer_var, T)]): ...
403 base, _ = types.get_original_bases(Child)
404 func, = get_args(base)
405 T, = Child.__type_params__
406 self.assertEqual(func(), (int, "outer", T))
407
408 def test_comprehension_01(self):
409 type Alias[T: ([T for T in (T, [1])[1]], T)] = [T for T in T.__name__]
410 self.assertEqual(Alias.__value__, ["T"])
411 T, = Alias.__type_params__
412 self.assertEqual(T.__constraints__, ([1], T))
413
414 def test_comprehension_02(self):
415 type Alias[T: [lambda: T for T in (T, [1])[1]]] = [lambda: T for T in T.__name__]
416 func, = Alias.__value__
417 self.assertEqual(func(), "T")
418 T, = Alias.__type_params__
419 func, = T.__bound__
420 self.assertEqual(func(), 1)
421
422 def test_comprehension_03(self):
423 def F[T: [lambda: T for T in (T, [1])[1]]](): return [lambda: T for T in T.__name__]
424 func, = F()
425 self.assertEqual(func(), "T")
426 T, = F.__type_params__
427 func, = T.__bound__
428 self.assertEqual(func(), 1)
429
430 def test_gen_exp_in_nested_class(self):
431 code = """
432 from test.test_type_params import make_base
433
434 class C[T]:
435 T = "class"
436 class Inner(make_base(T for _ in (1,)), make_base(T)):
437 pass
438 """
439 C = run_code(code)["C"]
440 T, = C.__type_params__
441 base1, base2 = C.Inner.__bases__
442 self.assertEqual(list(base1.__arg__), [T])
443 self.assertEqual(base2.__arg__, "class")
444
445 def test_gen_exp_in_nested_generic_class(self):
446 code = """
447 from test.test_type_params import make_base
448
449 class C[T]:
450 T = "class"
451 class Inner[U](make_base(T for _ in (1,)), make_base(T)):
452 pass
453 """
454 ns = run_code(code)
455 inner = ns["C"].Inner
456 base1, base2, _ = inner.__bases__
457 self.assertEqual(list(base1.__arg__), [ns["C"].__type_params__[0]])
458 self.assertEqual(base2.__arg__, "class")
459
460 def test_listcomp_in_nested_class(self):
461 code = """
462 from test.test_type_params import make_base
463
464 class C[T]:
465 T = "class"
466 class Inner(make_base([T for _ in (1,)]), make_base(T)):
467 pass
468 """
469 C = run_code(code)["C"]
470 T, = C.__type_params__
471 base1, base2 = C.Inner.__bases__
472 self.assertEqual(base1.__arg__, [T])
473 self.assertEqual(base2.__arg__, "class")
474
475 def test_listcomp_in_nested_generic_class(self):
476 code = """
477 from test.test_type_params import make_base
478
479 class C[T]:
480 T = "class"
481 class Inner[U](make_base([T for _ in (1,)]), make_base(T)):
482 pass
483 """
484 ns = run_code(code)
485 inner = ns["C"].Inner
486 base1, base2, _ = inner.__bases__
487 self.assertEqual(base1.__arg__, [ns["C"].__type_params__[0]])
488 self.assertEqual(base2.__arg__, "class")
489
490 def test_gen_exp_in_generic_method(self):
491 code = """
492 class C[T]:
493 T = "class"
494 def meth[U](x: (T for _ in (1,)), y: T):
495 pass
496 """
497 ns = run_code(code)
498 meth = ns["C"].meth
499 self.assertEqual(list(meth.__annotations__["x"]), [ns["C"].__type_params__[0]])
500 self.assertEqual(meth.__annotations__["y"], "class")
501
502 def test_nested_scope_in_generic_alias(self):
503 code = """
504 T = "global"
505 class C:
506 T = "class"
507 {}
508 """
509 cases = [
510 "type Alias[T] = (T for _ in (1,))",
511 "type Alias = (T for _ in (1,))",
512 "type Alias[T] = [T for _ in (1,)]",
513 "type Alias = [T for _ in (1,)]",
514 ]
515 for case in cases:
516 with self.subTest(case=case):
517 ns = run_code(code.format(case))
518 alias = ns["C"].Alias
519 value = list(alias.__value__)[0]
520 if alias.__type_params__:
521 self.assertIs(value, alias.__type_params__[0])
522 else:
523 self.assertEqual(value, "global")
524
525 def test_lambda_in_alias_in_class(self):
526 code = """
527 T = "global"
528 class C:
529 T = "class"
530 type Alias = lambda: T
531 """
532 C = run_code(code)["C"]
533 self.assertEqual(C.Alias.__value__(), "global")
534
535 def test_lambda_in_alias_in_generic_class(self):
536 code = """
537 class C[T]:
538 T = "class"
539 type Alias = lambda: T
540 """
541 C = run_code(code)["C"]
542 self.assertIs(C.Alias.__value__(), C.__type_params__[0])
543
544 def test_lambda_in_generic_alias_in_class(self):
545 # A lambda nested in the alias cannot see the class scope, but can see
546 # a surrounding annotation scope.
547 code = """
548 T = U = "global"
549 class C:
550 T = "class"
551 U = "class"
552 type Alias[T] = lambda: (T, U)
553 """
554 C = run_code(code)["C"]
555 T, U = C.Alias.__value__()
556 self.assertIs(T, C.Alias.__type_params__[0])
557 self.assertEqual(U, "global")
558
559 def test_lambda_in_generic_alias_in_generic_class(self):
560 # A lambda nested in the alias cannot see the class scope, but can see
561 # a surrounding annotation scope.
562 code = """
563 class C[T, U]:
564 T = "class"
565 U = "class"
566 type Alias[T] = lambda: (T, U)
567 """
568 C = run_code(code)["C"]
569 T, U = C.Alias.__value__()
570 self.assertIs(T, C.Alias.__type_params__[0])
571 self.assertIs(U, C.__type_params__[1])
572
573 def test_type_special_case(self):
574 # https://github.com/python/cpython/issues/119011
575 self.assertEqual(type.__type_params__, ())
576 self.assertEqual(object.__type_params__, ())
577
578
579 def make_base(arg):
580 class Base:
581 __arg__ = arg
582 return Base
583
584
585 def global_generic_func[T]():
586 pass
587
588 class GlobalGenericClass[T]:
589 pass
590
591
592 class TypeParamsLazyEvaluationTest(unittest.TestCase):
593 def test_qualname(self):
594 class Foo[T]:
595 pass
596
597 def func[T]():
598 pass
599
600 self.assertEqual(Foo.__qualname__, "TypeParamsLazyEvaluationTest.test_qualname.<locals>.Foo")
601 self.assertEqual(func.__qualname__, "TypeParamsLazyEvaluationTest.test_qualname.<locals>.func")
602 self.assertEqual(global_generic_func.__qualname__, "global_generic_func")
603 self.assertEqual(GlobalGenericClass.__qualname__, "GlobalGenericClass")
604
605 def test_recursive_class(self):
606 class Foo[T: Foo, U: (Foo, Foo)]:
607 pass
608
609 type_params = Foo.__type_params__
610 self.assertEqual(len(type_params), 2)
611 self.assertEqual(type_params[0].__name__, "T")
612 self.assertIs(type_params[0].__bound__, Foo)
613 self.assertEqual(type_params[0].__constraints__, ())
614 self.assertIs(type_params[0].__default__, NoDefault)
615
616 self.assertEqual(type_params[1].__name__, "U")
617 self.assertIs(type_params[1].__bound__, None)
618 self.assertEqual(type_params[1].__constraints__, (Foo, Foo))
619 self.assertIs(type_params[1].__default__, NoDefault)
620
621 def test_evaluation_error(self):
622 class Foo[T: Undefined, U: (Undefined,)]:
623 pass
624
625 type_params = Foo.__type_params__
626 with self.assertRaises(NameError):
627 type_params[0].__bound__
628 self.assertEqual(type_params[0].__constraints__, ())
629 self.assertIs(type_params[1].__bound__, None)
630 self.assertIs(type_params[0].__default__, NoDefault)
631 self.assertIs(type_params[1].__default__, NoDefault)
632 with self.assertRaises(NameError):
633 type_params[1].__constraints__
634
635 Undefined = "defined"
636 self.assertEqual(type_params[0].__bound__, "defined")
637 self.assertEqual(type_params[0].__constraints__, ())
638
639 self.assertIs(type_params[1].__bound__, None)
640 self.assertEqual(type_params[1].__constraints__, ("defined",))
641
642
643 class TypeParamsClassScopeTest(unittest.TestCase):
644 def test_alias(self):
645 class X:
646 T = int
647 type U = T
648 self.assertIs(X.U.__value__, int)
649
650 ns = run_code("""
651 glb = "global"
652 class X:
653 cls = "class"
654 type U = (glb, cls)
655 """)
656 cls = ns["X"]
657 self.assertEqual(cls.U.__value__, ("global", "class"))
658
659 def test_bound(self):
660 class X:
661 T = int
662 def foo[U: T](self): ...
663 self.assertIs(X.foo.__type_params__[0].__bound__, int)
664
665 ns = run_code("""
666 glb = "global"
667 class X:
668 cls = "class"
669 def foo[T: glb, U: cls](self): ...
670 """)
671 cls = ns["X"]
672 T, U = cls.foo.__type_params__
673 self.assertEqual(T.__bound__, "global")
674 self.assertEqual(U.__bound__, "class")
675
676 def test_modified_later(self):
677 class X:
678 T = int
679 def foo[U: T](self): ...
680 type Alias = T
681 X.T = float
682 self.assertIs(X.foo.__type_params__[0].__bound__, float)
683 self.assertIs(X.Alias.__value__, float)
684
685 def test_binding_uses_global(self):
686 ns = run_code("""
687 x = "global"
688 def outer():
689 x = "nonlocal"
690 class Cls:
691 type Alias = x
692 val = Alias.__value__
693 def meth[T: x](self, arg: x): ...
694 bound = meth.__type_params__[0].__bound__
695 annotation = meth.__annotations__["arg"]
696 x = "class"
697 return Cls
698 """)
699 cls = ns["outer"]()
700 self.assertEqual(cls.val, "global")
701 self.assertEqual(cls.bound, "global")
702 self.assertEqual(cls.annotation, "global")
703
704 def test_no_binding_uses_nonlocal(self):
705 ns = run_code("""
706 x = "global"
707 def outer():
708 x = "nonlocal"
709 class Cls:
710 type Alias = x
711 val = Alias.__value__
712 def meth[T: x](self, arg: x): ...
713 bound = meth.__type_params__[0].__bound__
714 return Cls
715 """)
716 cls = ns["outer"]()
717 self.assertEqual(cls.val, "nonlocal")
718 self.assertEqual(cls.bound, "nonlocal")
719 self.assertEqual(cls.meth.__annotations__["arg"], "nonlocal")
720
721 def test_explicit_global(self):
722 ns = run_code("""
723 x = "global"
724 def outer():
725 x = "nonlocal"
726 class Cls:
727 global x
728 type Alias = x
729 Cls.x = "class"
730 return Cls
731 """)
732 cls = ns["outer"]()
733 self.assertEqual(cls.Alias.__value__, "global")
734
735 def test_explicit_global_with_no_static_bound(self):
736 ns = run_code("""
737 def outer():
738 class Cls:
739 global x
740 type Alias = x
741 Cls.x = "class"
742 return Cls
743 """)
744 ns["x"] = "global"
745 cls = ns["outer"]()
746 self.assertEqual(cls.Alias.__value__, "global")
747
748 def test_explicit_global_with_assignment(self):
749 ns = run_code("""
750 x = "global"
751 def outer():
752 x = "nonlocal"
753 class Cls:
754 global x
755 type Alias = x
756 x = "global from class"
757 Cls.x = "class"
758 return Cls
759 """)
760 cls = ns["outer"]()
761 self.assertEqual(cls.Alias.__value__, "global from class")
762
763 def test_explicit_nonlocal(self):
764 ns = run_code("""
765 x = "global"
766 def outer():
767 x = "nonlocal"
768 class Cls:
769 nonlocal x
770 type Alias = x
771 x = "class"
772 return Cls
773 """)
774 cls = ns["outer"]()
775 self.assertEqual(cls.Alias.__value__, "class")
776
777 def test_nested_free(self):
778 ns = run_code("""
779 def f():
780 T = str
781 class C:
782 T = int
783 class D[U](T):
784 x = T
785 return C
786 """)
787 C = ns["f"]()
788 self.assertIn(int, C.D.__bases__)
789 self.assertIs(C.D.x, str)
790
791
792 class DynamicClassTest(unittest.TestCase):
793 def _set_type_params(self, ns, params):
794 ns['__type_params__'] = params
795
796 def test_types_new_class_with_callback(self):
797 T = TypeVar('T', infer_variance=True)
798 Klass = types.new_class('Klass', (Generic[T],), {},
799 lambda ns: self._set_type_params(ns, (T,)))
800
801 self.assertEqual(Klass.__bases__, (Generic,))
802 self.assertEqual(Klass.__orig_bases__, (Generic[T],))
803 self.assertEqual(Klass.__type_params__, (T,))
804 self.assertEqual(Klass.__parameters__, (T,))
805
806 def test_types_new_class_no_callback(self):
807 T = TypeVar('T', infer_variance=True)
808 Klass = types.new_class('Klass', (Generic[T],), {})
809
810 self.assertEqual(Klass.__bases__, (Generic,))
811 self.assertEqual(Klass.__orig_bases__, (Generic[T],))
812 self.assertEqual(Klass.__type_params__, ()) # must be explicitly set
813 self.assertEqual(Klass.__parameters__, (T,))
814
815
816 class TypeParamsManglingTest(unittest.TestCase):
817 def test_mangling(self):
818 class Foo[__T]:
819 param = __T
820 def meth[__U](self, arg: __T, arg2: __U):
821 return (__T, __U)
822 type Alias[__V] = (__T, __V)
823
824 T = Foo.__type_params__[0]
825 self.assertEqual(T.__name__, "__T")
826 U = Foo.meth.__type_params__[0]
827 self.assertEqual(U.__name__, "__U")
828 V = Foo.Alias.__type_params__[0]
829 self.assertEqual(V.__name__, "__V")
830
831 anno = Foo.meth.__annotations__
832 self.assertIs(anno["arg"], T)
833 self.assertIs(anno["arg2"], U)
834 self.assertEqual(Foo().meth(1, 2), (T, U))
835
836 self.assertEqual(Foo.Alias.__value__, (T, V))
837
838 def test_no_leaky_mangling_in_module(self):
839 ns = run_code("""
840 __before = "before"
841 class X[T]: pass
842 __after = "after"
843 """)
844 self.assertEqual(ns["__before"], "before")
845 self.assertEqual(ns["__after"], "after")
846
847 def test_no_leaky_mangling_in_function(self):
848 ns = run_code("""
849 def f():
850 class X[T]: pass
851 _X_foo = 2
852 __foo = 1
853 assert locals()['__foo'] == 1
854 return __foo
855 """)
856 self.assertEqual(ns["f"](), 1)
857
858 def test_no_leaky_mangling_in_class(self):
859 ns = run_code("""
860 class Outer:
861 __before = "before"
862 class Inner[T]:
863 __x = "inner"
864 __after = "after"
865 """)
866 Outer = ns["Outer"]
867 self.assertEqual(Outer._Outer__before, "before")
868 self.assertEqual(Outer.Inner._Inner__x, "inner")
869 self.assertEqual(Outer._Outer__after, "after")
870
871 def test_no_mangling_in_bases(self):
872 ns = run_code("""
873 class __Base:
874 def __init_subclass__(self, **kwargs):
875 self.kwargs = kwargs
876
877 class Derived[T](__Base, __kwarg=1):
878 pass
879 """)
880 Derived = ns["Derived"]
881 self.assertEqual(Derived.__bases__, (ns["__Base"], Generic))
882 self.assertEqual(Derived.kwargs, {"__kwarg": 1})
883
884 def test_no_mangling_in_nested_scopes(self):
885 ns = run_code("""
886 from test.test_type_params import make_base
887
888 class __X:
889 pass
890
891 class Y[T: __X](
892 make_base(lambda: __X),
893 # doubly nested scope
894 make_base(lambda: (lambda: __X)),
895 # list comprehension
896 make_base([__X for _ in (1,)]),
897 # genexp
898 make_base(__X for _ in (1,)),
899 ):
900 pass
901 """)
902 Y = ns["Y"]
903 T, = Y.__type_params__
904 self.assertIs(T.__bound__, ns["__X"])
905 base0 = Y.__bases__[0]
906 self.assertIs(base0.__arg__(), ns["__X"])
907 base1 = Y.__bases__[1]
908 self.assertIs(base1.__arg__()(), ns["__X"])
909 base2 = Y.__bases__[2]
910 self.assertEqual(base2.__arg__, [ns["__X"]])
911 base3 = Y.__bases__[3]
912 self.assertEqual(list(base3.__arg__), [ns["__X"]])
913
914 def test_type_params_are_mangled(self):
915 ns = run_code("""
916 from test.test_type_params import make_base
917
918 class Foo[__T, __U: __T](make_base(__T), make_base(lambda: __T)):
919 param = __T
920 """)
921 Foo = ns["Foo"]
922 T, U = Foo.__type_params__
923 self.assertEqual(T.__name__, "__T")
924 self.assertEqual(U.__name__, "__U")
925 self.assertIs(U.__bound__, T)
926 self.assertIs(Foo.param, T)
927
928 base1, base2, *_ = Foo.__bases__
929 self.assertIs(base1.__arg__, T)
930 self.assertIs(base2.__arg__(), T)
931
932
933 class TypeParamsComplexCallsTest(unittest.TestCase):
934 def test_defaults(self):
935 # Generic functions with both defaults and kwdefaults trigger a specific code path
936 # in the compiler.
937 def func[T](a: T = "a", *, b: T = "b"):
938 return (a, b)
939
940 T, = func.__type_params__
941 self.assertIs(func.__annotations__["a"], T)
942 self.assertIs(func.__annotations__["b"], T)
943 self.assertEqual(func(), ("a", "b"))
944 self.assertEqual(func(1), (1, "b"))
945 self.assertEqual(func(b=2), ("a", 2))
946
947 def test_complex_base(self):
948 class Base:
949 def __init_subclass__(cls, **kwargs) -> None:
950 cls.kwargs = kwargs
951
952 kwargs = {"c": 3}
953 # Base classes with **kwargs trigger a different code path in the compiler.
954 class C[T](Base, a=1, b=2, **kwargs):
955 pass
956
957 T, = C.__type_params__
958 self.assertEqual(T.__name__, "T")
959 self.assertEqual(C.kwargs, {"a": 1, "b": 2, "c": 3})
960 self.assertEqual(C.__bases__, (Base, Generic))
961
962 bases = (Base,)
963 class C2[T](*bases, **kwargs):
964 pass
965
966 T, = C2.__type_params__
967 self.assertEqual(T.__name__, "T")
968 self.assertEqual(C2.kwargs, {"c": 3})
969 self.assertEqual(C2.__bases__, (Base, Generic))
970
971 def test_starargs_base(self):
972 class C1[T](*()): pass
973
974 T, = C1.__type_params__
975 self.assertEqual(T.__name__, "T")
976 self.assertEqual(C1.__bases__, (Generic,))
977
978 class Base: pass
979 bases = [Base]
980 class C2[T](*bases): pass
981
982 T, = C2.__type_params__
983 self.assertEqual(T.__name__, "T")
984 self.assertEqual(C2.__bases__, (Base, Generic))
985
986
987 class TypeParamsTraditionalTypeVarsTest(unittest.TestCase):
988 def test_traditional_01(self):
989 code = """
990 from typing import Generic
991 class ClassA[T](Generic[T]): ...
992 """
993
994 with self.assertRaisesRegex(TypeError, r"Cannot inherit from Generic\[...\] multiple times."):
995 run_code(code)
996
997 def test_traditional_02(self):
998 from typing import TypeVar
999 S = TypeVar("S")
1000 with self.assertRaises(TypeError):
1001 class ClassA[T](dict[T, S]): ...
1002
1003 def test_traditional_03(self):
1004 # This does not generate a runtime error, but it should be
1005 # flagged as an error by type checkers.
1006 from typing import TypeVar
1007 S = TypeVar("S")
1008 def func[T](a: T, b: S) -> T | S:
1009 return a
1010
1011
1012 class TypeParamsTypeVarTest(unittest.TestCase):
1013 def test_typevar_01(self):
1014 def func1[A: str, B: str | int, C: (int, str)]():
1015 return (A, B, C)
1016
1017 a, b, c = func1()
1018
1019 self.assertIsInstance(a, TypeVar)
1020 self.assertEqual(a.__bound__, str)
1021 self.assertTrue(a.__infer_variance__)
1022 self.assertFalse(a.__covariant__)
1023 self.assertFalse(a.__contravariant__)
1024
1025 self.assertIsInstance(b, TypeVar)
1026 self.assertEqual(b.__bound__, str | int)
1027 self.assertTrue(b.__infer_variance__)
1028 self.assertFalse(b.__covariant__)
1029 self.assertFalse(b.__contravariant__)
1030
1031 self.assertIsInstance(c, TypeVar)
1032 self.assertEqual(c.__bound__, None)
1033 self.assertEqual(c.__constraints__, (int, str))
1034 self.assertTrue(c.__infer_variance__)
1035 self.assertFalse(c.__covariant__)
1036 self.assertFalse(c.__contravariant__)
1037
1038 def test_typevar_generator(self):
1039 def get_generator[A]():
1040 def generator1[C]():
1041 yield C
1042
1043 def generator2[B]():
1044 yield A
1045 yield B
1046 yield from generator1()
1047 return generator2
1048
1049 gen = get_generator()
1050
1051 a, b, c = [x for x in gen()]
1052
1053 self.assertIsInstance(a, TypeVar)
1054 self.assertEqual(a.__name__, "A")
1055 self.assertIsInstance(b, TypeVar)
1056 self.assertEqual(b.__name__, "B")
1057 self.assertIsInstance(c, TypeVar)
1058 self.assertEqual(c.__name__, "C")
1059
1060 def test_typevar_coroutine(self):
1061 def get_coroutine[A]():
1062 async def coroutine[B]():
1063 return (A, B)
1064 return coroutine
1065
1066 co = get_coroutine()
1067
1068 a, b = run_no_yield_async_fn(co)
1069
1070 self.assertIsInstance(a, TypeVar)
1071 self.assertEqual(a.__name__, "A")
1072 self.assertIsInstance(b, TypeVar)
1073 self.assertEqual(b.__name__, "B")
1074
1075
1076 class TypeParamsTypeVarTupleTest(unittest.TestCase):
1077 def test_typevartuple_01(self):
1078 code = """def func1[*A: str](): pass"""
1079 check_syntax_error(self, code, "cannot use bound with TypeVarTuple")
1080 code = """def func1[*A: (int, str)](): pass"""
1081 check_syntax_error(self, code, "cannot use constraints with TypeVarTuple")
1082 code = """class X[*A: str]: pass"""
1083 check_syntax_error(self, code, "cannot use bound with TypeVarTuple")
1084 code = """class X[*A: (int, str)]: pass"""
1085 check_syntax_error(self, code, "cannot use constraints with TypeVarTuple")
1086 code = """type X[*A: str] = int"""
1087 check_syntax_error(self, code, "cannot use bound with TypeVarTuple")
1088 code = """type X[*A: (int, str)] = int"""
1089 check_syntax_error(self, code, "cannot use constraints with TypeVarTuple")
1090
1091 def test_typevartuple_02(self):
1092 def func1[*A]():
1093 return A
1094
1095 a = func1()
1096 self.assertIsInstance(a, TypeVarTuple)
1097
1098
1099 class TypeParamsTypeVarParamSpecTest(unittest.TestCase):
1100 def test_paramspec_01(self):
1101 code = """def func1[**A: str](): pass"""
1102 check_syntax_error(self, code, "cannot use bound with ParamSpec")
1103 code = """def func1[**A: (int, str)](): pass"""
1104 check_syntax_error(self, code, "cannot use constraints with ParamSpec")
1105 code = """class X[**A: str]: pass"""
1106 check_syntax_error(self, code, "cannot use bound with ParamSpec")
1107 code = """class X[**A: (int, str)]: pass"""
1108 check_syntax_error(self, code, "cannot use constraints with ParamSpec")
1109 code = """type X[**A: str] = int"""
1110 check_syntax_error(self, code, "cannot use bound with ParamSpec")
1111 code = """type X[**A: (int, str)] = int"""
1112 check_syntax_error(self, code, "cannot use constraints with ParamSpec")
1113
1114 def test_paramspec_02(self):
1115 def func1[**A]():
1116 return A
1117
1118 a = func1()
1119 self.assertIsInstance(a, ParamSpec)
1120 self.assertTrue(a.__infer_variance__)
1121 self.assertFalse(a.__covariant__)
1122 self.assertFalse(a.__contravariant__)
1123
1124
1125 class TypeParamsTypeParamsDunder(unittest.TestCase):
1126 def test_typeparams_dunder_class_01(self):
1127 class Outer[A, B]:
1128 class Inner[C, D]:
1129 @staticmethod
1130 def get_typeparams():
1131 return A, B, C, D
1132
1133 a, b, c, d = Outer.Inner.get_typeparams()
1134 self.assertEqual(Outer.__type_params__, (a, b))
1135 self.assertEqual(Outer.Inner.__type_params__, (c, d))
1136
1137 self.assertEqual(Outer.__parameters__, (a, b))
1138 self.assertEqual(Outer.Inner.__parameters__, (c, d))
1139
1140 def test_typeparams_dunder_class_02(self):
1141 class ClassA:
1142 pass
1143
1144 self.assertEqual(ClassA.__type_params__, ())
1145
1146 def test_typeparams_dunder_class_03(self):
1147 code = """
1148 class ClassA[A]():
1149 pass
1150 ClassA.__type_params__ = ()
1151 params = ClassA.__type_params__
1152 """
1153
1154 ns = run_code(code)
1155 self.assertEqual(ns["params"], ())
1156
1157 def test_typeparams_dunder_function_01(self):
1158 def outer[A, B]():
1159 def inner[C, D]():
1160 return A, B, C, D
1161
1162 return inner
1163
1164 inner = outer()
1165 a, b, c, d = inner()
1166 self.assertEqual(outer.__type_params__, (a, b))
1167 self.assertEqual(inner.__type_params__, (c, d))
1168
1169 def test_typeparams_dunder_function_02(self):
1170 def func1():
1171 pass
1172
1173 self.assertEqual(func1.__type_params__, ())
1174
1175 def test_typeparams_dunder_function_03(self):
1176 code = """
1177 def func[A]():
1178 pass
1179 func.__type_params__ = ()
1180 """
1181
1182 ns = run_code(code)
1183 self.assertEqual(ns["func"].__type_params__, ())
1184
1185
1186
1187 # All these type aliases are used for pickling tests:
1188 T = TypeVar('T')
1189 def func1[X](x: X) -> X: ...
1190 def func2[X, Y](x: X | Y) -> X | Y: ...
1191 def func3[X, *Y, **Z](x: X, y: tuple[*Y], z: Z) -> X: ...
1192 def func4[X: int, Y: (bytes, str)](x: X, y: Y) -> X | Y: ...
1193
1194 class Class1[X]: ...
1195 class Class2[X, Y]: ...
1196 class Class3[X, *Y, **Z]: ...
1197 class Class4[X: int, Y: (bytes, str)]: ...
1198
1199
1200 class TypeParamsPickleTest(unittest.TestCase):
1201 def test_pickling_functions(self):
1202 things_to_test = [
1203 func1,
1204 func2,
1205 func3,
1206 func4,
1207 ]
1208 for thing in things_to_test:
1209 for proto in range(pickle.HIGHEST_PROTOCOL + 1):
1210 with self.subTest(thing=thing, proto=proto):
1211 pickled = pickle.dumps(thing, protocol=proto)
1212 self.assertEqual(pickle.loads(pickled), thing)
1213
1214 def test_pickling_classes(self):
1215 things_to_test = [
1216 Class1,
1217 Class1[int],
1218 Class1[T],
1219
1220 Class2,
1221 Class2[int, T],
1222 Class2[T, int],
1223 Class2[int, str],
1224
1225 Class3,
1226 Class3[int, T, str, bytes, [float, object, T]],
1227
1228 Class4,
1229 Class4[int, bytes],
1230 Class4[T, bytes],
1231 Class4[int, T],
1232 Class4[T, T],
1233 ]
1234 for thing in things_to_test:
1235 for proto in range(pickle.HIGHEST_PROTOCOL + 1):
1236 with self.subTest(thing=thing, proto=proto):
1237 pickled = pickle.dumps(thing, protocol=proto)
1238 self.assertEqual(pickle.loads(pickled), thing)
1239
1240 for klass in things_to_test:
1241 real_class = getattr(klass, '__origin__', klass)
1242 thing = klass()
1243 for proto in range(pickle.HIGHEST_PROTOCOL + 1):
1244 with self.subTest(thing=thing, proto=proto):
1245 pickled = pickle.dumps(thing, protocol=proto)
1246 # These instances are not equal,
1247 # but class check is good enough:
1248 self.assertIsInstance(pickle.loads(pickled), real_class)
1249
1250
1251 class TypeParamsWeakRefTest(unittest.TestCase):
1252 def test_weakrefs(self):
1253 T = TypeVar('T')
1254 P = ParamSpec('P')
1255 class OldStyle(Generic[T]):
1256 pass
1257
1258 class NewStyle[T]:
1259 pass
1260
1261 cases = [
1262 T,
1263 TypeVar('T', bound=int),
1264 P,
1265 P.args,
1266 P.kwargs,
1267 TypeVarTuple('Ts'),
1268 OldStyle,
1269 OldStyle[int],
1270 OldStyle(),
1271 NewStyle,
1272 NewStyle[int],
1273 NewStyle(),
1274 Generic[T],
1275 ]
1276 for case in cases:
1277 with self.subTest(case=case):
1278 weakref.ref(case)
1279
1280
1281 class TypeParamsRuntimeTest(unittest.TestCase):
1282 def test_name_error(self):
1283 # gh-109118: This crashed the interpreter due to a refcounting bug
1284 code = """
1285 class name_2[name_5]:
1286 class name_4[name_5](name_0):
1287 pass
1288 """
1289 with self.assertRaises(NameError):
1290 run_code(code)
1291
1292 # Crashed with a slightly different stack trace
1293 code = """
1294 class name_2[name_5]:
1295 class name_4[name_5: name_5](name_0):
1296 pass
1297 """
1298 with self.assertRaises(NameError):
1299 run_code(code)
1300
1301 def test_broken_class_namespace(self):
1302 code = """
1303 class WeirdMapping(dict):
1304 def __missing__(self, key):
1305 if key == "T":
1306 raise RuntimeError
1307 raise KeyError(key)
1308
1309 class Meta(type):
1310 def __prepare__(name, bases):
1311 return WeirdMapping()
1312
1313 class MyClass[V](metaclass=Meta):
1314 class Inner[U](T):
1315 pass
1316 """
1317 with self.assertRaises(RuntimeError):
1318 run_code(code)
1319
1320
1321 class DefaultsTest(unittest.TestCase):
1322 def test_defaults_on_func(self):
1323 ns = run_code("""
1324 def func[T=int, **U=float, *V=None]():
1325 pass
1326 """)
1327
1328 T, U, V = ns["func"].__type_params__
1329 self.assertIs(T.__default__, int)
1330 self.assertIs(U.__default__, float)
1331 self.assertIs(V.__default__, None)
1332
1333 def test_defaults_on_class(self):
1334 ns = run_code("""
1335 class C[T=int, **U=float, *V=None]:
1336 pass
1337 """)
1338
1339 T, U, V = ns["C"].__type_params__
1340 self.assertIs(T.__default__, int)
1341 self.assertIs(U.__default__, float)
1342 self.assertIs(V.__default__, None)
1343
1344 def test_defaults_on_type_alias(self):
1345 ns = run_code("""
1346 type Alias[T = int, **U = float, *V = None] = int
1347 """)
1348
1349 T, U, V = ns["Alias"].__type_params__
1350 self.assertIs(T.__default__, int)
1351 self.assertIs(U.__default__, float)
1352 self.assertIs(V.__default__, None)
1353
1354 def test_starred_invalid(self):
1355 check_syntax_error(self, "type Alias[T = *int] = int")
1356 check_syntax_error(self, "type Alias[**P = *int] = int")
1357
1358 def test_starred_typevartuple(self):
1359 ns = run_code("""
1360 default = tuple[int, str]
1361 type Alias[*Ts = *default] = Ts
1362 """)
1363
1364 Ts, = ns["Alias"].__type_params__
1365 self.assertEqual(Ts.__default__, next(iter(ns["default"])))
1366
1367 def test_nondefault_after_default(self):
1368 check_syntax_error(self, "def func[T=int, U](): pass", "non-default type parameter 'U' follows default type parameter")
1369 check_syntax_error(self, "class C[T=int, U]: pass", "non-default type parameter 'U' follows default type parameter")
1370 check_syntax_error(self, "type A[T=int, U] = int", "non-default type parameter 'U' follows default type parameter")
1371
1372 def test_lazy_evaluation(self):
1373 ns = run_code("""
1374 type Alias[T = Undefined, *U = Undefined, **V = Undefined] = int
1375 """)
1376
1377 T, U, V = ns["Alias"].__type_params__
1378
1379 with self.assertRaises(NameError):
1380 T.__default__
1381 with self.assertRaises(NameError):
1382 U.__default__
1383 with self.assertRaises(NameError):
1384 V.__default__
1385
1386 ns["Undefined"] = "defined"
1387 self.assertEqual(T.__default__, "defined")
1388 self.assertEqual(U.__default__, "defined")
1389 self.assertEqual(V.__default__, "defined")
1390
1391 # Now it is cached
1392 ns["Undefined"] = "redefined"
1393 self.assertEqual(T.__default__, "defined")
1394 self.assertEqual(U.__default__, "defined")
1395 self.assertEqual(V.__default__, "defined")
1396
1397 def test_symtable_key_regression_default(self):
1398 # Test against the bugs that would happen if we used .default_
1399 # as the key in the symtable.
1400 ns = run_code("""
1401 type X[T = [T for T in [T]]] = T
1402 """)
1403
1404 T, = ns["X"].__type_params__
1405 self.assertEqual(T.__default__, [T])
1406
1407 def test_symtable_key_regression_name(self):
1408 # Test against the bugs that would happen if we used .name
1409 # as the key in the symtable.
1410 ns = run_code("""
1411 type X1[T = A] = T
1412 type X2[T = B] = T
1413 A = "A"
1414 B = "B"
1415 """)
1416
1417 self.assertEqual(ns["X1"].__type_params__[0].__default__, "A")
1418 self.assertEqual(ns["X2"].__type_params__[0].__default__, "B")
1419
1420
1421 class TestEvaluateFunctions(unittest.TestCase):
1422 def test_general(self):
1423 type Alias = int
1424 Alias2 = TypeAliasType("Alias2", int)
1425 def f[T: int = int, **P = int, *Ts = int](): pass
1426 T, P, Ts = f.__type_params__
1427 T2 = TypeVar("T2", bound=int, default=int)
1428 P2 = ParamSpec("P2", default=int)
1429 Ts2 = TypeVarTuple("Ts2", default=int)
1430 cases = [
1431 Alias.evaluate_value,
1432 Alias2.evaluate_value,
1433 T.evaluate_bound,
1434 T.evaluate_default,
1435 P.evaluate_default,
1436 Ts.evaluate_default,
1437 T2.evaluate_bound,
1438 T2.evaluate_default,
1439 P2.evaluate_default,
1440 Ts2.evaluate_default,
1441 ]
1442 for case in cases:
1443 with self.subTest(case=case):
1444 self.assertIs(case(1), int)
1445 self.assertIs(annotationlib.call_evaluate_function(case, annotationlib.Format.VALUE), int)
1446 self.assertIs(annotationlib.call_evaluate_function(case, annotationlib.Format.FORWARDREF), int)
1447 self.assertEqual(annotationlib.call_evaluate_function(case, annotationlib.Format.STRING), 'int')
1448
1449 def test_constraints(self):
1450 def f[T: (int, str)](): pass
1451 T, = f.__type_params__
1452 T2 = TypeVar("T2", int, str)
1453 for case in [T, T2]:
1454 with self.subTest(case=case):
1455 self.assertEqual(case.evaluate_constraints(1), (int, str))
1456 self.assertEqual(annotationlib.call_evaluate_function(case.evaluate_constraints, annotationlib.Format.VALUE), (int, str))
1457 self.assertEqual(annotationlib.call_evaluate_function(case.evaluate_constraints, annotationlib.Format.FORWARDREF), (int, str))
1458 self.assertEqual(annotationlib.call_evaluate_function(case.evaluate_constraints, annotationlib.Format.STRING), '(int, str)')
1459
1460 def test_const_evaluator(self):
1461 T = TypeVar("T", bound=int)
1462 self.assertEqual(repr(T.evaluate_bound), "<constevaluator <class 'int'>>")
1463
1464 ConstEvaluator = type(T.evaluate_bound)
1465
1466 with self.assertRaisesRegex(TypeError, r"cannot create '_typing\._ConstEvaluator' instances"):
1467 ConstEvaluator() # This used to segfault.
1468 with self.assertRaisesRegex(TypeError, r"cannot set 'attribute' attribute of immutable type '_typing\._ConstEvaluator'"):
1469 ConstEvaluator.attribute = 1