From 3ebf23e39b1b0b50ee64bb3ad8522e067454801c Mon Sep 17 00:00:00 2001
From: Charlie Marsh <charlie.r.marsh@gmail.com>
Date: Tue, 21 Feb 2023 12:00:33 +0900
Subject: [PATCH] Update Python.asdl from CPython 3.11.1

---
 compiler/ast/Python.asdl    |  1 +
 compiler/ast/src/ast_gen.rs | 17 +++++++++
 vm/src/stdlib/ast/gen.rs    | 69 +++++++++++++++++++++++++++++++++++++
 3 files changed, 87 insertions(+)

diff --git a/compiler/ast/Python.asdl b/compiler/ast/Python.asdl
index 32fdc01a7..e9423a7c9 100644
--- a/compiler/ast/Python.asdl
+++ b/compiler/ast/Python.asdl
@@ -40,6 +40,7 @@ module Python
 
           | Raise(expr? exc, expr? cause)
           | Try(stmt* body, excepthandler* handlers, stmt* orelse, stmt* finalbody)
+          | TryStar(stmt* body, excepthandler* handlers, stmt* orelse, stmt* finalbody)
           | Assert(expr test, expr? msg)
 
           | Import(alias* names)
diff --git a/compiler/ast/src/ast_gen.rs b/compiler/ast/src/ast_gen.rs
index 32dd89c2c..c11fd87da 100644
--- a/compiler/ast/src/ast_gen.rs
+++ b/compiler/ast/src/ast_gen.rs
@@ -139,6 +139,12 @@ pub enum StmtKind<U = ()> {
         orelse: Vec<Stmt<U>>,
         finalbody: Vec<Stmt<U>>,
     },
+    TryStar {
+        body: Vec<Stmt<U>>,
+        handlers: Vec<Excepthandler<U>>,
+        orelse: Vec<Stmt<U>>,
+        finalbody: Vec<Stmt<U>>,
+    },
     Assert {
         test: Box<Expr<U>>,
         msg: Option<Box<Expr<U>>>,
@@ -726,6 +732,17 @@ pub mod fold {
                 orelse: Foldable::fold(orelse, folder)?,
                 finalbody: Foldable::fold(finalbody, folder)?,
             }),
+            StmtKind::TryStar {
+                body,
+                handlers,
+                orelse,
+                finalbody,
+            } => Ok(StmtKind::TryStar {
+                body: Foldable::fold(body, folder)?,
+                handlers: Foldable::fold(handlers, folder)?,
+                orelse: Foldable::fold(orelse, folder)?,
+                finalbody: Foldable::fold(finalbody, folder)?,
+            }),
             StmtKind::Assert { test, msg } => Ok(StmtKind::Assert {
                 test: Foldable::fold(test, folder)?,
                 msg: Foldable::fold(msg, folder)?,
diff --git a/vm/src/stdlib/ast/gen.rs b/vm/src/stdlib/ast/gen.rs
index b2c2c904b..a7244f9be 100644
--- a/vm/src/stdlib/ast/gen.rs
+++ b/vm/src/stdlib/ast/gen.rs
@@ -538,6 +538,34 @@ impl NodeTry {
         );
     }
 }
+#[pyclass(module = "_ast", name = "TryStar", base = "NodeKindStmt")]
+struct NodeTryStar;
+#[pyclass(flags(HAS_DICT, BASETYPE))]
+impl NodeTryStar {
+    #[extend_class]
+    fn extend_class_with_fields(ctx: &Context, class: &'static Py<PyType>) {
+        class.set_attr(
+            identifier!(ctx, _fields),
+            ctx.new_tuple(vec![
+                ctx.new_str(ascii!("body")).into(),
+                ctx.new_str(ascii!("handlers")).into(),
+                ctx.new_str(ascii!("orelse")).into(),
+                ctx.new_str(ascii!("finalbody")).into(),
+            ])
+            .into(),
+        );
+        class.set_attr(
+            identifier!(ctx, _attributes),
+            ctx.new_list(vec![
+                ctx.new_str(ascii!("lineno")).into(),
+                ctx.new_str(ascii!("col_offset")).into(),
+                ctx.new_str(ascii!("end_lineno")).into(),
+                ctx.new_str(ascii!("end_col_offset")).into(),
+            ])
+            .into(),
+        );
+    }
+}
 #[pyclass(module = "_ast", name = "Assert", base = "NodeKindStmt")]
 struct NodeAssert;
 #[pyclass(flags(HAS_DICT, BASETYPE))]
@@ -2635,6 +2663,30 @@ impl Node for ast::StmtKind {
                     .unwrap();
                 _node.into()
             }
+            ast::StmtKind::TryStar {
+                body,
+                handlers,
+                orelse,
+                finalbody,
+            } => {
+                let _node = AstNode
+                    .into_ref_with_type(_vm, NodeTryStar::static_type().to_owned())
+                    .unwrap();
+                let _dict = _node.as_object().dict().unwrap();
+                _dict
+                    .set_item("body", body.ast_to_object(_vm), _vm)
+                    .unwrap();
+                _dict
+                    .set_item("handlers", handlers.ast_to_object(_vm), _vm)
+                    .unwrap();
+                _dict
+                    .set_item("orelse", orelse.ast_to_object(_vm), _vm)
+                    .unwrap();
+                _dict
+                    .set_item("finalbody", finalbody.ast_to_object(_vm), _vm)
+                    .unwrap();
+                _node.into()
+            }
             ast::StmtKind::Assert { test, msg } => {
                 let _node = AstNode
                     .into_ref_with_type(_vm, NodeAssert::static_type().to_owned())
@@ -2928,6 +2980,22 @@ impl Node for ast::StmtKind {
                     get_node_field(_vm, &_object, "finalbody", "stmt")?,
                 )?,
             }
+        } else if _cls.is(NodeTryStar::static_type()) {
+            ast::StmtKind::TryStar {
+                body: Node::ast_from_object(_vm, get_node_field(_vm, &_object, "body", "stmt")?)?,
+                handlers: Node::ast_from_object(
+                    _vm,
+                    get_node_field(_vm, &_object, "handlers", "stmt")?,
+                )?,
+                orelse: Node::ast_from_object(
+                    _vm,
+                    get_node_field(_vm, &_object, "orelse", "stmt")?,
+                )?,
+                finalbody: Node::ast_from_object(
+                    _vm,
+                    get_node_field(_vm, &_object, "finalbody", "stmt")?,
+                )?,
+            }
         } else if _cls.is(NodeAssert::static_type()) {
             ast::StmtKind::Assert {
                 test: Node::ast_from_object(_vm, get_node_field(_vm, &_object, "test", "stmt")?)?,
@@ -4492,6 +4560,7 @@ pub fn extend_module_nodes(vm: &VirtualMachine, module: &PyObject) {
         "Match" => NodeMatch::make_class(&vm.ctx),
         "Raise" => NodeRaise::make_class(&vm.ctx),
         "Try" => NodeTry::make_class(&vm.ctx),
+        "TryStar" => NodeTryStar::make_class(&vm.ctx),
         "Assert" => NodeAssert::make_class(&vm.ctx),
         "Import" => NodeImport::make_class(&vm.ctx),
         "ImportFrom" => NodeImportFrom::make_class(&vm.ctx),