Implement except* handling and starred subscript support

Co-authored-by: youknowone <69878+youknowone@users.noreply.github.com>
RustPython · youknowone · Dec 26, 2025 · Dec 25, 2025 · Dec 25, 2025 · Dec 25, 2025
commit 1e9ab2a8972a80689f8dc05ece71fe29dcf941a7
diff --git a/crates/codegen/src/compile.rs b/crates/codegen/src/compile.rs
@@ -471,7 +471,16 @@ impl Compiler {
             }
         } else {
             // VISIT(c, expr, e->v.Subscript.slice)
-            self.compile_expression(slice)?;
+            match slice {
+                Expr::Starred(starred) => {
+                    self.starunpack_helper(
+                        &[Expr::Starred(starred.clone())],
+                        0,
+                        CollectionType::Tuple,
+                    )?;
+                }
+                other => self.compile_expression(other)?,
+            }
 
             // Emit appropriate instruction based on context
             match ctx {
@@ -2121,12 +2130,150 @@ impl Compiler {
 
     fn compile_try_star_statement(
         &mut self,
-        _body: &[Stmt],
-        _handlers: &[ExceptHandler],
-        _orelse: &[Stmt],
-        _finalbody: &[Stmt],
+        body: &[Stmt],
+        handlers: &[ExceptHandler],
+        orelse: &[Stmt],
+        finalbody: &[Stmt],
     ) -> CompileResult<()> {
-        Err(self.error(CodegenErrorType::NotImplementedYet))
+        let handler_block = self.new_block();
+        let finally_block = self.new_block();
+
+        if !finalbody.is_empty() {
+            emit!(
+                self,
+                Instruction::SetupFinally {
+                    handler: finally_block,
+                }
+            );
+        }
+
+        let else_block = self.new_block();
+
+        emit!(
+            self,
+            Instruction::SetupExcept {
+                handler: handler_block,
+            }
+        );
+        self.compile_statements(body)?;
+        emit!(self, Instruction::PopBlock);
+        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]
+
+        for handler in handlers {
+            let ExceptHandler::ExceptHandler(ExceptHandlerExceptHandler {
+                type_, name, body, ..
+            }) = handler;
+
+            let skip_block = self.new_block();
+            let next_block = self.new_block();
+
+            // Split current remainder for this handler
+            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(),
+                )));
+            }
+
+            emit!(
+                self,
+                Instruction::CallIntrinsic2 {
+                    func: bytecode::IntrinsicFunction2::ExceptStarMatch
+                }
+            );
+            emit!(self, Instruction::UnpackSequence { size: 2 }); // stack: [rest, match]
+            emit!(self, Instruction::CopyItem { index: 1_u32 }); // duplicate match for truthiness test
+            emit!(self, Instruction::ToBool);
+            emit!(self, Instruction::PopJumpIfFalse { target: skip_block });
+
+            // Handler selected, stack: [rest, match]
+            if let Some(alias) = name {
+                self.store_name(alias.as_str())?;
+            } else {
+                emit!(self, Instruction::Pop);
+            }
+
+            self.compile_statements(body)?;
+
+            if let Some(alias) = name {
+                self.emit_load_const(ConstantData::None);
+                self.store_name(alias.as_str())?;
+                self.compile_name(alias.as_str(), NameUsage::Delete)?;
+            }
+
+            emit!(self, Instruction::Jump { target: next_block });
+
+            // Skip handler when no match (stack currently [rest, match])
+            self.switch_to_block(skip_block);
+            emit!(self, Instruction::Pop); // drop match
+            emit!(self, Instruction::Jump { target: next_block });
+
+            // Continue with remaining exceptions
+            self.switch_to_block(next_block);
+        }
+
+        let handled_block = self.new_block();
+
+        // If remainder is truthy, re-raise it
+        emit!(self, Instruction::CopyItem { index: 1_u32 });
+        emit!(self, Instruction::ToBool);
+        emit!(
+            self,
+            Instruction::PopJumpIfFalse {
+                target: handled_block
+            }
+        );
+        emit!(
+            self,
+            Instruction::Raise {
+                kind: bytecode::RaiseKind::Raise
+            }
+        );
+
+        // All exceptions handled
+        self.switch_to_block(handled_block);
+        emit!(self, Instruction::Pop); // drop remainder (None)
+        emit!(self, Instruction::PopException);
+
+        if !finalbody.is_empty() {
+            emit!(self, Instruction::PopBlock);
+            emit!(self, Instruction::EnterFinally);
+        }
+
+        emit!(
+            self,
+            Instruction::Jump {
+                target: finally_block,
+            }
+        );
+
+        // try-else path
+        self.switch_to_block(else_block);
+        self.compile_statements(orelse)?;
+
+        if !finalbody.is_empty() {
+            emit!(self, Instruction::PopBlock);
+            emit!(self, Instruction::EnterFinally);
+        }
+
+        self.switch_to_block(finally_block);
+        if !finalbody.is_empty() {
+            self.compile_statements(finalbody)?;
+            emit!(self, Instruction::EndFinally);
+        }
+
+        Ok(())
     }
 
     fn is_forbidden_arg_name(name: &str) -> bool {

diff --git a/crates/compiler-core/src/bytecode.rs b/crates/compiler-core/src/bytecode.rs
@@ -566,6 +566,8 @@ op_arg_enum!(
         /// Generic subscript for PEP 695
         SubscriptGeneric = 10,
         TypeAlias = 11,
+        /// Ensure an exception is normalized to BaseExceptionGroup
+        EnsureExceptionGroup = 12,
     }
 );
 
@@ -580,6 +582,8 @@ op_arg_enum!(
         SetFunctionTypeParams = 4,
         /// Set default value for type parameter (PEP 695)
         SetTypeparamDefault = 5,
+        /// Split an ExceptionGroup according to except* handler condition
+        ExceptStarMatch = 6,
     }
 );
 

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, ToPyResult},
+    convert::{IntoObject, ToPyObject, ToPyResult},
     coroutine::Coro,
     exceptions::ExceptionCtor,
     function::{ArgMapping, Either, FuncArgs},
@@ -2460,6 +2460,18 @@ 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)
+                }
+            }
         }
     }
 
@@ -2494,6 +2506,16 @@ 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())
+            }
         }
     }
 

diff --git a/extra_tests/snippets/except_star_and_starred_index.py b/extra_tests/snippets/except_star_and_starred_index.py
@@ -0,0 +1,19 @@
+def test_except_star_with_plain_exception():
+    try:
+        raise ValueError("x")
+    except* ValueError as err:
+        assert isinstance(err, ExceptionGroup)
+        assert err.exceptions == (ValueError("x"),)
+    else:
+        raise AssertionError("except* handler did not run")
+
+
+def test_starred_index_builds_tuple():
+    target = {}
+    target[*"ab"] = 1
+    assert list(target.items()) == [(("a", "b"), 1)]
+
+
+if __name__ == "__main__":
+    test_except_star_with_plain_exception()
+    test_starred_index_builds_tuple()