[GR-63204][GR-63581] Multiple OR patterns support, same variable name usage in "case", mapping patma support, class patma support.

PullRequest: graalpython/3764

Author: Michal Medvecky

graalpython/com.oracle.graal.python.test/src/tests/cpyext/test_abstract.py

@@ -1567,29 +1567,28 @@ def _reference_seq_repeat(args):
             case _:
                 return args[0] * args[1]
 
-    if not os.environ.get('BYTECODE_DSL_INTERPRETER'): # TODO: class pattern matching
-        test_PySequence_Repeat = CPyExtFunction(
-            _reference_seq_repeat,
-            lambda: (
-                ((1,), 0),
-                ((1,), 1),
-                ((1,), 3),
-                ([1], 0),
-                ([1], 1),
-                ([1], 3),
-                ("hello", 0),
-                ("hello", 1),
-                ("hello", 3),
-                ({}, 0),
-                (SeqWithMulAdd(), 42),
-                (NonSeqWithMulAdd(), 24),
-                (DictSubclassWithSequenceMethods(), 5),
-            ),
-            resultspec="O",
-            argspec='On',
-            arguments=["PyObject* obj", "Py_ssize_t n"],
-            cmpfunc=unhandled_error_compare
-        )
+    test_PySequence_Repeat = CPyExtFunction(
+        _reference_seq_repeat,
+        lambda: (
+            ((1,), 0),
+            ((1,), 1),
+            ((1,), 3),
+            ([1], 0),
+            ([1], 1),
+            ([1], 3),
+            ("hello", 0),
+            ("hello", 1),
+            ("hello", 3),
+            ({}, 0),
+            (SeqWithMulAdd(), 42),
+            (NonSeqWithMulAdd(), 24),
+            (DictSubclassWithSequenceMethods(), 5),
+        ),
+        resultspec="O",
+        argspec='On',
+        arguments=["PyObject* obj", "Py_ssize_t n"],
+        cmpfunc=unhandled_error_compare
+    )
 
     test_PySequence_InPlaceRepeat = CPyExtFunction(
         lambda args: args[0] * args[1],
@@ -1622,35 +1621,34 @@ def _reference_seq_concat(args):
             case _:
                 return args[0] + args[1]
 
-    if not os.environ.get('BYTECODE_DSL_INTERPRETER'): # TODO: class pattern matching
-        test_PySequence_Concat = CPyExtFunction(
-            _reference_seq_concat,
-            lambda: (
-                ((1,), tuple()),
-                ((1,), list()),
-                ((1,), (2,)),
-                ((1,), [2,]),
-                ([1], tuple()),
-                ([1], list()),
-                ([1], (2,)),
-                ([1], [2,]),
-                ("hello", "world"),
-                ("hello", ""),
-                ({}, []),
-                ([], {}),
-                (SeqWithMulAdd(), 1),
-                (SeqWithMulAdd(), SeqWithMulAdd()),
-                (SeqWithMulAdd(), [1,2,3]),
-                (NonSeqWithMulAdd(), 2),
-                (NonSeqWithMulAdd(), [1,2,3]),
-                (DictSubclassWithSequenceMethods(), (1,2,3)),
-                ((1,2,3), DictSubclassWithSequenceMethods()),
-            ),
-            resultspec="O",
-            argspec='OO',
-            arguments=["PyObject* s", "PyObject* o"],
-            cmpfunc=unhandled_error_compare
-        )
+    test_PySequence_Concat = CPyExtFunction(
+        _reference_seq_concat,
+        lambda: (
+            ((1,), tuple()),
+            ((1,), list()),
+            ((1,), (2,)),
+            ((1,), [2,]),
+            ([1], tuple()),
+            ([1], list()),
+            ([1], (2,)),
+            ([1], [2,]),
+            ("hello", "world"),
+            ("hello", ""),
+            ({}, []),
+            ([], {}),
+            (SeqWithMulAdd(), 1),
+            (SeqWithMulAdd(), SeqWithMulAdd()),
+            (SeqWithMulAdd(), [1,2,3]),
+            (NonSeqWithMulAdd(), 2),
+            (NonSeqWithMulAdd(), [1,2,3]),
+            (DictSubclassWithSequenceMethods(), (1,2,3)),
+            ((1,2,3), DictSubclassWithSequenceMethods()),
+        ),
+        resultspec="O",
+        argspec='OO',
+        arguments=["PyObject* s", "PyObject* o"],
+        cmpfunc=unhandled_error_compare
+    )
 
     test_PySequence_InPlaceConcat = CPyExtFunction(
         lambda args: args[0] + list(args[1]) if isinstance(args[0], list) else args[0] + args[1],

graalpython/com.oracle.graal.python.test/src/tests/test_patmat.py

@@ -38,9 +38,9 @@
 # SOFTWARE.
 import os
 import sys, ast, unittest
+import inspect
 
 
-@unittest.skipIf(sys.version_info.minor < 10, "Requires Python 3.10+")
 def test_guard():
     def f(x, g):
         match x:
@@ -62,7 +62,6 @@ def f(x):
     assert f(1) == 42
     assert f(2) == 0
 
-@unittest.skipIf(sys.version_info.minor < 10, "Requires Python 3.10+")
 def test_complex_as_binary_op():
     src = """
 def f(a):
@@ -87,8 +86,6 @@ def f(a):
     assert f(6+3j) == "match add"
     assert f(-2-3j) == "match sub"
 
-@unittest.skipIf(sys.version_info.minor < 10, "Requires Python 3.10+")
-@unittest.skipIf(os.environ.get('BYTECODE_DSL_INTERPRETER'), "TODO: mapping pattern matching")
 def test_long_mapping():
     def f(x):
         match d:
@@ -107,7 +104,6 @@ def star_match(x):
 
     assert star_match(d) == {33:33}
 
-@unittest.skipIf(os.environ.get('BYTECODE_DSL_INTERPRETER'), "TODO: mapping pattern matching")
 def test_mutable_dict_keys():
     class MyObj:
         pass
@@ -125,3 +121,145 @@ def test(name):
 
     assert test('attr1') == {'dyn_match': 1, 'attr2': 2, 'attr3': 3}
     assert test('attr2') == {'dyn_match': 2, 'attr1': 1, 'attr3': 3}
+
+def test_multiple_or_pattern_basic():
+    match 0:
+        case 0 | 1 | 2 | 3 | 4 | 5 as x:
+            assert x == 0
+
+    match 3:
+        case ((0 | 1 | 2) as x) | ((3 | 4 | 5) as x):
+            assert x == 3
+
+def test_sequence_pattern():
+    match (1, 2):
+        case (3, 2):
+            assert False
+
+    match (1, (2, 2)):
+        case (3, (2, 2)):
+            assert False
+
+    match (1, 2):
+        case (3, q):
+            assert False
+
+
+def test_multiple_or_pattern_advanced():
+    match 4:
+        case (0 as z) | (1 as z) | (2 as z) | (4 as z) | (77 as z):
+            assert z == 4
+
+    match 42:
+        case (0 as z) | (1 as z):
+            assert z == 1
+        case x:
+            assert x == 42
+
+    match 2:
+        case (0 as z) | (1 as z) | (2 as z):
+            assert z == 2
+        case _:
+            assert False
+
+    match 1:
+        case (0 as z) | (1 as z) | (2 as z):
+            assert z == 1
+        case _:
+            assert False
+
+    match 0:
+        case (0 as z) | (1 as z) | (2 as z):
+            assert z == 0
+        case _:
+            assert False
+
+    match (1, 2):
+        case (w, 2) | (2, w):
+            assert w == 1
+
+
+def test_multiple_or_pattern_creates_locals():
+    match (1, 2):
+        case (a, 1) | (a, 2):
+            assert a == 1
+    assert a == 1
+
+    match [1, 2]:
+        case [a1, 1] | [a1, 2]:
+            assert a1 == 1
+    assert a1 == 1
+
+    match (1, 2, 2, 3, 2):
+        case (1, a, b, 4, c) | (1, a, b, 3, c) | (1, a, b, 2, c):
+            assert a == 2
+            assert b == 2
+            assert c == 2
+    assert a == 2
+    assert b == 2
+    assert c == 2
+
+    match (1, 3, 4, 9):
+        case ((d, e, f, 7) | (d, e, f, 8) | (d, e, f, 6) | (d, e, f, 9)):
+            assert d == 1
+            assert e == 3
+            assert f == 4
+    assert d == 1
+    assert e == 3
+    assert f == 4
+
+    match (1,2,3,4,5,6,7):
+        case (0,q,w,e,r,t,y) | (q,w,e,r,t,y,7):
+            assert q == 1
+            assert w == 2
+            assert e == 3
+            assert r == 4
+            assert t == 5
+            assert y == 6
+    assert q == 1
+    assert w == 2
+    assert e == 3
+    assert r == 4
+    assert t == 5
+    assert y == 6
+
+
+class TestErrors(unittest.TestCase):
+    def assert_syntax_error(self, code: str):
+        with self.assertRaises(SyntaxError):
+            compile(inspect.cleandoc(code), "<test>", "exec")
+
+    def test_alternative_patterns_bind_different_names_0(self):
+        self.assert_syntax_error("""
+            match ...:
+                case "a" | a:
+                    pass
+            """)
+
+    def test_alternative_patterns_bind_different_names_1(self):
+        self.assert_syntax_error("""
+        match ...:
+            case [a, [b] | [c] | [d]]:
+                pass
+        """)
+
+    def test_multiple_or_same_name(self):
+        self.assert_syntax_error("""
+        match 0:
+            case x | x:
+                pass
+        """)
+
+    def test_multiple_or_wildcard(self):
+        self.assert_syntax_error("""
+        match 0:
+            case * | 1:
+                pass
+        """)
+
+    def test_unbound_local_variable(self):
+        with self.assertRaises(UnboundLocalError):
+            match (1, 3):
+                case (a, 1) | (a, 2):
+                    pass
+            assert a == 1