bpo-41746: Add type information to asdl_seq objects (GH-22223)

* Add new capability to the PEG parser to type variable assignments. For instance:
```
       | a[asdl_stmt_seq*]=';'.small_stmt+ [';'] NEWLINE { a }
```

* Add new sequence types from the asdl definition (automatically generated)
* Make `asdl_seq` type a generic aliasing pointer type.
* Create a new `asdl_generic_seq` for the generic case using `void*`.
* The old `asdl_seq_GET`/`ast_seq_SET` macros now are typed.
* New `asdl_seq_GET_UNTYPED`/`ast_seq_SET_UNTYPED` macros for dealing with generic sequences.
* Changes all possible `asdl_seq` types to use specific versions everywhere.

1 files changed, 221 insertions, 135 deletions

diff --git a/Include/Python-ast.h b/Include/Python-ast.h
index e7afa1e..e14bab5 100644
--- a/Include/Python-ast.h
+++ b/Include/Python-ast.h
@@ -47,18 +47,99 @@ typedef struct _withitem *withitem_ty;
 typedef struct _type_ignore *type_ignore_ty;
 
 
+typedef struct {
+    _ASDL_SEQ_HEAD
+    mod_ty typed_elements[1];
+} asdl_mod_seq;
+
+asdl_mod_seq *_Py_asdl_mod_seq_new(Py_ssize_t size, PyArena *arena);
+
+typedef struct {
+    _ASDL_SEQ_HEAD
+    stmt_ty typed_elements[1];
+} asdl_stmt_seq;
+
+asdl_stmt_seq *_Py_asdl_stmt_seq_new(Py_ssize_t size, PyArena *arena);
+
+typedef struct {
+    _ASDL_SEQ_HEAD
+    expr_ty typed_elements[1];
+} asdl_expr_seq;
+
+asdl_expr_seq *_Py_asdl_expr_seq_new(Py_ssize_t size, PyArena *arena);
+
+typedef struct {
+    _ASDL_SEQ_HEAD
+    comprehension_ty typed_elements[1];
+} asdl_comprehension_seq;
+
+asdl_comprehension_seq *_Py_asdl_comprehension_seq_new(Py_ssize_t size, PyArena
+                                                       *arena);
+
+typedef struct {
+    _ASDL_SEQ_HEAD
+    excepthandler_ty typed_elements[1];
+} asdl_excepthandler_seq;
+
+asdl_excepthandler_seq *_Py_asdl_excepthandler_seq_new(Py_ssize_t size, PyArena
+                                                       *arena);
+
+typedef struct {
+    _ASDL_SEQ_HEAD
+    arguments_ty typed_elements[1];
+} asdl_arguments_seq;
+
+asdl_arguments_seq *_Py_asdl_arguments_seq_new(Py_ssize_t size, PyArena *arena);
+
+typedef struct {
+    _ASDL_SEQ_HEAD
+    arg_ty typed_elements[1];
+} asdl_arg_seq;
+
+asdl_arg_seq *_Py_asdl_arg_seq_new(Py_ssize_t size, PyArena *arena);
+
+typedef struct {
+    _ASDL_SEQ_HEAD
+    keyword_ty typed_elements[1];
+} asdl_keyword_seq;
+
+asdl_keyword_seq *_Py_asdl_keyword_seq_new(Py_ssize_t size, PyArena *arena);
+
+typedef struct {
+    _ASDL_SEQ_HEAD
+    alias_ty typed_elements[1];
+} asdl_alias_seq;
+
+asdl_alias_seq *_Py_asdl_alias_seq_new(Py_ssize_t size, PyArena *arena);
+
+typedef struct {
+    _ASDL_SEQ_HEAD
+    withitem_ty typed_elements[1];
+} asdl_withitem_seq;
+
+asdl_withitem_seq *_Py_asdl_withitem_seq_new(Py_ssize_t size, PyArena *arena);
+
+typedef struct {
+    _ASDL_SEQ_HEAD
+    type_ignore_ty typed_elements[1];
+} asdl_type_ignore_seq;
+
+asdl_type_ignore_seq *_Py_asdl_type_ignore_seq_new(Py_ssize_t size, PyArena
+                                                   *arena);
+
+
 enum _mod_kind {Module_kind=1, Interactive_kind=2, Expression_kind=3,
                  FunctionType_kind=4};
 struct _mod {
     enum _mod_kind kind;
     union {
         struct {
-            asdl_seq *body;
-            asdl_seq *type_ignores;
+            asdl_stmt_seq *body;
+            asdl_type_ignore_seq *type_ignores;
         } Module;
 
         struct {
-            asdl_seq *body;
+            asdl_stmt_seq *body;
         } Interactive;
 
         struct {
@@ -66,7 +147,7 @@ struct _mod {
         } Expression;
 
         struct {
-            asdl_seq *argtypes;
+            asdl_expr_seq *argtypes;
             expr_ty returns;
         } FunctionType;
 
@@ -87,8 +168,8 @@ struct _stmt {
         struct {
             identifier name;
             arguments_ty args;
-            asdl_seq *body;
-            asdl_seq *decorator_list;
+            asdl_stmt_seq *body;
+            asdl_expr_seq *decorator_list;
             expr_ty returns;
             string type_comment;
         } FunctionDef;
@@ -96,18 +177,18 @@ struct _stmt {
         struct {
             identifier name;
             arguments_ty args;
-            asdl_seq *body;
-            asdl_seq *decorator_list;
+            asdl_stmt_seq *body;
+            asdl_expr_seq *decorator_list;
             expr_ty returns;
             string type_comment;
         } AsyncFunctionDef;
 
         struct {
             identifier name;
-            asdl_seq *bases;
-            asdl_seq *keywords;
-            asdl_seq *body;
-            asdl_seq *decorator_list;
+            asdl_expr_seq *bases;
+            asdl_keyword_seq *keywords;
+            asdl_stmt_seq *body;
+            asdl_expr_seq *decorator_list;
         } ClassDef;
 
         struct {
@@ -115,11 +196,11 @@ struct _stmt {
         } Return;
 
         struct {
-            asdl_seq *targets;
+            asdl_expr_seq *targets;
         } Delete;
 
         struct {
-            asdl_seq *targets;
+            asdl_expr_seq *targets;
             expr_ty value;
             string type_comment;
         } Assign;
@@ -140,40 +221,40 @@ struct _stmt {
         struct {
             expr_ty target;
             expr_ty iter;
-            asdl_seq *body;
-            asdl_seq *orelse;
+            asdl_stmt_seq *body;
+            asdl_stmt_seq *orelse;
             string type_comment;
         } For;
 
         struct {
             expr_ty target;
             expr_ty iter;
-            asdl_seq *body;
-            asdl_seq *orelse;
+            asdl_stmt_seq *body;
+            asdl_stmt_seq *orelse;
             string type_comment;
         } AsyncFor;
 
         struct {
             expr_ty test;
-            asdl_seq *body;
-            asdl_seq *orelse;
+            asdl_stmt_seq *body;
+            asdl_stmt_seq *orelse;
         } While;
 
         struct {
             expr_ty test;
-            asdl_seq *body;
-            asdl_seq *orelse;
+            asdl_stmt_seq *body;
+            asdl_stmt_seq *orelse;
         } If;
 
         struct {
-            asdl_seq *items;
-            asdl_seq *body;
+            asdl_withitem_seq *items;
+            asdl_stmt_seq *body;
             string type_comment;
         } With;
 
         struct {
-            asdl_seq *items;
-            asdl_seq *body;
+            asdl_withitem_seq *items;
+            asdl_stmt_seq *body;
             string type_comment;
         } AsyncWith;
 
@@ -183,10 +264,10 @@ struct _stmt {
         } Raise;
 
         struct {
-            asdl_seq *body;
-            asdl_seq *handlers;
-            asdl_seq *orelse;
-            asdl_seq *finalbody;
+            asdl_stmt_seq *body;
+            asdl_excepthandler_seq *handlers;
+            asdl_stmt_seq *orelse;
+            asdl_stmt_seq *finalbody;
         } Try;
 
         struct {
@@ -195,21 +276,21 @@ struct _stmt {
         } Assert;
 
         struct {
-            asdl_seq *names;
+            asdl_alias_seq *names;
         } Import;
 
         struct {
             identifier module;
-            asdl_seq *names;
+            asdl_alias_seq *names;
             int level;
         } ImportFrom;
 
         struct {
-            asdl_seq *names;
+            asdl_identifier_seq *names;
         } Global;
 
         struct {
-            asdl_seq *names;
+            asdl_identifier_seq *names;
         } Nonlocal;
 
         struct {
@@ -236,7 +317,7 @@ struct _expr {
     union {
         struct {
             boolop_ty op;
-            asdl_seq *values;
+            asdl_expr_seq *values;
         } BoolOp;
 
         struct {
@@ -267,33 +348,33 @@ struct _expr {
         } IfExp;
 
         struct {
-            asdl_seq *keys;
-            asdl_seq *values;
+            asdl_expr_seq *keys;
+            asdl_expr_seq *values;
         } Dict;
 
         struct {
-            asdl_seq *elts;
+            asdl_expr_seq *elts;
         } Set;
 
         struct {
             expr_ty elt;
-            asdl_seq *generators;
+            asdl_comprehension_seq *generators;
         } ListComp;
 
         struct {
             expr_ty elt;
-            asdl_seq *generators;
+            asdl_comprehension_seq *generators;
         } SetComp;
 
         struct {
             expr_ty key;
             expr_ty value;
-            asdl_seq *generators;
+            asdl_comprehension_seq *generators;
         } DictComp;
 
         struct {
             expr_ty elt;
-            asdl_seq *generators;
+            asdl_comprehension_seq *generators;
         } GeneratorExp;
 
         struct {
@@ -311,13 +392,13 @@ struct _expr {
         struct {
             expr_ty left;
             asdl_int_seq *ops;
-            asdl_seq *comparators;
+            asdl_expr_seq *comparators;
         } Compare;
 
         struct {
             expr_ty func;
-            asdl_seq *args;
-            asdl_seq *keywords;
+            asdl_expr_seq *args;
+            asdl_keyword_seq *keywords;
         } Call;
 
         struct {
@@ -327,7 +408,7 @@ struct _expr {
         } FormattedValue;
 
         struct {
-            asdl_seq *values;
+            asdl_expr_seq *values;
         } JoinedStr;
 
         struct {
@@ -358,12 +439,12 @@ struct _expr {
         } Name;
 
         struct {
-            asdl_seq *elts;
+            asdl_expr_seq *elts;
             expr_context_ty ctx;
         } List;
 
         struct {
-            asdl_seq *elts;
+            asdl_expr_seq *elts;
             expr_context_ty ctx;
         } Tuple;
 
@@ -383,7 +464,7 @@ struct _expr {
 struct _comprehension {
     expr_ty target;
     expr_ty iter;
-    asdl_seq *ifs;
+    asdl_expr_seq *ifs;
     int is_async;
 };
 
@@ -394,7 +475,7 @@ struct _excepthandler {
         struct {
             expr_ty type;
             identifier name;
-            asdl_seq *body;
+            asdl_stmt_seq *body;
         } ExceptHandler;
 
     } v;
@@ -405,13 +486,13 @@ struct _excepthandler {
 };
 
 struct _arguments {
-    asdl_seq *posonlyargs;
-    asdl_seq *args;
+    asdl_arg_seq *posonlyargs;
+    asdl_arg_seq *args;
     arg_ty vararg;
-    asdl_seq *kwonlyargs;
-    asdl_seq *kw_defaults;
+    asdl_arg_seq *kwonlyargs;
+    asdl_expr_seq *kw_defaults;
     arg_ty kwarg;
-    asdl_seq *defaults;
+    asdl_expr_seq *defaults;
 };
 
 struct _arg {
@@ -458,39 +539,41 @@ struct _type_ignore {
 
 // Note: these macros affect function definitions, not only call sites.
 #define Module(a0, a1, a2) _Py_Module(a0, a1, a2)
-mod_ty _Py_Module(asdl_seq * body, asdl_seq * type_ignores, PyArena *arena);
+mod_ty _Py_Module(asdl_stmt_seq * body, asdl_type_ignore_seq * type_ignores,
+                  PyArena *arena);
 #define Interactive(a0, a1) _Py_Interactive(a0, a1)
-mod_ty _Py_Interactive(asdl_seq * body, PyArena *arena);
+mod_ty _Py_Interactive(asdl_stmt_seq * body, PyArena *arena);
 #define Expression(a0, a1) _Py_Expression(a0, a1)
 mod_ty _Py_Expression(expr_ty body, PyArena *arena);
 #define FunctionType(a0, a1, a2) _Py_FunctionType(a0, a1, a2)
-mod_ty _Py_FunctionType(asdl_seq * argtypes, expr_ty returns, PyArena *arena);
+mod_ty _Py_FunctionType(asdl_expr_seq * argtypes, expr_ty returns, PyArena
+                        *arena);
 #define FunctionDef(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10) _Py_FunctionDef(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10)
-stmt_ty _Py_FunctionDef(identifier name, arguments_ty args, asdl_seq * body,
-                        asdl_seq * decorator_list, expr_ty returns, string
-                        type_comment, int lineno, int col_offset, int
+stmt_ty _Py_FunctionDef(identifier name, arguments_ty args, asdl_stmt_seq *
+                        body, asdl_expr_seq * decorator_list, expr_ty returns,
+                        string type_comment, int lineno, int col_offset, int
                         end_lineno, int end_col_offset, PyArena *arena);
 #define AsyncFunctionDef(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10) _Py_AsyncFunctionDef(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10)
-stmt_ty _Py_AsyncFunctionDef(identifier name, arguments_ty args, asdl_seq *
-                             body, asdl_seq * decorator_list, expr_ty returns,
-                             string type_comment, int lineno, int col_offset,
-                             int end_lineno, int end_col_offset, PyArena
-                             *arena);
+stmt_ty _Py_AsyncFunctionDef(identifier name, arguments_ty args, asdl_stmt_seq
+                             * body, asdl_expr_seq * decorator_list, expr_ty
+                             returns, string type_comment, int lineno, int
+                             col_offset, int end_lineno, int end_col_offset,
+                             PyArena *arena);
 #define ClassDef(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9) _Py_ClassDef(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9)
-stmt_ty _Py_ClassDef(identifier name, asdl_seq * bases, asdl_seq * keywords,
-                     asdl_seq * body, asdl_seq * decorator_list, int lineno,
-                     int col_offset, int end_lineno, int end_col_offset,
-                     PyArena *arena);
+stmt_ty _Py_ClassDef(identifier name, asdl_expr_seq * bases, asdl_keyword_seq *
+                     keywords, asdl_stmt_seq * body, asdl_expr_seq *
+                     decorator_list, int lineno, int col_offset, int
+                     end_lineno, int end_col_offset, PyArena *arena);
 #define Return(a0, a1, a2, a3, a4, a5) _Py_Return(a0, a1, a2, a3, a4, a5)
 stmt_ty _Py_Return(expr_ty value, int lineno, int col_offset, int end_lineno,
                    int end_col_offset, PyArena *arena);
 #define Delete(a0, a1, a2, a3, a4, a5) _Py_Delete(a0, a1, a2, a3, a4, a5)
-stmt_ty _Py_Delete(asdl_seq * targets, int lineno, int col_offset, int
+stmt_ty _Py_Delete(asdl_expr_seq * targets, int lineno, int col_offset, int
                    end_lineno, int end_col_offset, PyArena *arena);
 #define Assign(a0, a1, a2, a3, a4, a5, a6, a7) _Py_Assign(a0, a1, a2, a3, a4, a5, a6, a7)
-stmt_ty _Py_Assign(asdl_seq * targets, expr_ty value, string type_comment, int
-                   lineno, int col_offset, int end_lineno, int end_col_offset,
-                   PyArena *arena);
+stmt_ty _Py_Assign(asdl_expr_seq * targets, expr_ty value, string type_comment,
+                   int lineno, int col_offset, int end_lineno, int
+                   end_col_offset, PyArena *arena);
 #define AugAssign(a0, a1, a2, a3, a4, a5, a6, a7) _Py_AugAssign(a0, a1, a2, a3, a4, a5, a6, a7)
 stmt_ty _Py_AugAssign(expr_ty target, operator_ty op, expr_ty value, int
                       lineno, int col_offset, int end_lineno, int
@@ -500,52 +583,54 @@ stmt_ty _Py_AnnAssign(expr_ty target, expr_ty annotation, expr_ty value, int
                       simple, int lineno, int col_offset, int end_lineno, int
                       end_col_offset, PyArena *arena);
 #define For(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9) _Py_For(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9)
-stmt_ty _Py_For(expr_ty target, expr_ty iter, asdl_seq * body, asdl_seq *
-                orelse, string type_comment, int lineno, int col_offset, int
-                end_lineno, int end_col_offset, PyArena *arena);
+stmt_ty _Py_For(expr_ty target, expr_ty iter, asdl_stmt_seq * body,
+                asdl_stmt_seq * orelse, string type_comment, int lineno, int
+                col_offset, int end_lineno, int end_col_offset, PyArena *arena);
 #define AsyncFor(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9) _Py_AsyncFor(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9)
-stmt_ty _Py_AsyncFor(expr_ty target, expr_ty iter, asdl_seq * body, asdl_seq *
-                     orelse, string type_comment, int lineno, int col_offset,
-                     int end_lineno, int end_col_offset, PyArena *arena);
+stmt_ty _Py_AsyncFor(expr_ty target, expr_ty iter, asdl_stmt_seq * body,
+                     asdl_stmt_seq * orelse, string type_comment, int lineno,
+                     int col_offset, int end_lineno, int end_col_offset,
+                     PyArena *arena);
 #define While(a0, a1, a2, a3, a4, a5, a6, a7) _Py_While(a0, a1, a2, a3, a4, a5, a6, a7)
-stmt_ty _Py_While(expr_ty test, asdl_seq * body, asdl_seq * orelse, int lineno,
-                  int col_offset, int end_lineno, int end_col_offset, PyArena
-                  *arena);
+stmt_ty _Py_While(expr_ty test, asdl_stmt_seq * body, asdl_stmt_seq * orelse,
+                  int lineno, int col_offset, int end_lineno, int
+                  end_col_offset, PyArena *arena);
 #define If(a0, a1, a2, a3, a4, a5, a6, a7) _Py_If(a0, a1, a2, a3, a4, a5, a6, a7)
-stmt_ty _Py_If(expr_ty test, asdl_seq * body, asdl_seq * orelse, int lineno,
-               int col_offset, int end_lineno, int end_col_offset, PyArena
-               *arena);
+stmt_ty _Py_If(expr_ty test, asdl_stmt_seq * body, asdl_stmt_seq * orelse, int
+               lineno, int col_offset, int end_lineno, int end_col_offset,
+               PyArena *arena);
 #define With(a0, a1, a2, a3, a4, a5, a6, a7) _Py_With(a0, a1, a2, a3, a4, a5, a6, a7)
-stmt_ty _Py_With(asdl_seq * items, asdl_seq * body, string type_comment, int
-                 lineno, int col_offset, int end_lineno, int end_col_offset,
-                 PyArena *arena);
+stmt_ty _Py_With(asdl_withitem_seq * items, asdl_stmt_seq * body, string
+                 type_comment, int lineno, int col_offset, int end_lineno, int
+                 end_col_offset, PyArena *arena);
 #define AsyncWith(a0, a1, a2, a3, a4, a5, a6, a7) _Py_AsyncWith(a0, a1, a2, a3, a4, a5, a6, a7)
-stmt_ty _Py_AsyncWith(asdl_seq * items, asdl_seq * body, string type_comment,
-                      int lineno, int col_offset, int end_lineno, int
-                      end_col_offset, PyArena *arena);
+stmt_ty _Py_AsyncWith(asdl_withitem_seq * items, asdl_stmt_seq * body, string
+                      type_comment, int lineno, int col_offset, int end_lineno,
+                      int end_col_offset, PyArena *arena);
 #define Raise(a0, a1, a2, a3, a4, a5, a6) _Py_Raise(a0, a1, a2, a3, a4, a5, a6)
 stmt_ty _Py_Raise(expr_ty exc, expr_ty cause, int lineno, int col_offset, int
                   end_lineno, int end_col_offset, PyArena *arena);
 #define Try(a0, a1, a2, a3, a4, a5, a6, a7, a8) _Py_Try(a0, a1, a2, a3, a4, a5, a6, a7, a8)
-stmt_ty _Py_Try(asdl_seq * body, asdl_seq * handlers, asdl_seq * orelse,
-                asdl_seq * finalbody, int lineno, int col_offset, int
-                end_lineno, int end_col_offset, PyArena *arena);
+stmt_ty _Py_Try(asdl_stmt_seq * body, asdl_excepthandler_seq * handlers,
+                asdl_stmt_seq * orelse, asdl_stmt_seq * finalbody, int lineno,
+                int col_offset, int end_lineno, int end_col_offset, PyArena
+                *arena);
 #define Assert(a0, a1, a2, a3, a4, a5, a6) _Py_Assert(a0, a1, a2, a3, a4, a5, a6)
 stmt_ty _Py_Assert(expr_ty test, expr_ty msg, int lineno, int col_offset, int
                    end_lineno, int end_col_offset, PyArena *arena);
 #define Import(a0, a1, a2, a3, a4, a5) _Py_Import(a0, a1, a2, a3, a4, a5)
-stmt_ty _Py_Import(asdl_seq * names, int lineno, int col_offset, int
+stmt_ty _Py_Import(asdl_alias_seq * names, int lineno, int col_offset, int
                    end_lineno, int end_col_offset, PyArena *arena);
 #define ImportFrom(a0, a1, a2, a3, a4, a5, a6, a7) _Py_ImportFrom(a0, a1, a2, a3, a4, a5, a6, a7)
-stmt_ty _Py_ImportFrom(identifier module, asdl_seq * names, int level, int
-                       lineno, int col_offset, int end_lineno, int
+stmt_ty _Py_ImportFrom(identifier module, asdl_alias_seq * names, int level,
+                       int lineno, int col_offset, int end_lineno, int
                        end_col_offset, PyArena *arena);
 #define Global(a0, a1, a2, a3, a4, a5) _Py_Global(a0, a1, a2, a3, a4, a5)
-stmt_ty _Py_Global(asdl_seq * names, int lineno, int col_offset, int
+stmt_ty _Py_Global(asdl_identifier_seq * names, int lineno, int col_offset, int
                    end_lineno, int end_col_offset, PyArena *arena);
 #define Nonlocal(a0, a1, a2, a3, a4, a5) _Py_Nonlocal(a0, a1, a2, a3, a4, a5)
-stmt_ty _Py_Nonlocal(asdl_seq * names, int lineno, int col_offset, int
-                     end_lineno, int end_col_offset, PyArena *arena);
+stmt_ty _Py_Nonlocal(asdl_identifier_seq * names, int lineno, int col_offset,
+                     int end_lineno, int end_col_offset, PyArena *arena);
 #define Expr(a0, a1, a2, a3, a4, a5) _Py_Expr(a0, a1, a2, a3, a4, a5)
 stmt_ty _Py_Expr(expr_ty value, int lineno, int col_offset, int end_lineno, int
                  end_col_offset, PyArena *arena);
@@ -559,8 +644,9 @@ stmt_ty _Py_Break(int lineno, int col_offset, int end_lineno, int
 stmt_ty _Py_Continue(int lineno, int col_offset, int end_lineno, int
                      end_col_offset, PyArena *arena);
 #define BoolOp(a0, a1, a2, a3, a4, a5, a6) _Py_BoolOp(a0, a1, a2, a3, a4, a5, a6)
-expr_ty _Py_BoolOp(boolop_ty op, asdl_seq * values, int lineno, int col_offset,
-                   int end_lineno, int end_col_offset, PyArena *arena);
+expr_ty _Py_BoolOp(boolop_ty op, asdl_expr_seq * values, int lineno, int
+                   col_offset, int end_lineno, int end_col_offset, PyArena
+                   *arena);
 #define NamedExpr(a0, a1, a2, a3, a4, a5, a6) _Py_NamedExpr(a0, a1, a2, a3, a4, a5, a6)
 expr_ty _Py_NamedExpr(expr_ty target, expr_ty value, int lineno, int
                       col_offset, int end_lineno, int end_col_offset, PyArena
@@ -580,28 +666,28 @@ expr_ty _Py_IfExp(expr_ty test, expr_ty body, expr_ty orelse, int lineno, int
                   col_offset, int end_lineno, int end_col_offset, PyArena
                   *arena);
 #define Dict(a0, a1, a2, a3, a4, a5, a6) _Py_Dict(a0, a1, a2, a3, a4, a5, a6)
-expr_ty _Py_Dict(asdl_seq * keys, asdl_seq * values, int lineno, int
+expr_ty _Py_Dict(asdl_expr_seq * keys, asdl_expr_seq * values, int lineno, int
                  col_offset, int end_lineno, int end_col_offset, PyArena
                  *arena);
 #define Set(a0, a1, a2, a3, a4, a5) _Py_Set(a0, a1, a2, a3, a4, a5)
-expr_ty _Py_Set(asdl_seq * elts, int lineno, int col_offset, int end_lineno,
-                int end_col_offset, PyArena *arena);
+expr_ty _Py_Set(asdl_expr_seq * elts, int lineno, int col_offset, int
+                end_lineno, int end_col_offset, PyArena *arena);
 #define ListComp(a0, a1, a2, a3, a4, a5, a6) _Py_ListComp(a0, a1, a2, a3, a4, a5, a6)
-expr_ty _Py_ListComp(expr_ty elt, asdl_seq * generators, int lineno, int
-                     col_offset, int end_lineno, int end_col_offset, PyArena
-                     *arena);
-#define SetComp(a0, a1, a2, a3, a4, a5, a6) _Py_SetComp(a0, a1, a2, a3, a4, a5, a6)
-expr_ty _Py_SetComp(expr_ty elt, asdl_seq * generators, int lineno, int
-                    col_offset, int end_lineno, int end_col_offset, PyArena
-                    *arena);
-#define DictComp(a0, a1, a2, a3, a4, a5, a6, a7) _Py_DictComp(a0, a1, a2, a3, a4, a5, a6, a7)
-expr_ty _Py_DictComp(expr_ty key, expr_ty value, asdl_seq * generators, int
+expr_ty _Py_ListComp(expr_ty elt, asdl_comprehension_seq * generators, int
                      lineno, int col_offset, int end_lineno, int
                      end_col_offset, PyArena *arena);
+#define SetComp(a0, a1, a2, a3, a4, a5, a6) _Py_SetComp(a0, a1, a2, a3, a4, a5, a6)
+expr_ty _Py_SetComp(expr_ty elt, asdl_comprehension_seq * generators, int
+                    lineno, int col_offset, int end_lineno, int end_col_offset,
+                    PyArena *arena);
+#define DictComp(a0, a1, a2, a3, a4, a5, a6, a7) _Py_DictComp(a0, a1, a2, a3, a4, a5, a6, a7)
+expr_ty _Py_DictComp(expr_ty key, expr_ty value, asdl_comprehension_seq *
+                     generators, int lineno, int col_offset, int end_lineno,
+                     int end_col_offset, PyArena *arena);
 #define GeneratorExp(a0, a1, a2, a3, a4, a5, a6) _Py_GeneratorExp(a0, a1, a2, a3, a4, a5, a6)
-expr_ty _Py_GeneratorExp(expr_ty elt, asdl_seq * generators, int lineno, int
-                         col_offset, int end_lineno, int end_col_offset,
-                         PyArena *arena);
+expr_ty _Py_GeneratorExp(expr_ty elt, asdl_comprehension_seq * generators, int
+                         lineno, int col_offset, int end_lineno, int
+                         end_col_offset, PyArena *arena);
 #define Await(a0, a1, a2, a3, a4, a5) _Py_Await(a0, a1, a2, a3, a4, a5)
 expr_ty _Py_Await(expr_ty value, int lineno, int col_offset, int end_lineno,
                   int end_col_offset, PyArena *arena);
@@ -612,19 +698,19 @@ expr_ty _Py_Yield(expr_ty value, int lineno, int col_offset, int end_lineno,
 expr_ty _Py_YieldFrom(expr_ty value, int lineno, int col_offset, int
                       end_lineno, int end_col_offset, PyArena *arena);
 #define Compare(a0, a1, a2, a3, a4, a5, a6, a7) _Py_Compare(a0, a1, a2, a3, a4, a5, a6, a7)
-expr_ty _Py_Compare(expr_ty left, asdl_int_seq * ops, asdl_seq * comparators,
-                    int lineno, int col_offset, int end_lineno, int
-                    end_col_offset, PyArena *arena);
+expr_ty _Py_Compare(expr_ty left, asdl_int_seq * ops, asdl_expr_seq *
+                    comparators, int lineno, int col_offset, int end_lineno,
+                    int end_col_offset, PyArena *arena);
 #define Call(a0, a1, a2, a3, a4, a5, a6, a7) _Py_Call(a0, a1, a2, a3, a4, a5, a6, a7)
-expr_ty _Py_Call(expr_ty func, asdl_seq * args, asdl_seq * keywords, int
-                 lineno, int col_offset, int end_lineno, int end_col_offset,
-                 PyArena *arena);
+expr_ty _Py_Call(expr_ty func, asdl_expr_seq * args, asdl_keyword_seq *
+                 keywords, int lineno, int col_offset, int end_lineno, int
+                 end_col_offset, PyArena *arena);
 #define FormattedValue(a0, a1, a2, a3, a4, a5, a6, a7) _Py_FormattedValue(a0, a1, a2, a3, a4, a5, a6, a7)
 expr_ty _Py_FormattedValue(expr_ty value, int conversion, expr_ty format_spec,
                            int lineno, int col_offset, int end_lineno, int
                            end_col_offset, PyArena *arena);
 #define JoinedStr(a0, a1, a2, a3, a4, a5) _Py_JoinedStr(a0, a1, a2, a3, a4, a5)
-expr_ty _Py_JoinedStr(asdl_seq * values, int lineno, int col_offset, int
+expr_ty _Py_JoinedStr(asdl_expr_seq * values, int lineno, int col_offset, int
                       end_lineno, int end_col_offset, PyArena *arena);
 #define Constant(a0, a1, a2, a3, a4, a5, a6) _Py_Constant(a0, a1, a2, a3, a4, a5, a6)
 expr_ty _Py_Constant(constant value, string kind, int lineno, int col_offset,
@@ -646,11 +732,11 @@ expr_ty _Py_Name(identifier id, expr_context_ty ctx, int lineno, int
                  col_offset, int end_lineno, int end_col_offset, PyArena
                  *arena);
 #define List(a0, a1, a2, a3, a4, a5, a6) _Py_List(a0, a1, a2, a3, a4, a5, a6)
-expr_ty _Py_List(asdl_seq * elts, expr_context_ty ctx, int lineno, int
+expr_ty _Py_List(asdl_expr_seq * elts, expr_context_ty ctx, int lineno, int
                  col_offset, int end_lineno, int end_col_offset, PyArena
                  *arena);
 #define Tuple(a0, a1, a2, a3, a4, a5, a6) _Py_Tuple(a0, a1, a2, a3, a4, a5, a6)
-expr_ty _Py_Tuple(asdl_seq * elts, expr_context_ty ctx, int lineno, int
+expr_ty _Py_Tuple(asdl_expr_seq * elts, expr_context_ty ctx, int lineno, int
                   col_offset, int end_lineno, int end_col_offset, PyArena
                   *arena);
 #define Slice(a0, a1, a2, a3, a4, a5, a6, a7) _Py_Slice(a0, a1, a2, a3, a4, a5, a6, a7)
@@ -658,18 +744,18 @@ expr_ty _Py_Slice(expr_ty lower, expr_ty upper, expr_ty step, int lineno, int
                   col_offset, int end_lineno, int end_col_offset, PyArena
                   *arena);
 #define comprehension(a0, a1, a2, a3, a4) _Py_comprehension(a0, a1, a2, a3, a4)
-comprehension_ty _Py_comprehension(expr_ty target, expr_ty iter, asdl_seq *
-                                   ifs, int is_async, PyArena *arena);
+comprehension_ty _Py_comprehension(expr_ty target, expr_ty iter, asdl_expr_seq
+                                   * ifs, int is_async, PyArena *arena);
 #define ExceptHandler(a0, a1, a2, a3, a4, a5, a6, a7) _Py_ExceptHandler(a0, a1, a2, a3, a4, a5, a6, a7)
-excepthandler_ty _Py_ExceptHandler(expr_ty type, identifier name, asdl_seq *
-                                   body, int lineno, int col_offset, int
+excepthandler_ty _Py_ExceptHandler(expr_ty type, identifier name, asdl_stmt_seq
+                                   * body, int lineno, int col_offset, int
                                    end_lineno, int end_col_offset, PyArena
                                    *arena);
 #define arguments(a0, a1, a2, a3, a4, a5, a6, a7) _Py_arguments(a0, a1, a2, a3, a4, a5, a6, a7)
-arguments_ty _Py_arguments(asdl_seq * posonlyargs, asdl_seq * args, arg_ty
-                           vararg, asdl_seq * kwonlyargs, asdl_seq *
-                           kw_defaults, arg_ty kwarg, asdl_seq * defaults,
-                           PyArena *arena);
+arguments_ty _Py_arguments(asdl_arg_seq * posonlyargs, asdl_arg_seq * args,
+                           arg_ty vararg, asdl_arg_seq * kwonlyargs,
+                           asdl_expr_seq * kw_defaults, arg_ty kwarg,
+                           asdl_expr_seq * defaults, PyArena *arena);
 #define arg(a0, a1, a2, a3, a4, a5, a6, a7) _Py_arg(a0, a1, a2, a3, a4, a5, a6, a7)
 arg_ty _Py_arg(identifier arg, expr_ty annotation, string type_comment, int
                lineno, int col_offset, int end_lineno, int end_col_offset,