Fix patma guard

youknowone · youknowone · commit ef1ed9416b81 · 2025-08-26T16:31:02.000+09:00
diff --git a/Lib/test/test_patma.py b/Lib/test/test_patma.py
@@ -586,7 +586,6 @@ def test_patma_051(self):
         self.assertEqual(y, 1)
         self.assertEqual(z, 0)
 
-    @unittest.expectedFailure   # TODO: RUSTPYTHON
     def test_patma_052(self):
         x = [1, 0]
         match x:
@@ -1904,7 +1903,6 @@ def whereis(points):
         self.assertEqual(whereis([Point(0, 0), Point(0, 0), Point(0, 0)]), "Something else")
         self.assertEqual(whereis([Point(0, 1), Point(0, 1), Point(0, 1)]), "Something else")
 
-    @unittest.expectedFailure   # TODO: RUSTPYTHON
     def test_patma_183(self):
         def whereis(point):
             match point:
@@ -2695,7 +2693,6 @@ def f(self, x):
         setattr(c, "__attr", "spam")  # setattr is needed because we're in a class scope
         self.assertEqual(Outer().f(c), "spam")
 
-    @unittest.expectedFailure   # TODO: RUSTPYTHON
     def test_patma_250(self):
         def f(x):
             match x:
@@ -2707,7 +2704,6 @@ def f(x):
         self.assertIs(f({"foo": 1}), True)
         self.assertIs(f({"foo": -1}), False)
 
-    @unittest.expectedFailure   # TODO: RUSTPYTHON
     def test_patma_251(self):
         def f(v, x):
             match v:
@@ -2726,7 +2722,6 @@ def __init__(self, attr):
         self.assertIs(f(-1, X(-1)), False)
         self.assertIs(f(1, X(-1)), None)
 
-    @unittest.expectedFailure   # TODO: RUSTPYTHON
     def test_patma_252(self):
         # Side effects must be possible in guards:
         effects = []
@@ -2764,7 +2759,6 @@ def f(v):
         self.assertEqual(f(1), 1)
         self.assertEqual(f({"x": 1}), 1)
 
-    @unittest.expectedFailure   # TODO: RUSTPYTHON
     def test_patma_255(self):
         x = []
         match x:
@@ -3259,7 +3253,6 @@ class Class:
         self.assertIs(y, None)
         self.assertIs(z, None)
 
-    @unittest.expectedFailure   # TODO: RUSTPYTHON
     def test_accepts_positional_subpatterns_1(self):
         x = range(10)
         y = None
diff --git a/compiler/codegen/src/compile.rs b/compiler/codegen/src/compile.rs
@@ -4011,10 +4011,10 @@ impl Compiler {
                 self.ensure_fail_pop(pattern_context, 0)?;
                 // Compile the guard expression
                 self.compile_expression(guard)?;
-                // If guard is false, jump to fail_pop[0]
+                emit!(self, Instruction::ToBool);
                 emit!(
                     self,
-                    Instruction::JumpIfFalseOrPop {
+                    Instruction::PopJumpIfFalse {
                         target: pattern_context.fail_pop[0]
                     }
                 );
diff --git a/vm/src/frame.rs b/vm/src/frame.rs
@@ -1439,14 +1439,18 @@ impl ExecutingFrame<'_> {
                                     extracted.push(subject.clone());
                                 } else if nargs_val > 1 {
                                     // Too many positional arguments for MATCH_SELF
-                                    self.push_value(vm.ctx.none());
-                                    return Ok(None);
+                                    return Err(vm.new_type_error(
+                                        "class pattern accepts at most 1 positional sub-pattern for MATCH_SELF types"
+                                            .to_string(),
+                                    ));
                                 }
                             } else {
                                 // No __match_args__ and not a MATCH_SELF type
                                 if nargs_val > 0 {
-                                    self.push_value(vm.ctx.none());
-                                    return Ok(None);
+                                    return Err(vm.new_type_error(
+                                        "class pattern defines no positional sub-patterns (__match_args__ missing)"
+                                            .to_string(),
+                                    ));
                                 }
                             }
                         }
@@ -1457,11 +1461,11 @@ impl ExecutingFrame<'_> {
                         let name_str = name.downcast_ref::<PyStr>().unwrap();
                         match subject.get_attr(name_str, vm) {
                             Ok(value) => extracted.push(value),
-                            Err(_) => {
-                                // Attribute doesn't exist
+                            Err(e) if e.fast_isinstance(vm.ctx.exceptions.attribute_error) => {
                                 self.push_value(vm.ctx.none());
                                 return Ok(None);
                             }
+                            Err(e) => return Err(e),
                         }
                     }
 

Original file line number	Diff line number	Diff line change
`@@ -1439,14 +1439,18 @@ impl ExecutingFrame<'_> {`
`1439`	`1439`	`extracted.push(subject.clone());`
`1440`	`1440`	`} else if nargs_val > 1 {`
`1441`	`1441`	`// Too many positional arguments for MATCH_SELF`
`1442`		`- self.push_value(vm.ctx.none());`
`1443`		`- return Ok(None);`
	`1442`	`+ return Err(vm.new_type_error(`
	`1443`	`+ "class pattern accepts at most 1 positional sub-pattern for MATCH_SELF types"`
	`1444`	`+ .to_string(),`
	`1445`	`+ ));`
`1444`	`1446`	`}`
`1445`	`1447`	`} else {`
`1446`	`1448`	`// No __match_args__ and not a MATCH_SELF type`
`1447`	`1449`	`if nargs_val > 0 {`
`1448`		`- self.push_value(vm.ctx.none());`
`1449`		`- return Ok(None);`
	`1450`	`+ return Err(vm.new_type_error(`
	`1451`	`+ "class pattern defines no positional sub-patterns (__match_args__ missing)"`
	`1452`	`+ .to_string(),`
	`1453`	`+ ));`
`1450`	`1454`	`}`
`1451`	`1455`	`}`
`1452`	`1456`	`}`
`@@ -1457,11 +1461,11 @@ impl ExecutingFrame<'_> {`
`1457`	`1461`	`let name_str = name.downcast_ref::<PyStr>().unwrap();`
`1458`	`1462`	`match subject.get_attr(name_str, vm) {`
`1459`	`1463`	`Ok(value) => extracted.push(value),`
`1460`		`- Err(_) => {`
`1461`		`- // Attribute doesn't exist`
	`1464`	`+ Err(e) if e.fast_isinstance(vm.ctx.exceptions.attribute_error) => {`
`1462`	`1465`	`self.push_value(vm.ctx.none());`
`1463`	`1466`	`return Ok(None);`
`1464`	`1467`	`}`
	`1468`	`+ Err(e) => return Err(e),`
`1465`	`1469`	`}`
`1466`	`1470`	`}`
`1467`	`1471`