CPython internal AST structure deep-copy functions • Eritque Arcus

Deep copy

code generation for deepcopy Python AST tree

1
###
2
# This script is used to generate deepcopy functions for CPython internal AST nodes.
3
# License: MIT
4
# Author: Eritque arcus
5
# Date: July 20, 2024
6
###
7

8
import sys
9

10
if len(sys.argv) != 3:
11
    print("Usage: python deepcopy_ast.py <header> <output>")
12
    sys.exit(1)
13

14
TARGETS = ["expr", "stmt", "excepthandler",
15
           "pattern", "type_ignore", "type_param", "mod"]
16
INDIVIDUAL_TARGETS = ["comprehension", "arguments",
17
                      "arg", "keyword", "alias", "withitem", "match_case"]
18

19

20
UNION_TARGET_TEMPLATE = """%s_ty %s_copy(%s_ty val, PyArena *arena)
21
{
22
    if(val == NULL){
23
        return NULL;
24
    }
25
    %s_ty re = _PyArena_Malloc(arena, sizeof(struct _%s));
26
    re->kind = val->kind;
27
    switch (val->kind) {
28
    BODY
29
    }
30
    OTHER
31
    return re;
32
}"""
33

34
UNION_STMT_PATCH = """
35
case Pass_kind:
36
case Break_kind:
37
case Continue_kind:
38
    break;
39
""".strip()
40

41
INDIVIDUAL_TARGET_TEMPLATE = """%s_ty %s_copy(%s_ty val, PyArena *arena)
42
{
43
    if(val == NULL){
44
        return NULL;
45
    }
46
    %s_ty re = _PyArena_Malloc(arena, sizeof(struct _%s));
47
    BODY
48
    return re;
49
}"""
50

51
header = sys.argv[1]
52
with open(header, "r", encoding="utf-8") as f:
53
    codes_raw = f.read().strip().split("\n")
54

55

56
def parse_struct(start: int, codes: list[str], name: str = ""):
57
    parse_code = "\n"
58
    end = start + 1
59
    while not codes[end].replace(" ", "").startswith("}"):
60
        end += 1
61
    if name == "":
62
        name = codes[end].replace(" ", "").removeprefix("}").removesuffix(";")
63
    for j in range(start + 1, end):
64
        if codes[j].strip() == "":
65
            continue
66
        code = codes[j].strip().split(" ")
67
        n = code[1].removesuffix(";").removeprefix("*")
68
        t = code[0].removesuffix("_ty")
69
        if t == "int":
70
            if name is None:
71
                parse_code += f"re->{n} = val->{n};\n"
72
            else:
73
                parse_code += f"re->v.{name}.{n} = val->v.{name}.{n};\n"
74
        else:
75
            # print(name, t, n)
76
            if name is None:
77
                parse_code += f"re->{n} = {t}_copy(val->{n}, arena);\n"
78
            else:
79
                parse_code += f"re->v.{name}.{n} = {t}_copy(val->v.{name}.{n}, arena);\n"
80
    parse_code = parse_code.replace("\n", "\n" + " " * 3)
81
    if name is not None:
82
        parse_code = f"case {name}_kind:{parse_code}break;"
83
    return (end, parse_code)
84

85

86
def gen_targets(codes: list[str], target: str):
87
    i = 0
88
    while i < len(codes) and codes[i].replace(" ", "") != "struct_%s{" % target:
89
        i += 1
90
    codes = codes[i + 1:]
91
    i = 0
92
    while i < len(codes) and codes[i].replace(" ", "") != "}v;":
93
        i += 1
94
    body_codes = codes[:i]
95
    ii = i
96
    while ii < len(codes) and codes[ii].replace(" ", "") != "};":
97
        ii += 1
98
    other_codes = codes[i:ii + 1]
99

100
    template = UNION_TARGET_TEMPLATE % (target, target, target, target, target)
101
    body = ""
102

103
    i = 0
104
    base = 0
105
    while True:
106
        while i < len(body_codes) and body_codes[i].replace(" ", "") != "struct{":
107
            i += 1
108
        if i == len(body_codes):
109
            break
110
        i, code = parse_struct(i + base, body_codes)
111
        body += code + "\n"
112
    if target == "stmt":
113
        body += UNION_STMT_PATCH
114
    body = body.replace("\n", "\n" + " " * 6)
115

116
    if len(other_codes) > 1:
117
        _, code = parse_struct(0, other_codes, None)
118
        template = template.replace("OTHER", code)
119

120
    return template.replace("BODY", " " * 3 + body)
121

122

123
def gen_individual_targets(codes: list[str], target: str):
124
    i = 0
125
    while i < len(codes) and codes[i].replace(" ", "") != "struct_%s{" % target:
126
        i += 1
127
    codes = codes[i:]
128
    i = 0
129
    while i < len(codes) and codes[i] != "};":
130
        i += 1
131
    codes = codes[:i + 1]
132
    template = INDIVIDUAL_TARGET_TEMPLATE % (
133
        target, target, target, target, target)
134
    _, body = parse_struct(0, codes, None)
135
    return template.replace("BODY", " " * 3 + body)
136

137

138
FILE_CONTENT = "#include \"deepcopy_gen.h\"\n"
139
HEADER_CONTENT = "#ifndef DEEPCOPY_GEN_H\n#define DEEPCOPY_GEN_H\n\n#include \"deepcopy.h\"\n\n"
140

141
for t in TARGETS:
142
    FILE_CONTENT += gen_targets(codes_raw, t) + "\n"
143
    HEADER_CONTENT += f"{t}_ty {t}_copy({t}_ty val, PyArena *arena);\n"
144
for t in INDIVIDUAL_TARGETS:
145
    FILE_CONTENT += gen_individual_targets(codes_raw, t) + "\n"
146
    HEADER_CONTENT += f"{t}_ty {t}_copy({t}_ty val, PyArena *arena);\n"
147

148
with open(sys.argv[2] + ".c", "w", encoding="utf-8") as f:
149
    f.write(FILE_CONTENT)
150
with open(sys.argv[2] + ".h", "w", encoding="utf-8") as f:
151
    f.write(HEADER_CONTENT + "\n#endif")

and some manually written implementations

1
#ifndef DEEPCOPY_H
2
#define DEEPCOPY_H
3

4
#define Py_BUILD_CORE 1
5
#include "Python.h"
6
#include "pycore_ast.h"
7

8
#include "deepcopy_gen.h"
9

10
expr_ty expr_copy(expr_ty val, PyArena *arena);
11
stmt_ty stmt_copy(stmt_ty val, PyArena *arena);
12

13
#define ASDL_SEQ_COPY_HEADER(type)                                  \
14
    type *type##_copy(type *seq, PyArena *arena);                   \
15
    type *type##_copy_add(type *seq, PyArena *arena, int add_size); \
16
    type *type##_copy_add_front(type *seq, PyArena *arena, int add_size);
17

18
ASDL_SEQ_COPY_HEADER(asdl_expr_seq)
19
ASDL_SEQ_COPY_HEADER(asdl_stmt_seq)
20
ASDL_SEQ_COPY_HEADER(asdl_keyword_seq)
21
ASDL_SEQ_COPY_HEADER(asdl_int_seq)
22
ASDL_SEQ_COPY_HEADER(asdl_arg_seq)
23
ASDL_SEQ_COPY_HEADER(asdl_type_param_seq)
24
ASDL_SEQ_COPY_HEADER(asdl_comprehension_seq)
25
ASDL_SEQ_COPY_HEADER(asdl_alias_seq)
26
ASDL_SEQ_COPY_HEADER(asdl_excepthandler_seq)
27
ASDL_SEQ_COPY_HEADER(asdl_type_ignore_seq)
28
ASDL_SEQ_COPY_HEADER(asdl_withitem_seq)
29
ASDL_SEQ_COPY_HEADER(asdl_match_case_seq)
30
ASDL_SEQ_COPY_HEADER(asdl_identifier_seq)
31
ASDL_SEQ_COPY_HEADER(asdl_pattern_seq)
32

33
#define TRIAL_COPY_HEDER(type) type##_ty type##_copy(type##_ty val, PyArena *arena);
34
TRIAL_COPY_HEDER(boolop)
35
TRIAL_COPY_HEDER(operator)
36
TRIAL_COPY_HEDER(unaryop)
37
TRIAL_COPY_HEDER(cmpop)
38
TRIAL_COPY_HEDER(expr_context)
39
identifier identifier_copy(identifier val, PyArena *arena);
40
PyObject *constant_copy(PyObject *val, PyArena *arena);
41
PyObject *string_copy(PyObject *val, PyArena *arena);
42
// PyObject *object_copy(PyObject *val, PyArena *arena);
43

44
#endif // DEEPCOPY_H

1
#include "deepcopy.h"
2

3
// implement log funcs yourself
4
#define INFO(fmt, ...) info(fmt, ##__VA_ARGS__)
5
#define ERROR(fmt, ...) error(fmt, ##__VA_ARGS__)
6
#define PANIC(fmt, ...) panic(fmt, ##__VA_ARGS__)
7

8
PyObject *PyUnicode_FromString_Arena(const char *s, PyArena *arena)
9
{
10
    PyObject *re = (PyObject *)PyUnicode_FromString(s);
11
    _PyArena_AddPyObject(arena, re);
12
    // check obj2ast_constant from CPython source code
13
    Py_INCREF(re);
14
    return re;
15
}
16

17
PyObject *PyLong_Copy_Arena(PyObject *s, PyArena *arena)
18
{
19
    if (s == NULL)
20
    {
21
        return NULL;
22
    }
23
    PyObject *re = (PyObject *)PyLong_FromLongLong(PyLong_AsLongLong(s));
24
    _PyArena_AddPyObject(arena, re);
25
    // check obj2ast_constant from CPython source code
26
    Py_INCREF(re);
27
    return re;
28
}
29

30
PyObject *PyUnicode_Copy_Arena(PyObject *s, PyArena *arena)
31
{
32
    if (s == NULL)
33
    {
34
        return NULL;
35
    }
36
    Py_ssize_t length = PyUnicode_GET_LENGTH(s);
37
    PyObject *re = (PyObject *)PyUnicode_New(length, PyUnicode_MAX_CHAR_VALUE(s));
38
    memcpy(PyUnicode_DATA(re), PyUnicode_DATA(s), length * PyUnicode_KIND(s)); // from _PyUnicode_Copy but no checks
39
    _PyArena_AddPyObject(arena, re);
40
    // check obj2ast_constant from CPython source code
41
    Py_INCREF(re);
42
    return re;
43
}
44

45
PyObject *PyLong_FromLong_Arena(long n, PyArena *arena)
46
{
47
    PyObject *re = (PyObject *)PyLong_FromLong(n);
48
    _PyArena_AddPyObject(arena, re);
49
    // check obj2ast_constant from CPython source code
50
    Py_INCREF(re);
51
    return re;
52
}
53

54
#define TRIAL_COPY(type)                                 \
55
    type##_ty type##_copy(type##_ty val, PyArena *arena) \
56
    {                                                    \
57
        return val;                                      \
58
    }
59
TRIAL_COPY(boolop)
60
TRIAL_COPY(operator)
61
TRIAL_COPY(unaryop)
62
TRIAL_COPY(cmpop)
63
TRIAL_COPY(expr_context)
64

65
identifier identifier_copy(identifier val, PyArena *arena)
66
{
67
    return PyUnicode_Copy_Arena(val, arena);
68
}
69
PyObject *string_copy(PyObject *val, PyArena *arena)
70
{
71
    return PyUnicode_Copy_Arena(val, arena);
72
}
73
PyObject *constant_copy(PyObject *val, PyArena *arena)
74
{
75
    if (PyLong_CheckExact(val))
76
    {
77
        return PyLong_Copy_Arena(val, arena);
78
    }
79
    else if (PyUnicode_CheckExact(val))
80
    {
81
        return PyUnicode_Copy_Arena(val, arena);
82
    }
83
    ERROR("Unknown constant type, use fallback - %s\n", val->ob_type->tp_name);
84
    _PyArena_AddPyObject(arena, val);
85
    Py_INCREF(val);
86
    return val;
87
}
88

89
#define ASDL_SEQ_COPY_COMBINED(type) \
90
    ASDL_SEQ_COPY_ADD_FRONT(type)    \
91
    ASDL_SEQ_COPY_ADD(type)          \
92
    ASDL_SEQ_COPY(type)
93

94
#define ASDL_SEQ_COPY_ADD(type)                                                                           \
95
    asdl_##type##_seq *asdl_##type##_seq##_copy_add(asdl_##type##_seq *seq, PyArena *arena, int add_size) \
96
    {                                                                                                     \
97
        asdl_##type##_seq *re;                                                                            \
98
        if (seq == NULL)                                                                                  \
99
        {                                                                                                 \
100
            re = _Py_##asdl_##type##_seq##_new(add_size, arena);                                          \
101
        }                                                                                                 \
102
        else                                                                                              \
103
        {                                                                                                 \
104
            re = _Py_##asdl_##type##_seq##_new(seq->size + add_size, arena);                              \
105
            for (int i = 0; i < seq->size; i++)                                                           \
106
            {                                                                                             \
107
                re->typed_elements[i] = type##_copy(seq->typed_elements[i], arena);                       \
108
            }                                                                                             \
109
        }                                                                                                 \
110
        return re;                                                                                        \
111
    }
112

113
#define ASDL_SEQ_COPY_ADD_FRONT(type)                                                                           \
114
    asdl_##type##_seq *asdl_##type##_seq##_copy_add_front(asdl_##type##_seq *seq, PyArena *arena, int add_size) \
115
    {                                                                                                           \
116
        asdl_##type##_seq *re;                                                                                  \
117
        if (seq == NULL)                                                                                        \
118
        {                                                                                                       \
119
            re = _Py_##asdl_##type##_seq##_new(add_size, arena);                                                \
120
        }                                                                                                       \
121
        else                                                                                                    \
122
        {                                                                                                       \
123
            re = _Py_##asdl_##type##_seq##_new(seq->size + add_size, arena);                                    \
124
            for (int i = 1; i < seq->size + 1; i++)                                                             \
125
            {                                                                                                   \
126
                re->typed_elements[i] = type##_copy(seq->typed_elements[i - 1], arena);                         \
127
            }                                                                                                   \
128
        }                                                                                                       \
129
        return re;                                                                                              \
130
    }
131

132
#define ASDL_SEQ_COPY(type)                                                             \
133
    asdl_##type##_seq *asdl_##type##_seq##_copy(asdl_##type##_seq *seq, PyArena *arena) \
134
    {                                                                                   \
135
        if (seq == NULL)                                                                \
136
        {                                                                               \
137
            return NULL;                                                                \
138
        }                                                                               \
139
        asdl_##type##_seq *re = _Py_##asdl_##type##_seq##_new(seq->size, arena);        \
140
        for (int i = 0; i < seq->size; i++)                                             \
141
        {                                                                               \
142
            re->typed_elements[i] = type##_copy(seq->typed_elements[i], arena);         \
143
        }                                                                               \
144
        return re;                                                                      \
145
    }
146

147
ASDL_SEQ_COPY_COMBINED(expr)
148
ASDL_SEQ_COPY_COMBINED(stmt)
149
ASDL_SEQ_COPY_COMBINED(keyword)
150
asdl_int_seq *asdl_int_seq_copy(asdl_int_seq *seq, PyArena *arena)
151
{
152
    asdl_int_seq *re = _Py_asdl_int_seq_new(seq->size, arena);
153
    for (int i = 0; i < seq->size; i++)
154
    {
155
        re->typed_elements[i] = seq->typed_elements[i];
156
    }
157
    return re;
158
}
159
asdl_int_seq *asdl_int_seq_copy_add(asdl_int_seq *seq, PyArena *arena, int add_size)
160
{
161
    asdl_int_seq *re = _Py_asdl_int_seq_new(seq->size + add_size, arena);
162
    for (int i = 0; i < seq->size; i++)
163
    {
164
        re->typed_elements[i] = seq->typed_elements[i];
165
    }
166
    return re;
167
}
168
ASDL_SEQ_COPY_COMBINED(arg)
169
ASDL_SEQ_COPY_COMBINED(comprehension)
170
ASDL_SEQ_COPY_COMBINED(type_param)
171
ASDL_SEQ_COPY_COMBINED(alias)
172
ASDL_SEQ_COPY_COMBINED(excepthandler)
173
ASDL_SEQ_COPY_COMBINED(type_ignore)
174
ASDL_SEQ_COPY_COMBINED(withitem)
175
ASDL_SEQ_COPY_COMBINED(match_case)
176
ASDL_SEQ_COPY_COMBINED(identifier)
177
ASDL_SEQ_COPY_COMBINED(pattern)

Default

code generation for default constructor for every types in Python AST tree

1
import pathlib
2
from glob import glob
3
import re
4
import sys
5

6

7
def extract_enum_kinds(source):
8
    enums = {}
9
    for match in re.finditer(r"enum (\w+_kind)\s*\{([^}]+)\};", source):
10
        enum_name = match.group(1)
11
        body = match.group(2)
12
        values = re.findall(r"\b(\w+_kind)\b", body)
13
        enums[enum_name] = values
14
    return enums
15

16

17
def extract_pyast_constructors(source):
18
    constructors = []
19
    pattern = re.compile(r"PyAPI_FUNC\((\w+_ty)\)\s+(_PyAST_\w+)\s*\(([^)]*)\);")
20
    for match in pattern.finditer(source):
21
        return_type = match.group(1)
22
        name = match.group(2)
23
        args = [
24
            a.strip()
25
            for a in match.group(3)
26
            .strip()
27
            .replace("\\\n", "")
28
            .replace("\n", " ")
29
            .split(",")
30
        ]
31
        constructors.append({"return_type": return_type, "name": name, "args": args})
32
    return constructors
33

34
# TODO change me
35
HEADER_PATH = "cpython_bin/include/python*/internal/pycore_ast.h"
36
HEADER_PATH = glob(HEADER_PATH)[0]
37
HEADER_PATH = pathlib.Path(HEADER_PATH).resolve()
38

39
FUNC_TEMPLATE = """
40
%s default%s(ast_data_t *data){
41
    return %s(%s);
42
}
43
"""
44

45
header_content = """
46
#ifndef DEFAULT_GEN_H
47
#define DEFAULT_GEN_H
48

49
#define Py_BUILD_CORE 1
50
#include "Python.h"
51
#include "pycore_ast.h"
52

53
typedef struct {
54
    PyArena *arena;
55
} ast_data_t;
56

57
typedef enum Node_kind {
58
   %s
59
} Node_kind_t;
60

61
extern const int node_kind_cnt;
62

63
extern const int table_size[];
64

65
extern const void(** implementation_tables[])(ast_data_t *);
66

67
#endif
68
""".strip()
69
source_content = """
70
#include "default_gen.h"
71
#include "default.h"
72

73
const int node_kind_cnt = %d;
74
const int table_size[] = {%s};
75
""".strip()
76

77

78
if len(sys.argv) != 2:
79
    print("Usage: python pycore_ast.py <output_file>")
80
    sys.exit(1)
81

82
print("parse from", HEADER_PATH)
83

84
with open(HEADER_PATH, "r") as f:
85
    source = f.read()
86
    enums = extract_enum_kinds(source)
87

88
enums.pop("_mod_kind")
89
constructors = extract_pyast_constructors(source)
90
# make a C style dict, enum -> function pointers
91
implementation_tables = {}
92
for enum_name, _ in enums.items():
93
    implementation_tables[enum_name] = [
94
        constructor
95
        for constructor in constructors
96
        if enum_name.removeprefix("_").removesuffix("_kind")
97
        in constructor["return_type"]
98
    ]
99

100
source_content = source_content % (
101
    len(enums),
102
    (
103
        (", ".join([str(len(v)) for v in implementation_tables.values()])).removesuffix(
104
            ","
105
        )
106
    ),
107
)
108

109
header_content = header_content % (
110
    "\n   ".join([f"{name} = {i}," for i, name in enumerate(enums.keys())]),
111
)
112
for enum_name, functions in implementation_tables.items():
113
    for func in functions:
114
        args = ""
115
        for a in func["args"]:
116
            # remove abundant spaces
117
            a = " ".join(a.strip().split()).split(" ")
118
            if a[1][0] == "*":
119
                if a[0] == "PyArena":
120
                    args += "data->arena, "
121
                else:
122
                    args += f"default_{a[0]}_ptr(data), "
123
            else:
124
                args += f"default_{a[0]}(data), "
125
        source_content += FUNC_TEMPLATE % (
126
            func["return_type"],
127
            func["name"],
128
            func["name"],
129
            args.removesuffix(", "),
130
        )
131
    source_content += """
132
void(* %s_funcs[])(ast_data_t *) = {
133
   %s
134
};
135
""" % (
136
        enum_name,
137
        "\n   ".join(
138
            [f"(void *)default{name['name']}," for name in functions]
139
        ).removesuffix(","),
140
    )
141

142
source_content += """
143
const void(** implementation_tables[])(ast_data_t *) = {
144
   %s
145
};
146
""" % (
147
    "\n   ".join([f"{name}_funcs," for name in enums.keys()]).removesuffix(",")
148
)
149

150
with open(sys.argv[1] + ".c", "w") as f:
151
    f.write(source_content)
152
with open(sys.argv[1] + ".h", "w") as f:
153
    f.write(header_content)

and some manual implemented function

1
#ifndef AST_DEFAULT_H
2
#define AST_DEFAULT_H
3

4
#define Py_BUILD_CORE 1
5
#include "Python.h"
6
#include "pycore_ast.h"
7

8
typedef struct {
9
    PyArena *arena;
10
} ast_data_t;
11

12
identifier default_identifier(ast_data_t *data);
13
arguments_ty default_arguments_ty(ast_data_t *data);
14
stmt_ty default_stmt_ty(ast_data_t *data);
15
string default_string(ast_data_t *data);
16
expr_ty default_expr_ty(ast_data_t *data);
17
int default_int(ast_data_t *data);
18
constant default_constant(ast_data_t *data);
19
expr_context_ty default_expr_context_ty(ast_data_t *data);
20
alias_ty default_alias(ast_data_t *data);
21
unaryop_ty default_unaryop(ast_data_t *data);
22
operator_ty default_operator_ty(ast_data_t *data);
23

24
asdl_arguments_seq *default_asdl_arguments_seq_ptr(ast_data_t *data);
25
asdl_identifier_seq *default_asdl_identifier_seq_ptr(ast_data_t *data);
26
asdl_keyword_seq *default_asdl_keyword_seq_ptr(ast_data_t *data);
27
asdl_stmt_seq *default_asdl_stmt_seq_ptr(ast_data_t *data);
28
asdl_expr_seq *default_asdl_expr_seq_ptr(ast_data_t *data);
29
asdl_type_param_seq *default_asdl_type_param_seq_ptr(ast_data_t *data);
30
asdl_withitem_seq *default_asdl_withitem_seq_ptr(ast_data_t *data);
31
asdl_match_case_seq *default_asdl_match_case_seq_ptr(ast_data_t *data);
32
asdl_excepthandler_seq *default_asdl_excepthandler_seq_ptr(ast_data_t *data);
33
asdl_alias_seq *default_asdl_alias_seq_ptr(ast_data_t *data);
34

35
#endif  // AST_DEFAULT_H

1
#include "default.h"
2

3
#include "ast.h"
4

5
identifier default_identifier(ast_data_t *data) {
6
    return gen_name_id(data->gen_name_cnt++);
7
}
8

9
arguments_ty default_arguments_ty(ast_data_t *data) {
10
    return _PyAST_arguments(NULL, _Py_asdl_arg_seq_new(0, data->arena), NULL,
11
                            NULL, NULL, NULL, NULL, data->arena);
12
}
13

14
stmt_ty default_stmt_ty(ast_data_t *data) {
15
    return _PyAST_Pass(LINE, data->arena);
16
}
17

18
string default_string(ast_data_t *data) { return NULL; }
19

20
alias_ty default_alias(ast_data_t *data) {
21
    return _PyAST_alias(default_identifier(data), default_identifier(data),
22
                        LINE, data->arena);
23
}
24

25
expr_ty default_expr_ty(ast_data_t *data) { return _PyLong_GetZero(); }
26

27
int default_int(ast_data_t *data) { return 0; }
28

29
constant default_constant(ast_data_t *data) { return _PyLong_GetZero(); }
30

31
expr_context_ty default_expr_context_ty(ast_data_t *data) { return Load; }
32

33
operator_ty default_operator_ty(ast_data_t *data) { return Add; }
34

35
asdl_arguments_seq *default_asdl_arguments_seq_ptr(ast_data_t *data) {
36
    asdl_arguments_seq *tmp = _Py_asdl_arguments_seq_new(1, data->arena);
37
    tmp->typed_elements[0] = default_arguments_ty(data);
38
    return tmp;
39
}
40

41
asdl_identifier_seq *default_asdl_identifier_seq_ptr(ast_data_t *data) {
42
    asdl_identifier_seq *tmp = _Py_asdl_identifier_seq_new(1, data->arena);
43
    tmp->typed_elements[0] = default_identifier(data);
44
    return tmp;
45
}
46

47
asdl_keyword_seq *default_asdl_keyword_seq_ptr(ast_data_t *data) {
48
    return _Py_asdl_keyword_seq_new(0, data->arena);
49
}
50

51
asdl_stmt_seq *default_asdl_stmt_seq_ptr(ast_data_t *data) {
52
    asdl_stmt_seq *tmp = _Py_asdl_stmt_seq_new(1, data->arena);
53
    tmp->typed_elements[0] = default_stmt_ty(data->arena);
54
    return tmp;
55
}
56

57
asdl_expr_seq *default_asdl_expr_seq_ptr(ast_data_t *data) {
58
    asdl_expr_seq *tmp = _Py_asdl_expr_seq_new(1, data->arena);
59
    tmp->typed_elements[0] = default_expr_ty(data);
60
    return tmp;
61
}
62

63
asdl_type_param_seq *default_asdl_type_param_seq_ptr(ast_data_t *data) {
64
    return _Py_asdl_type_param_seq_new(0, data->arena);
65
}
66

67
asdl_withitem_seq *default_asdl_withitem_seq_ptr(ast_data_t *data) {
68
    asdl_withitem_seq *tmp = _Py_asdl_withitem_seq_new(1, data->arena);
69
    tmp->typed_elements[0] = _PyAST_Pass(LINE, data->arena);
70
    return tmp;
71
}
72

73
asdl_match_case_seq *default_asdl_match_case_seq_ptr(ast_data_t *data) {
74
    asdl_match_case_seq *tmp = _Py_asdl_match_case_seq_new(1, data->arena);
75
    tmp->typed_elements[0] = _PyAST_Pass(LINE, data->arena);
76
    return tmp;
77
}
78

79
asdl_excepthandler_seq *default_asdl_excepthandler_seq_ptr(ast_data_t *data) {
80
    asdl_excepthandler_seq *tmp =
81
        _Py_asdl_excepthandler_seq_new(1, data->arena);
82
    tmp->typed_elements[0] = _PyAST_Pass(LINE, data->arena);
83
    return tmp;
84
}
85

86
asdl_alias_seq *default_asdl_alias_seq_ptr(ast_data_t *data) {
87
    asdl_alias_seq *tmp = _Py_asdl_alias_seq_new(1, data->arena);
88
    tmp->typed_elements[0] = default_alias(data);
89
    return tmp;
90
}
91

92
unaryop_ty default_unaryop(ast_data_t *data) { return Invert; }

How to use

Run the script with pycore_ast.h as first argument, and the destination filename (w/o extension) as second argument.
E.g:

python deepcopy_ast.py $(readlink -f $CPYTHON_BIN_PATH/include/python3.*/internal/pycore_ast.h) src/codgen/deepcopy_gen
python default_gen.py src/codgen/default_gen

Then add all above files into your project.
Check CPython-AST-Fuzzer