except*

RustPython · youknowone · Dec 26, 2025 · Dec 25, 2025 · Dec 25, 2025 · Dec 25, 2025
commit a73b2d688318218e16dc2d50223c96b9d81c6338
diff --git a/crates/codegen/src/compile.rs b/crates/codegen/src/compile.rs
@@ -45,7 +45,6 @@ use rustpython_wtf8::Wtf8Buf;
 use std::{borrow::Cow, collections::HashSet};
 
 const MAXBLOCKS: usize = 20;
-const COPY_TOP: u32 = 1;
 
 #[derive(Debug, Clone, Copy)]
 pub enum FBlockType {
@@ -472,16 +471,7 @@ impl Compiler {
             }
         } else {
             // VISIT(c, expr, e->v.Subscript.slice)
-            match slice {
-                Expr::Starred(starred) => {
-                    self.starunpack_helper(
-                        &[Expr::Starred(starred.clone())],
-                        0,
-                        CollectionType::Tuple,
-                    )?;
-                }
-                other => self.compile_expression(other)?,
-            }
+            self.compile_expression(slice)?;
 
             // Emit appropriate instruction based on context
             match ctx {
@@ -1520,7 +1510,7 @@ impl Compiler {
                 ..
             }) => {
                 if *is_star {
-                    self.compile_try_star_statement(body, handlers, orelse, finalbody)?
+                    self.compile_try_star_except(body, handlers, orelse, finalbody)?
                 } else {
                     self.compile_try_statement(body, handlers, orelse, finalbody)?
                 }
@@ -2129,13 +2119,14 @@ impl Compiler {
         Ok(())
     }
 
-    fn compile_try_star_statement(
+    fn compile_try_star_except(
         &mut self,
         body: &[Stmt],
         handlers: &[ExceptHandler],
         orelse: &[Stmt],
         finalbody: &[Stmt],
     ) -> CompileResult<()> {
+        // Simplified except* implementation using CheckEgMatch
         let handler_block = self.new_block();
         let finally_block = self.new_block();
 
@@ -2161,14 +2152,7 @@ impl Compiler {
         emit!(self, Instruction::Jump { target: else_block });
 
         self.switch_to_block(handler_block);
-        // incoming stack: [exc]
-        emit!(
-            self,
-            Instruction::CallIntrinsic1 {
-                func: bytecode::IntrinsicFunction1::EnsureExceptionGroup
-            }
-        );
-        // stack: [remainder]
+        // Stack: [exc]
 
         for handler in handlers {
             let ExceptHandler::ExceptHandler(ExceptHandlerExceptHandler {
@@ -2178,32 +2162,32 @@ impl Compiler {
             let skip_block = self.new_block();
             let next_block = self.new_block();
 
-            // Split current remainder for this handler
+            // Compile exception type
             if let Some(exc_type) = type_ {
                 self.compile_expression(exc_type)?;
             } else {
                 return Err(self.error(CodegenErrorType::SyntaxError(
                     "except* must specify an exception type".to_owned(),
                 )));
             }
+            // Stack: [exc, type]
 
-            emit!(
-                self,
-                Instruction::CallIntrinsic2 {
-                    func: bytecode::IntrinsicFunction2::ExceptStarMatch
-                }
-            );
-            emit!(self, Instruction::UnpackSequence { size: 2 }); // stack: [rest, match]
-            emit!(self, Instruction::CopyItem { index: COPY_TOP }); // duplicate match for truthiness test
+            emit!(self, Instruction::CheckEgMatch);
+            // Stack: [rest, match]
+
+            // Check if match is None (truthy check)
+            emit!(self, Instruction::CopyItem { index: 1 });
             emit!(self, Instruction::ToBool);
             emit!(self, Instruction::PopJumpIfFalse { target: skip_block });
 
-            // Handler selected, stack: [rest, match]
+            // Handler matched - store match to name if provided
+            // Stack: [rest, match]
             if let Some(alias) = name {
                 self.store_name(alias.as_str())?;
             } else {
-                emit!(self, Instruction::Pop);
+                emit!(self, Instruction::PopTop);
             }
+            // Stack: [rest]
 
             self.compile_statements(body)?;
 
@@ -2215,26 +2199,28 @@ impl Compiler {
 
             emit!(self, Instruction::Jump { target: next_block });
 
-            // Skip handler when no match (stack currently [rest, match])
+            // No match - pop match (None) and continue with rest
             self.switch_to_block(skip_block);
-            emit!(self, Instruction::Pop); // drop match
-            emit!(self, Instruction::Jump { target: next_block });
+            emit!(self, Instruction::PopTop); // drop match (None)
+            // Stack: [rest]
 
-            // Continue with remaining exceptions
             self.switch_to_block(next_block);
+            // Stack: [rest] - continue with rest for next handler
         }
 
         let handled_block = self.new_block();
 
-        // If remainder is truthy, re-raise it
-        emit!(self, Instruction::CopyItem { index: COPY_TOP });
+        // Check if remainder is truthy (has unhandled exceptions)
+        // Stack: [rest]
+        emit!(self, Instruction::CopyItem { index: 1 });
         emit!(self, Instruction::ToBool);
         emit!(
             self,
             Instruction::PopJumpIfFalse {
                 target: handled_block
             }
         );
+        // Reraise unhandled exceptions
         emit!(
             self,
             Instruction::Raise {
@@ -2244,7 +2230,7 @@ impl Compiler {
 
         // All exceptions handled
         self.switch_to_block(handled_block);
-        emit!(self, Instruction::Pop); // drop remainder (None)
+        emit!(self, Instruction::PopTop); // drop remainder (None)
         emit!(self, Instruction::PopException);
 
         if !finalbody.is_empty() {

diff --git a/crates/compiler-core/src/bytecode.rs b/crates/compiler-core/src/bytecode.rs
@@ -566,8 +566,6 @@ op_arg_enum!(
         /// Generic subscript for PEP 695
         SubscriptGeneric = 10,
         TypeAlias = 11,
-        /// Ensure an exception is normalized to BaseExceptionGroup
-        EnsureExceptionGroup = 12,
     }
 );
 
@@ -576,14 +574,12 @@ op_arg_enum!(
     #[derive(Copy, Clone, Debug, PartialEq, Eq)]
     #[repr(u8)]
     pub enum IntrinsicFunction2 {
-        // PrepReraiseS tar = 1,
+        PrepReraiseStar = 1,
         TypeVarWithBound = 2,
         TypeVarWithConstraint = 3,
         SetFunctionTypeParams = 4,
         /// Set default value for type parameter (PEP 695)
         SetTypeparamDefault = 5,
-        /// Split an ExceptionGroup according to except* handler condition
-        ExceptStarMatch = 6,
     }
 );
 
@@ -656,6 +652,9 @@ pub enum Instruction {
     CallMethodPositional {
         nargs: Arg<u32>,
     },
+    /// Check if exception matches except* handler type.
+    /// Pops exc_value and match_type, pushes (rest, match).
+    CheckEgMatch,
     CompareOperation {
         op: Arg<ComparisonOperator>,
     },
@@ -1725,6 +1724,7 @@ impl Instruction {
             CallMethodKeyword { nargs } => -1 - (nargs.get(arg) as i32) - 3 + 1,
             CallFunctionEx { has_kwargs } => -1 - (has_kwargs.get(arg) as i32) - 1 + 1,
             CallMethodEx { has_kwargs } => -1 - (has_kwargs.get(arg) as i32) - 3 + 1,
+            CheckEgMatch => 0, // pops 2 (exc, type), pushes 2 (rest, match)
             ConvertValue { .. } => 0,
             FormatSimple => 0,
             FormatWithSpec => -1,
@@ -1891,6 +1891,7 @@ impl Instruction {
             CallMethodEx { has_kwargs } => w!(CALL_METHOD_EX, has_kwargs),
             CallMethodKeyword { nargs } => w!(CALL_METHOD_KEYWORD, nargs),
             CallMethodPositional { nargs } => w!(CALL_METHOD_POSITIONAL, nargs),
+            CheckEgMatch => w!(CHECK_EG_MATCH),
             CompareOperation { op } => w!(COMPARE_OPERATION, ?op),
             ContainsOp(inv) => w!(CONTAINS_OP, ?inv),
             Continue { target } => w!(CONTINUE, target),

diff --git a/crates/vm/src/exceptions.rs b/crates/vm/src/exceptions.rs
@@ -2432,3 +2432,127 @@ pub(super) mod types {
     #[repr(transparent)]
     pub struct PyEncodingWarning(PyWarning);
 }
+
+/// Match exception against except* handler type.
+/// Returns (rest, match) tuple.
+pub fn exception_group_match(
+    exc_value: &PyObjectRef,
+    match_type: &PyObjectRef,
+    vm: &VirtualMachine,
+) -> PyResult<(PyObjectRef, PyObjectRef)> {
+    // Implements _PyEval_ExceptionGroupMatch
+
+    // If exc_value is None, return (None, None)
+    if vm.is_none(exc_value) {
+        return Ok((vm.ctx.none(), vm.ctx.none()));
+    }
+
+    // Check if exc_value matches match_type
+    if exc_value.is_instance(match_type, vm)? {
+        // Full match of exc itself
+        let is_eg = exc_value.fast_isinstance(vm.ctx.exceptions.base_exception_group);
+        let matched = if is_eg {
+            exc_value.clone()
+        } else {
+            // Naked exception - wrap it in ExceptionGroup
+            let excs = vm.ctx.new_tuple(vec![exc_value.clone()]);
+            let eg_type: PyObjectRef = crate::exception_group::exception_group().to_owned().into();
+            let wrapped = eg_type.call((vm.ctx.new_str(""), excs), vm)?;
+            // Copy traceback from original exception
+            if let Ok(exc) = exc_value.clone().downcast::<types::PyBaseException>()
+                && let Some(tb) = exc.__traceback__()
+                && let Ok(wrapped_exc) = wrapped.clone().downcast::<types::PyBaseException>()
+            {
+                let _ = wrapped_exc.set___traceback__(tb.into(), vm);
+            }
+            wrapped
+        };
+        return Ok((vm.ctx.none(), matched));
+    }
+
+    // Check for partial match if it's an exception group
+    if exc_value.fast_isinstance(vm.ctx.exceptions.base_exception_group) {
+        let pair = vm.call_method(exc_value, "split", (match_type.clone(),))?;
+        let pair_tuple: PyTupleRef = pair.try_into_value(vm)?;
+        if pair_tuple.len() < 2 {
+            return Err(vm.new_type_error(format!(
+                "{}.split must return a 2-tuple, got tuple of size {}",
+                exc_value.class().name(),
+                pair_tuple.len()
+            )));
+        }
+        let matched = pair_tuple[0].clone();
+        let rest = pair_tuple[1].clone();
+        return Ok((rest, matched));
+    }
+
+    // No match
+    Ok((exc_value.clone(), vm.ctx.none()))
+}
+
+/// Prepare exception for reraise in except* block.
+pub fn prep_reraise_star(orig: PyObjectRef, excs: PyObjectRef, vm: &VirtualMachine) -> PyResult {
+    // Implements _PyExc_PrepReraiseStar
+    use crate::builtins::PyList;
+
+    let excs_list = excs
+        .downcast::<PyList>()
+        .map_err(|_| vm.new_type_error("expected list for prep_reraise_star"))?;
+
+    let excs_vec: Vec<PyObjectRef> = excs_list.borrow_vec().to_vec();
+
+    // Filter out None values
+    let mut raised: Vec<PyObjectRef> = Vec::new();
+    let mut reraised: Vec<PyObjectRef> = Vec::new();
+
+    for exc in excs_vec {
+        if vm.is_none(&exc) {
+            continue;
+        }
+        // Check if this exception was in the original exception group
+        if !vm.is_none(&orig) && is_same_exception_metadata(&exc, &orig, vm) {
+            reraised.push(exc);
+        } else {
+            raised.push(exc);
+        }
+    }
+
+    // If no exceptions to reraise, return None
+    if raised.is_empty() && reraised.is_empty() {
+        return Ok(vm.ctx.none());
+    }
+
+    // Combine raised and reraised exceptions
+    let mut all_excs = raised;
+    all_excs.extend(reraised);
+
+    if all_excs.len() == 1 {
+        // If only one exception, just return it
+        return Ok(all_excs.into_iter().next().unwrap());
+    }
+
+    // Create new ExceptionGroup
+    let excs_tuple = vm.ctx.new_tuple(all_excs);
+    let eg_type: PyObjectRef = crate::exception_group::exception_group().to_owned().into();
+    eg_type.call((vm.ctx.new_str(""), excs_tuple), vm)
+}
+
+/// Check if two exceptions have the same metadata (for reraise detection)
+fn is_same_exception_metadata(exc1: &PyObjectRef, exc2: &PyObjectRef, vm: &VirtualMachine) -> bool {
+    // Check if exc1 is part of exc2's exception group
+    if exc2.fast_isinstance(vm.ctx.exceptions.base_exception_group) {
+        let exc_class: PyObjectRef = exc1.class().to_owned().into();
+        if let Ok(result) = vm.call_method(exc2, "subgroup", (exc_class,))
+            && !vm.is_none(&result)
+            && let Ok(subgroup_excs) = result.get_attr("exceptions", vm)
+            && let Ok(tuple) = subgroup_excs.downcast::<PyTuple>()
+        {
+            for e in tuple.iter() {
+                if e.is(exc1) {
+                    return true;
+                }
+            }
+        }
+    }
+    exc1.is(exc2)
+}
diff --git a/crates/vm/src/frame.rs b/crates/vm/src/frame.rs
@@ -8,7 +8,7 @@ use crate::{
         tuple::{PyTuple, PyTupleRef},
     },
     bytecode,
-    convert::{IntoObject, ToPyObject, ToPyResult},
+    convert::{IntoObject, ToPyResult},
     coroutine::Coro,
     exceptions::ExceptionCtor,
     function::{ArgMapping, Either, FuncArgs},
@@ -691,6 +691,15 @@ impl ExecutingFrame<'_> {
                 let args = self.collect_positional_args(nargs.get(arg));
                 self.execute_method_call(args, vm)
             }
+            bytecode::Instruction::CheckEgMatch => {
+                let match_type = self.pop_value();
+                let exc_value = self.pop_value();
+                let (rest, matched) =
+                    crate::exceptions::exception_group_match(&exc_value, &match_type, vm)?;
+                self.push_value(rest);
+                self.push_value(matched);
+                Ok(None)
+            }
             bytecode::Instruction::CompareOperation { op } => self.execute_compare(vm, op.get(arg)),
             bytecode::Instruction::ContainsOp(invert) => {
                 let b = self.pop_value();
@@ -2460,18 +2469,6 @@ impl ExecutingFrame<'_> {
                     .map_err(|_| vm.new_type_error("LIST_TO_TUPLE expects a list"))?;
                 Ok(vm.ctx.new_tuple(list.borrow_vec().to_vec()).into())
             }
-            bytecode::IntrinsicFunction1::EnsureExceptionGroup => {
-                if arg.fast_isinstance(vm.ctx.exceptions.base_exception_group) {
-                    Ok(arg)
-                } else {
-                    let exception_group_type = crate::exception_group::exception_group();
-                    let wrapped = exception_group_type
-                        .to_owned()
-                        .to_pyobject(vm)
-                        .call((vm.ctx.new_str(""), vm.ctx.new_tuple(vec![arg])), vm)?;
-                    Ok(wrapped)
-                }
-            }
         }
     }
 
@@ -2506,15 +2503,11 @@ impl ExecutingFrame<'_> {
                         .into();
                 Ok(type_var)
             }
-            bytecode::IntrinsicFunction2::ExceptStarMatch => {
-                let result = vm.call_method(&arg1, "split", (arg2,))?;
-                let result_tuple: PyTupleRef = result.try_into_value(vm)?;
-                if result_tuple.len() != 2 {
-                    return Err(vm.new_type_error("ExceptionGroup.split must return 2-tuple"));
-                }
-                let matched = result_tuple[0].clone();
-                let rest = result_tuple[1].clone();
-                Ok(vm.ctx.new_tuple(vec![matched, rest]).into())
+            bytecode::IntrinsicFunction2::PrepReraiseStar => {
+                // arg1 = orig (original exception)
+                // arg2 = excs (list of exceptions raised/reraised in except* blocks)
+                // Returns: exception to reraise, or None if nothing to reraise
+                crate::exceptions::prep_reraise_star(arg1, arg2, vm)
             }
         }
     }