Implement except* syntax

Author: charliermarsh

compiler/codegen/src/compile.rs

@@ -709,6 +709,12 @@ impl Compiler {
                 orelse,
                 finalbody,
             } => self.compile_try_statement(body, handlers, orelse, finalbody)?,
+            TryStar {
+                body,
+                handlers,
+                orelse,
+                finalbody,
+            } => self.compile_try_star_statement(body, handlers, orelse, finalbody)?,
             FunctionDef {
                 name,
                 args,
@@ -1092,6 +1098,16 @@ impl Compiler {
         Ok(())
     }
 
+    fn compile_try_star_statement(
+        &mut self,
+        _body: &[ast::Stmt],
+        _handlers: &[ast::Excepthandler],
+        _orelse: &[ast::Stmt],
+        _finalbody: &[ast::Stmt],
+    ) -> CompileResult<()> {
+        Err(self.error(CodegenErrorType::NotImplementedYet))
+    }
+
     fn is_forbidden_arg_name(name: &str) -> bool {
         is_forbidden_name(name)
     }

compiler/codegen/src/symboltable.rs

@@ -809,6 +809,12 @@ impl SymbolTableBuilder {
                 handlers,
                 orelse,
                 finalbody,
+            }
+            | TryStar {
+                body,
+                handlers,
+                orelse,
+                finalbody,
             } => {
                 self.scan_statements(body)?;
                 for handler in handlers {

compiler/parser/python.lalrpop

@@ -451,6 +451,27 @@ TryStatement: ast::Stmt = {
             },
         }
     },
+    <location:@L> "try" ":" <body:Suite> <handlers:ExceptStarClause+> <else_suite:("else" ":" Suite)?> <finally:("finally" ":" Suite)?> <end_location:@R> => {
+        let orelse = else_suite.map(|s| s.2).unwrap_or_default();
+        let finalbody = finally.map(|s| s.2).unwrap_or_default();
+        let end_location = finalbody
+            .last()
+            .or_else(|| orelse.last())
+            .map(|last| last.end_location)
+            .or_else(|| handlers.last().map(|last| last.end_location))
+            .unwrap();
+        ast::Stmt {
+            custom: (),
+            location,
+            end_location,
+            node: ast::StmtKind::TryStar {
+                body,
+                handlers,
+                orelse,
+                finalbody,
+            },
+        }
+    },
     <location:@L> "try" ":" <body:Suite> <finally:("finally" ":" Suite)> => {
         let handlers = vec![];
         let orelse = vec![];
@@ -470,6 +491,34 @@ TryStatement: ast::Stmt = {
     },
 };
 
+ExceptStarClause: ast::Excepthandler = {
+    <location:@L> "except" "*" <typ:Test<"all">> ":" <body:Suite> => {
+        let end_location = body.last().unwrap().end_location.unwrap();
+        ast::Excepthandler::new(
+            location,
+            end_location,
+            ast::ExcepthandlerKind::ExceptHandler {
+                type_: Some(Box::new(typ)),
+                name: None,
+                body,
+            },
+        )
+    },
+    <location:@L> "except" "*" <x:(Test<"all"> "as" Identifier)> ":" <body:Suite> => {
+        let end_location = body.last().unwrap().end_location.unwrap();
+        ast::Excepthandler::new(
+            location,
+            end_location,
+            ast::ExcepthandlerKind::ExceptHandler {
+                type_: Some(Box::new(x.0)),
+                name: Some(x.2),
+                body,
+            },
+        )
+    },
+};
+
+
 ExceptClause: ast::Excepthandler = {
     <location:@L> "except" <typ:Test<"all">?> ":" <body:Suite> => {
         let end_location = body.last().unwrap().end_location.unwrap();

compiler/parser/src/parser.rs

@@ -405,6 +405,37 @@ with (0 as a, 1 as b,): pass
         insta::assert_debug_snapshot!(parse_ast);
     }
 
+    #[test]
+    fn test_try() {
+        let parse_ast = parse_program(
+            r#"try:
+    raise ValueError(1)
+except TypeError as e:
+    print(f'caught {type(e)}')
+except OSError as e:
+    print(f'caught {type(e)}')"#,
+            "<test>",
+        )
+        .unwrap();
+        insta::assert_debug_snapshot!(parse_ast);
+    }
+
+    #[test]
+    fn test_try_star() {
+        let parse_ast = parse_program(
+            r#"try:
+    raise ExceptionGroup("eg",
+        [ValueError(1), TypeError(2), OSError(3), OSError(4)])
+except* TypeError as e:
+    print(f'caught {type(e)} with nested {e.exceptions}')
+except* OSError as e:
+    print(f'caught {type(e)} with nested {e.exceptions}')"#,
+            "<test>",
+        )
+        .unwrap();
+        insta::assert_debug_snapshot!(parse_ast);
+    }
+
     #[test]
     fn test_dict_unpacking() {
         let parse_ast = parse_expression(r#"{"a": "b", **c, "d": "e"}"#, "<test>").unwrap();