| |
| new file mode 100644 |
| |
| |
| |
| @@ -0,0 +1,162 @@ |
| +"""Augmented P2P tests for the PEP 798 bundle. |
| + |
| +These exercise the regenerated PEG parser across a broad slice of existing |
| +Python syntax — they pass on the pre-solution interpreter (none of the code |
| +below uses PEP 798 forms) and still pass post-solution, pinning that the |
| +grammar regeneration did not disturb pre-existing parsing behavior while |
| +walking a wide range of parser.c rules for coverage. |
| +""" |
| + |
| +import ast |
| +import unittest |
| + |
| + |
| +# A deterministic corpus touching many grammar rules: statements, decorators, |
| +# pattern matching, type params, f-strings, slices, lambda, star-args, |
| +# with/try/except*, walrus, comprehensions (classic forms), annotations. |
| +CORPUS = r''' |
| +from __future__ import annotations |
| +import os, sys as system |
| +from os import (path, sep) |
| + |
| +CONST: int = 0x10 + 0o7 + 0b1 + 1_000 - .5j.imag |
| + |
| +@staticmethod |
| +def deco(): ... |
| + |
| +class Meta(type): ... |
| + |
| +class C(Meta, metaclass=Meta): |
| + """doc""" |
| + x: int = 1 |
| + def method(self, a, b=2, /, c=3, *args, d, e=5, **kw) -> "C": |
| + global CONST |
| + nonlocal_target = lambda q, *, r=1: (q, r) |
| + y = [i for i in range(3) if i] |
| + z = {k: v for k, v in zip("ab", y)} |
| + s = {frozenset({1, 2})} |
| + g = (w for w in y) |
| + t = a if b else c |
| + f = f"{a!r:>{b}} {'lit'} {a=}" |
| + m = b"bytes" rb"raw" |
| + sl = y[::2], y[1:], y[:1], y[0] |
| + star_call = print(*y, **{}) |
| + unpack_assign, *rest = [1, 2, 3] |
| + (p := 9) |
| + del nonlocal_target |
| + return self |
| + |
| +async def aio(): |
| + async with open(os.devnull) as fh: |
| + pass |
| + async for _ in agen(): |
| + break |
| + await coro() |
| + |
| +def agen(): ... |
| +def coro(): ... |
| + |
| +def matcher(obj): |
| + match obj: |
| + case [1, 2, *rest]: |
| + return rest |
| + case {"k": v, **extra}: |
| + return v, extra |
| + case C(x=1) | None: |
| + return None |
| + case str() as s if s: |
| + return s |
| + case _: |
| + return obj |
| + |
| +def generic[T, *Ts, **P](x: T) -> T: |
| + type Alias[U] = list[U] |
| + return x |
| + |
| +try: |
| + 1 / 0 |
| +except* ZeroDivisionError as eg: |
| + pass |
| +finally: |
| + pass |
| + |
| +while False: |
| + continue |
| +else: |
| + pass |
| + |
| +for i in range(1): |
| + break |
| +else: |
| + pass |
| + |
| +with open(os.devnull) as a, open(os.devnull) as b: |
| + pass |
| + |
| +if CONST: |
| + pass |
| +elif system: |
| + pass |
| +else: |
| + assert True, "msg" |
| + |
| +yield_holder = lambda: (x for x in ()) |
| +''' |
| + |
| + |
| +class ParserStabilityAugTests(unittest.TestCase): |
| + def test_broad_syntax_corpus_compiles_and_roundtrips(self): |
| + tree = ast.parse(CORPUS) |
| + compile(tree, "<pep798-corpus>", "exec") |
| + # unparse → reparse round-trip walks the AST and the parser again |
| + rendered = ast.unparse(tree) |
| + reparsed = ast.parse(rendered) |
| + compile(reparsed, "<pep798-corpus-2>", "exec") |
| + |
| + def test_classic_comprehensions_unchanged(self): |
| + ns = {} |
| + exec( |
| + "lc=[i*i for i in range(4)]; sc={i%2 for i in range(4)};" |
| + "dc={i: -i for i in range(3)}; ge=sum(i for i in range(4))", |
| + ns, |
| + ) |
| + self.assertEqual(ns["lc"], [0, 1, 4, 9]) |
| + self.assertEqual(ns["sc"], {0, 1}) |
| + self.assertEqual(ns["dc"], {0: 0, 1: -1, 2: -2}) |
| + self.assertEqual(ns["ge"], 6) |
| + |
| + def test_classic_call_and_display_unpacking_unchanged(self): |
| + # Pre-PEP-798 star/double-star forms (displays + calls) unchanged. |
| + a, b = [1, 2], {"x": 3} |
| + self.assertEqual([*a, 9], [1, 2, 9]) |
| + self.assertEqual({*a, 9}, {1, 2, 9}) |
| + self.assertEqual((*a, 9), (1, 2, 9)) |
| + self.assertEqual({**b, "y": 4}, {"x": 3, "y": 4}) |
| + self.assertEqual(dict(**b), {"x": 3}) |
| + |
| + def test_unpacking_remains_illegal_outside_element_position(self): |
| + # These are SyntaxError both pre- and post-PEP-798: the PEP only |
| + # legalizes * / ** at the top level of the comprehension element. |
| + for bad in ( |
| + "{*x: 1 for x in y}", # starred dict-comprehension key |
| + "[x, *y for y in z]", # star not at top level of the element |
| + "[(*y) for y in z]", # parenthesized star is not a valid expr |
| + ): |
| + with self.subTest(bad=bad): |
| + with self.assertRaises(SyntaxError): |
| + compile(bad, "<pep798-bad>", "eval") |
| + |
| + def test_parser_error_positions_stable(self): |
| + for bad, needle in ( |
| + ("def f(:", "invalid syntax"), |
| + ("x = [1, 2", "was never closed"), |
| + ("class :", "invalid syntax"), |
| + ): |
| + with self.subTest(bad=bad): |
| + with self.assertRaises(SyntaxError) as cm: |
| + compile(bad, "<bad>", "exec") |
| + self.assertIn(needle, str(cm.exception)) |
| + |
| + |
| +if __name__ == "__main__": |
| + unittest.main() |
| |
| new file mode 100644 |
| |
| |
| |
| @@ -0,0 +1,158 @@ |
| +"""Augmented F2P tests for PEP 798 (unpacking in comprehensions). |
| + |
| +Every test drives the documented PEP 798 syntax forms — ``*`` in list/set |
| +comprehensions and generator expressions, ``**`` in dict comprehensions, and |
| +their ``async for`` variants — through plain compilation and evaluation. No |
| +PR-internal symbol is referenced; the new syntax itself is the documented |
| +public surface, so each test fails with SyntaxError on the pre-solution |
| +interpreter and passes once PEP 798 is implemented. |
| +""" |
| + |
| +import ast |
| +import asyncio |
| +import subprocess |
| +import sys |
| +import textwrap |
| +import unittest |
| + |
| + |
| +async def _agen(items): |
| + for item in items: |
| + yield item |
| + |
| + |
| +class UnpackingComprehensionAugTests(unittest.TestCase): |
| + def run_async(self, coro): |
| + return asyncio.run(coro) |
| + |
| + def test_setcomp_star_unpacks_each_iterable(self): |
| + # PEP 798: {*expr for x in it} merges each iterable into the set |
| + # (set.update semantics). Guards both the setcomp grammar rule and |
| + # the SET_UPDATE opcode selection. |
| + result = eval("{*t for t in [(1, 2), (2, 3), ()]}") |
| + self.assertEqual(result, {1, 2, 3}) |
| + |
| + # An unhashable iterable element must still unpack (update), not be |
| + # added as a single element (add would raise TypeError for a list). |
| + result = eval("{*lst for lst in [[1, 2], [3]]}") |
| + self.assertEqual(result, {1, 2, 3}) |
| + |
| + def test_listcomp_and_genexp_star_flatten(self): |
| + # Documented list-comprehension and generator-expression forms. |
| + self.assertEqual(eval("[*t for t in [(1, 2), (), (3,)]]"), [1, 2, 3]) |
| + gen = eval("(*t for t in [(1, 2), (3,)])") |
| + self.assertEqual(next(gen), 1) |
| + self.assertEqual(list(gen), [2, 3]) |
| + |
| + def test_dictcomp_double_star_merges_with_update_semantics(self): |
| + # {**d for d in dicts}: dict.update semantics — later values win, |
| + # duplicate keys are allowed. |
| + dicts = [{1: "a"}, {2: "b"}, {1: "c"}] |
| + result = eval("{**d for d in dicts}", {"dicts": dicts}) |
| + self.assertEqual(result, {1: "c", 2: "b"}) |
| + |
| + def test_dictcomp_double_star_compiles_from_ast(self): |
| + # The AST for {**d for d in ds} carries DictComp.value == None; the |
| + # compiler's AST validation must accept it. Run in a subprocess so a |
| + # validation crash on a broken interpreter is a clean test failure |
| + # rather than taking down the test runner. |
| + code = textwrap.dedent( |
| + """ |
| + import ast |
| + tree = ast.parse('{**d for d in ds}', mode='eval') |
| + compiled = compile(tree, '<pep798>', 'eval') |
| + result = eval(compiled, {'ds': [{1: 2}, {3: 4}, {1: 0}]}) |
| + assert result == {1: 0, 3: 4}, result |
| + print('OK') |
| + """ |
| + ) |
| + proc = subprocess.run( |
| + [sys.executable, "-c", code], |
| + capture_output=True, text=True, timeout=60, |
| + ) |
| + self.assertEqual(proc.returncode, 0, proc.stderr) |
| + self.assertIn("OK", proc.stdout) |
| + |
| + def test_async_listcomp_star_extends(self): |
| + async def main(): |
| + return [*item async for item in _agen([(1, 2), (3,), ()])] |
| + |
| + self.assertEqual(self.run_async(main()), [1, 2, 3]) |
| + |
| + def test_async_setcomp_star_updates(self): |
| + async def main(): |
| + return {*item async for item in _agen([(1, 2), (2, 3)])} |
| + |
| + self.assertEqual(self.run_async(main()), {1, 2, 3}) |
| + |
| + def test_async_genexp_star_flattens(self): |
| + async def main(): |
| + agen = (*item async for item in _agen([(1,), (2, 3)])) |
| + return [x async for x in agen] |
| + |
| + self.assertEqual(self.run_async(main()), [1, 2, 3]) |
| + |
| + def test_async_dictcomp_double_star_allows_duplicate_keys(self): |
| + # DICT_UPDATE semantics in the async path: duplicates allowed, |
| + # right-most wins. Run in a subprocess so a broken interpreter that |
| + # mis-selects the merge opcode (which can crash the process) is a |
| + # clean test failure rather than taking down the test runner. |
| + code = textwrap.dedent( |
| + """ |
| + import asyncio |
| + |
| + async def agen(items): |
| + for item in items: |
| + yield item |
| + |
| + async def main(): |
| + return {**d async for d in agen([{1: "a"}, {2: "b"}, {1: "c"}])} |
| + |
| + result = asyncio.run(main()) |
| + assert result == {1: "c", 2: "b"}, result |
| + print("OK") |
| + """ |
| + ) |
| + proc = subprocess.run( |
| + [sys.executable, "-c", code], |
| + capture_output=True, text=True, timeout=60, |
| + ) |
| + self.assertEqual(proc.returncode, 0, proc.stderr) |
| + self.assertIn("OK", proc.stdout) |
| + |
| + def test_nested_and_conditional_unpacking_forms(self): |
| + # Conditional clauses and nested fors combine with unpacking. |
| + self.assertEqual( |
| + eval("[*t for t in [(1, 2), (3, 4), (5,)] if len(t) == 2]"), |
| + [1, 2, 3, 4], |
| + ) |
| + self.assertEqual( |
| + eval("[*t for pair in [((1,), (2, 3))] for t in pair]"), |
| + [1, 2, 3], |
| + ) |
| + self.assertEqual( |
| + eval("{**d for ds in [[{1: 2}], [{3: 4}]] for d in ds}"), |
| + {1: 2, 3: 4}, |
| + ) |
| + |
| + def test_ast_shapes_of_unpacking_comprehensions(self): |
| + # ast.parse produces the documented node shapes: the DictComp node |
| + # for ** has value=None per the updated ASDL, and a starred setcomp |
| + # element is a Starred node that compiles and evaluates. |
| + # (ast.unparse of the ** form is not exercised: the reference patch |
| + # does not extend _ast_unparse.py for value=None DictComp nodes.) |
| + tree = ast.parse("{**d for d in ds}", mode="eval") |
| + comp = tree.body |
| + self.assertIsInstance(comp, ast.DictComp) |
| + self.assertIsNone(comp.value) |
| + self.assertEqual(len(comp.generators), 1) |
| + |
| + tree = ast.parse("{*t for t in ts}", mode="eval") |
| + self.assertIsInstance(tree.body, ast.SetComp) |
| + self.assertIsInstance(tree.body.elt, ast.Starred) |
| + compiled = compile(tree, "<pep798-ast>", "eval") |
| + self.assertEqual(eval(compiled, {"ts": [(1, 2), (3,)]}), {1, 2, 3}) |
| + |
| + |
| +if __name__ == "__main__": |
| + unittest.main() |
|
|
