Branch data Line data Source code
1 : : // File automatically generated by Parser/asdl_c.py.
2 : :
3 : : #include "Python.h"
4 : : #include "pycore_ast.h"
5 : : #include "pycore_ast_state.h" // struct ast_state
6 : : #include "pycore_ceval.h" // _Py_EnterRecursiveCall
7 : : #include "pycore_interp.h" // _PyInterpreterState.ast
8 : : #include "pycore_pystate.h" // _PyInterpreterState_GET()
9 : : #include "structmember.h"
10 : : #include <stddef.h>
11 : :
12 : : // Forward declaration
13 : : static int init_types(struct ast_state *state);
14 : :
15 : : static struct ast_state*
16 : 47758 : get_ast_state(void)
17 : : {
18 : 47758 : PyInterpreterState *interp = _PyInterpreterState_GET();
19 : 47758 : struct ast_state *state = &interp->ast;
20 [ - + ]: 47758 : if (!init_types(state)) {
21 : 0 : return NULL;
22 : : }
23 : 47758 : return state;
24 : : }
25 : :
26 : 3125 : void _PyAST_Fini(PyInterpreterState *interp)
27 : : {
28 : 3125 : struct ast_state *state = &interp->ast;
29 : :
30 [ + + ]: 3125 : Py_CLEAR(state->AST_type);
31 [ + + ]: 3125 : Py_CLEAR(state->Add_singleton);
32 [ + + ]: 3125 : Py_CLEAR(state->Add_type);
33 [ + + ]: 3125 : Py_CLEAR(state->And_singleton);
34 [ + + ]: 3125 : Py_CLEAR(state->And_type);
35 [ + + ]: 3125 : Py_CLEAR(state->AnnAssign_type);
36 [ + + ]: 3125 : Py_CLEAR(state->Assert_type);
37 [ + + ]: 3125 : Py_CLEAR(state->Assign_type);
38 [ + + ]: 3125 : Py_CLEAR(state->AsyncFor_type);
39 [ + + ]: 3125 : Py_CLEAR(state->AsyncFunctionDef_type);
40 [ + + ]: 3125 : Py_CLEAR(state->AsyncWith_type);
41 [ + + ]: 3125 : Py_CLEAR(state->Attribute_type);
42 [ + + ]: 3125 : Py_CLEAR(state->AugAssign_type);
43 [ + + ]: 3125 : Py_CLEAR(state->Await_type);
44 [ + + ]: 3125 : Py_CLEAR(state->BinOp_type);
45 [ + + ]: 3125 : Py_CLEAR(state->BitAnd_singleton);
46 [ + + ]: 3125 : Py_CLEAR(state->BitAnd_type);
47 [ + + ]: 3125 : Py_CLEAR(state->BitOr_singleton);
48 [ + + ]: 3125 : Py_CLEAR(state->BitOr_type);
49 [ + + ]: 3125 : Py_CLEAR(state->BitXor_singleton);
50 [ + + ]: 3125 : Py_CLEAR(state->BitXor_type);
51 [ + + ]: 3125 : Py_CLEAR(state->BoolOp_type);
52 [ + + ]: 3125 : Py_CLEAR(state->Break_type);
53 [ + + ]: 3125 : Py_CLEAR(state->Call_type);
54 [ + + ]: 3125 : Py_CLEAR(state->ClassDef_type);
55 [ + + ]: 3125 : Py_CLEAR(state->Compare_type);
56 [ + + ]: 3125 : Py_CLEAR(state->Constant_type);
57 [ + + ]: 3125 : Py_CLEAR(state->Continue_type);
58 [ + + ]: 3125 : Py_CLEAR(state->Del_singleton);
59 [ + + ]: 3125 : Py_CLEAR(state->Del_type);
60 [ + + ]: 3125 : Py_CLEAR(state->Delete_type);
61 [ + + ]: 3125 : Py_CLEAR(state->DictComp_type);
62 [ + + ]: 3125 : Py_CLEAR(state->Dict_type);
63 [ + + ]: 3125 : Py_CLEAR(state->Div_singleton);
64 [ + + ]: 3125 : Py_CLEAR(state->Div_type);
65 [ + + ]: 3125 : Py_CLEAR(state->Eq_singleton);
66 [ + + ]: 3125 : Py_CLEAR(state->Eq_type);
67 [ + + ]: 3125 : Py_CLEAR(state->ExceptHandler_type);
68 [ + + ]: 3125 : Py_CLEAR(state->Expr_type);
69 [ + + ]: 3125 : Py_CLEAR(state->Expression_type);
70 [ + + ]: 3125 : Py_CLEAR(state->FloorDiv_singleton);
71 [ + + ]: 3125 : Py_CLEAR(state->FloorDiv_type);
72 [ + + ]: 3125 : Py_CLEAR(state->For_type);
73 [ + + ]: 3125 : Py_CLEAR(state->FormattedValue_type);
74 [ + + ]: 3125 : Py_CLEAR(state->FunctionDef_type);
75 [ + + ]: 3125 : Py_CLEAR(state->FunctionType_type);
76 [ + + ]: 3125 : Py_CLEAR(state->GeneratorExp_type);
77 [ + + ]: 3125 : Py_CLEAR(state->Global_type);
78 [ + + ]: 3125 : Py_CLEAR(state->GtE_singleton);
79 [ + + ]: 3125 : Py_CLEAR(state->GtE_type);
80 [ + + ]: 3125 : Py_CLEAR(state->Gt_singleton);
81 [ + + ]: 3125 : Py_CLEAR(state->Gt_type);
82 [ + + ]: 3125 : Py_CLEAR(state->IfExp_type);
83 [ + + ]: 3125 : Py_CLEAR(state->If_type);
84 [ + + ]: 3125 : Py_CLEAR(state->ImportFrom_type);
85 [ + + ]: 3125 : Py_CLEAR(state->Import_type);
86 [ + + ]: 3125 : Py_CLEAR(state->In_singleton);
87 [ + + ]: 3125 : Py_CLEAR(state->In_type);
88 [ + + ]: 3125 : Py_CLEAR(state->Interactive_type);
89 [ + + ]: 3125 : Py_CLEAR(state->Invert_singleton);
90 [ + + ]: 3125 : Py_CLEAR(state->Invert_type);
91 [ + + ]: 3125 : Py_CLEAR(state->IsNot_singleton);
92 [ + + ]: 3125 : Py_CLEAR(state->IsNot_type);
93 [ + + ]: 3125 : Py_CLEAR(state->Is_singleton);
94 [ + + ]: 3125 : Py_CLEAR(state->Is_type);
95 [ + + ]: 3125 : Py_CLEAR(state->JoinedStr_type);
96 [ + + ]: 3125 : Py_CLEAR(state->LShift_singleton);
97 [ + + ]: 3125 : Py_CLEAR(state->LShift_type);
98 [ + + ]: 3125 : Py_CLEAR(state->Lambda_type);
99 [ + + ]: 3125 : Py_CLEAR(state->ListComp_type);
100 [ + + ]: 3125 : Py_CLEAR(state->List_type);
101 [ + + ]: 3125 : Py_CLEAR(state->Load_singleton);
102 [ + + ]: 3125 : Py_CLEAR(state->Load_type);
103 [ + + ]: 3125 : Py_CLEAR(state->LtE_singleton);
104 [ + + ]: 3125 : Py_CLEAR(state->LtE_type);
105 [ + + ]: 3125 : Py_CLEAR(state->Lt_singleton);
106 [ + + ]: 3125 : Py_CLEAR(state->Lt_type);
107 [ + + ]: 3125 : Py_CLEAR(state->MatMult_singleton);
108 [ + + ]: 3125 : Py_CLEAR(state->MatMult_type);
109 [ + + ]: 3125 : Py_CLEAR(state->MatchAs_type);
110 [ + + ]: 3125 : Py_CLEAR(state->MatchClass_type);
111 [ + + ]: 3125 : Py_CLEAR(state->MatchMapping_type);
112 [ + + ]: 3125 : Py_CLEAR(state->MatchOr_type);
113 [ + + ]: 3125 : Py_CLEAR(state->MatchSequence_type);
114 [ + + ]: 3125 : Py_CLEAR(state->MatchSingleton_type);
115 [ + + ]: 3125 : Py_CLEAR(state->MatchStar_type);
116 [ + + ]: 3125 : Py_CLEAR(state->MatchValue_type);
117 [ + + ]: 3125 : Py_CLEAR(state->Match_type);
118 [ + + ]: 3125 : Py_CLEAR(state->Mod_singleton);
119 [ + + ]: 3125 : Py_CLEAR(state->Mod_type);
120 [ + + ]: 3125 : Py_CLEAR(state->Module_type);
121 [ + + ]: 3125 : Py_CLEAR(state->Mult_singleton);
122 [ + + ]: 3125 : Py_CLEAR(state->Mult_type);
123 [ + + ]: 3125 : Py_CLEAR(state->Name_type);
124 [ + + ]: 3125 : Py_CLEAR(state->NamedExpr_type);
125 [ + + ]: 3125 : Py_CLEAR(state->Nonlocal_type);
126 [ + + ]: 3125 : Py_CLEAR(state->NotEq_singleton);
127 [ + + ]: 3125 : Py_CLEAR(state->NotEq_type);
128 [ + + ]: 3125 : Py_CLEAR(state->NotIn_singleton);
129 [ + + ]: 3125 : Py_CLEAR(state->NotIn_type);
130 [ + + ]: 3125 : Py_CLEAR(state->Not_singleton);
131 [ + + ]: 3125 : Py_CLEAR(state->Not_type);
132 [ + + ]: 3125 : Py_CLEAR(state->Or_singleton);
133 [ + + ]: 3125 : Py_CLEAR(state->Or_type);
134 [ + + ]: 3125 : Py_CLEAR(state->Pass_type);
135 [ + + ]: 3125 : Py_CLEAR(state->Pow_singleton);
136 [ + + ]: 3125 : Py_CLEAR(state->Pow_type);
137 [ + + ]: 3125 : Py_CLEAR(state->RShift_singleton);
138 [ + + ]: 3125 : Py_CLEAR(state->RShift_type);
139 [ + + ]: 3125 : Py_CLEAR(state->Raise_type);
140 [ + + ]: 3125 : Py_CLEAR(state->Return_type);
141 [ + + ]: 3125 : Py_CLEAR(state->SetComp_type);
142 [ + + ]: 3125 : Py_CLEAR(state->Set_type);
143 [ + + ]: 3125 : Py_CLEAR(state->Slice_type);
144 [ + + ]: 3125 : Py_CLEAR(state->Starred_type);
145 [ + + ]: 3125 : Py_CLEAR(state->Store_singleton);
146 [ + + ]: 3125 : Py_CLEAR(state->Store_type);
147 [ + + ]: 3125 : Py_CLEAR(state->Sub_singleton);
148 [ + + ]: 3125 : Py_CLEAR(state->Sub_type);
149 [ + + ]: 3125 : Py_CLEAR(state->Subscript_type);
150 [ + + ]: 3125 : Py_CLEAR(state->TryStar_type);
151 [ + + ]: 3125 : Py_CLEAR(state->Try_type);
152 [ + + ]: 3125 : Py_CLEAR(state->Tuple_type);
153 [ + + ]: 3125 : Py_CLEAR(state->TypeIgnore_type);
154 [ + + ]: 3125 : Py_CLEAR(state->UAdd_singleton);
155 [ + + ]: 3125 : Py_CLEAR(state->UAdd_type);
156 [ + + ]: 3125 : Py_CLEAR(state->USub_singleton);
157 [ + + ]: 3125 : Py_CLEAR(state->USub_type);
158 [ + + ]: 3125 : Py_CLEAR(state->UnaryOp_type);
159 [ + + ]: 3125 : Py_CLEAR(state->While_type);
160 [ + + ]: 3125 : Py_CLEAR(state->With_type);
161 [ + + ]: 3125 : Py_CLEAR(state->YieldFrom_type);
162 [ + + ]: 3125 : Py_CLEAR(state->Yield_type);
163 [ + + ]: 3125 : Py_CLEAR(state->__dict__);
164 [ + + ]: 3125 : Py_CLEAR(state->__doc__);
165 [ + + ]: 3125 : Py_CLEAR(state->__match_args__);
166 [ + + ]: 3125 : Py_CLEAR(state->__module__);
167 [ + + ]: 3125 : Py_CLEAR(state->_attributes);
168 [ + + ]: 3125 : Py_CLEAR(state->_fields);
169 [ + + ]: 3125 : Py_CLEAR(state->alias_type);
170 [ + + ]: 3125 : Py_CLEAR(state->annotation);
171 [ + + ]: 3125 : Py_CLEAR(state->arg);
172 [ + + ]: 3125 : Py_CLEAR(state->arg_type);
173 [ + + ]: 3125 : Py_CLEAR(state->args);
174 [ + + ]: 3125 : Py_CLEAR(state->argtypes);
175 [ + + ]: 3125 : Py_CLEAR(state->arguments_type);
176 [ + + ]: 3125 : Py_CLEAR(state->asname);
177 [ + + ]: 3125 : Py_CLEAR(state->ast);
178 [ + + ]: 3125 : Py_CLEAR(state->attr);
179 [ + + ]: 3125 : Py_CLEAR(state->bases);
180 [ + + ]: 3125 : Py_CLEAR(state->body);
181 [ + + ]: 3125 : Py_CLEAR(state->boolop_type);
182 [ + + ]: 3125 : Py_CLEAR(state->cases);
183 [ + + ]: 3125 : Py_CLEAR(state->cause);
184 [ + + ]: 3125 : Py_CLEAR(state->cls);
185 [ + + ]: 3125 : Py_CLEAR(state->cmpop_type);
186 [ + + ]: 3125 : Py_CLEAR(state->col_offset);
187 [ + + ]: 3125 : Py_CLEAR(state->comparators);
188 [ + + ]: 3125 : Py_CLEAR(state->comprehension_type);
189 [ + + ]: 3125 : Py_CLEAR(state->context_expr);
190 [ + + ]: 3125 : Py_CLEAR(state->conversion);
191 [ + + ]: 3125 : Py_CLEAR(state->ctx);
192 [ + + ]: 3125 : Py_CLEAR(state->decorator_list);
193 [ + + ]: 3125 : Py_CLEAR(state->defaults);
194 [ + + ]: 3125 : Py_CLEAR(state->elt);
195 [ + + ]: 3125 : Py_CLEAR(state->elts);
196 [ + + ]: 3125 : Py_CLEAR(state->end_col_offset);
197 [ + + ]: 3125 : Py_CLEAR(state->end_lineno);
198 [ + + ]: 3125 : Py_CLEAR(state->exc);
199 [ + + ]: 3125 : Py_CLEAR(state->excepthandler_type);
200 [ + + ]: 3125 : Py_CLEAR(state->expr_context_type);
201 [ + + ]: 3125 : Py_CLEAR(state->expr_type);
202 [ + + ]: 3125 : Py_CLEAR(state->finalbody);
203 [ + + ]: 3125 : Py_CLEAR(state->format_spec);
204 [ + + ]: 3125 : Py_CLEAR(state->func);
205 [ + + ]: 3125 : Py_CLEAR(state->generators);
206 [ + + ]: 3125 : Py_CLEAR(state->guard);
207 [ + + ]: 3125 : Py_CLEAR(state->handlers);
208 [ + + ]: 3125 : Py_CLEAR(state->id);
209 [ + + ]: 3125 : Py_CLEAR(state->ifs);
210 [ + + ]: 3125 : Py_CLEAR(state->is_async);
211 [ + + ]: 3125 : Py_CLEAR(state->items);
212 [ + + ]: 3125 : Py_CLEAR(state->iter);
213 [ + + ]: 3125 : Py_CLEAR(state->key);
214 [ + + ]: 3125 : Py_CLEAR(state->keys);
215 [ + + ]: 3125 : Py_CLEAR(state->keyword_type);
216 [ + + ]: 3125 : Py_CLEAR(state->keywords);
217 [ + + ]: 3125 : Py_CLEAR(state->kind);
218 [ + + ]: 3125 : Py_CLEAR(state->kw_defaults);
219 [ + + ]: 3125 : Py_CLEAR(state->kwarg);
220 [ + + ]: 3125 : Py_CLEAR(state->kwd_attrs);
221 [ + + ]: 3125 : Py_CLEAR(state->kwd_patterns);
222 [ + + ]: 3125 : Py_CLEAR(state->kwonlyargs);
223 [ + + ]: 3125 : Py_CLEAR(state->left);
224 [ + + ]: 3125 : Py_CLEAR(state->level);
225 [ + + ]: 3125 : Py_CLEAR(state->lineno);
226 [ + + ]: 3125 : Py_CLEAR(state->lower);
227 [ + + ]: 3125 : Py_CLEAR(state->match_case_type);
228 [ + + ]: 3125 : Py_CLEAR(state->mod_type);
229 [ + + ]: 3125 : Py_CLEAR(state->module);
230 [ + + ]: 3125 : Py_CLEAR(state->msg);
231 [ + + ]: 3125 : Py_CLEAR(state->name);
232 [ + + ]: 3125 : Py_CLEAR(state->names);
233 [ + + ]: 3125 : Py_CLEAR(state->op);
234 [ + + ]: 3125 : Py_CLEAR(state->operand);
235 [ + + ]: 3125 : Py_CLEAR(state->operator_type);
236 [ + + ]: 3125 : Py_CLEAR(state->ops);
237 [ + + ]: 3125 : Py_CLEAR(state->optional_vars);
238 [ + + ]: 3125 : Py_CLEAR(state->orelse);
239 [ + + ]: 3125 : Py_CLEAR(state->pattern);
240 [ + + ]: 3125 : Py_CLEAR(state->pattern_type);
241 [ + + ]: 3125 : Py_CLEAR(state->patterns);
242 [ + + ]: 3125 : Py_CLEAR(state->posonlyargs);
243 [ + + ]: 3125 : Py_CLEAR(state->rest);
244 [ + + ]: 3125 : Py_CLEAR(state->returns);
245 [ + + ]: 3125 : Py_CLEAR(state->right);
246 [ + + ]: 3125 : Py_CLEAR(state->simple);
247 [ + + ]: 3125 : Py_CLEAR(state->slice);
248 [ + + ]: 3125 : Py_CLEAR(state->step);
249 [ + + ]: 3125 : Py_CLEAR(state->stmt_type);
250 [ + + ]: 3125 : Py_CLEAR(state->subject);
251 [ + + ]: 3125 : Py_CLEAR(state->tag);
252 [ + + ]: 3125 : Py_CLEAR(state->target);
253 [ + + ]: 3125 : Py_CLEAR(state->targets);
254 [ + + ]: 3125 : Py_CLEAR(state->test);
255 [ + + ]: 3125 : Py_CLEAR(state->type);
256 [ + + ]: 3125 : Py_CLEAR(state->type_comment);
257 [ + + ]: 3125 : Py_CLEAR(state->type_ignore_type);
258 [ + + ]: 3125 : Py_CLEAR(state->type_ignores);
259 [ + + ]: 3125 : Py_CLEAR(state->unaryop_type);
260 [ + + ]: 3125 : Py_CLEAR(state->upper);
261 [ + + ]: 3125 : Py_CLEAR(state->value);
262 [ + + ]: 3125 : Py_CLEAR(state->values);
263 [ + + ]: 3125 : Py_CLEAR(state->vararg);
264 [ + + ]: 3125 : Py_CLEAR(state->withitem_type);
265 : :
266 : : #if !defined(NDEBUG)
267 : : state->initialized = -1;
268 : : #else
269 : 3125 : state->initialized = 0;
270 : : #endif
271 : 3125 : }
272 : :
273 : 1459 : static int init_identifiers(struct ast_state *state)
274 : : {
275 [ - + ]: 1459 : if ((state->__dict__ = PyUnicode_InternFromString("__dict__")) == NULL) return 0;
276 [ - + ]: 1459 : if ((state->__doc__ = PyUnicode_InternFromString("__doc__")) == NULL) return 0;
277 [ - + ]: 1459 : if ((state->__match_args__ = PyUnicode_InternFromString("__match_args__")) == NULL) return 0;
278 [ - + ]: 1459 : if ((state->__module__ = PyUnicode_InternFromString("__module__")) == NULL) return 0;
279 [ - + ]: 1459 : if ((state->_attributes = PyUnicode_InternFromString("_attributes")) == NULL) return 0;
280 [ - + ]: 1459 : if ((state->_fields = PyUnicode_InternFromString("_fields")) == NULL) return 0;
281 [ - + ]: 1459 : if ((state->annotation = PyUnicode_InternFromString("annotation")) == NULL) return 0;
282 [ - + ]: 1459 : if ((state->arg = PyUnicode_InternFromString("arg")) == NULL) return 0;
283 [ - + ]: 1459 : if ((state->args = PyUnicode_InternFromString("args")) == NULL) return 0;
284 [ - + ]: 1459 : if ((state->argtypes = PyUnicode_InternFromString("argtypes")) == NULL) return 0;
285 [ - + ]: 1459 : if ((state->asname = PyUnicode_InternFromString("asname")) == NULL) return 0;
286 [ - + ]: 1459 : if ((state->ast = PyUnicode_InternFromString("ast")) == NULL) return 0;
287 [ - + ]: 1459 : if ((state->attr = PyUnicode_InternFromString("attr")) == NULL) return 0;
288 [ - + ]: 1459 : if ((state->bases = PyUnicode_InternFromString("bases")) == NULL) return 0;
289 [ - + ]: 1459 : if ((state->body = PyUnicode_InternFromString("body")) == NULL) return 0;
290 [ - + ]: 1459 : if ((state->cases = PyUnicode_InternFromString("cases")) == NULL) return 0;
291 [ - + ]: 1459 : if ((state->cause = PyUnicode_InternFromString("cause")) == NULL) return 0;
292 [ - + ]: 1459 : if ((state->cls = PyUnicode_InternFromString("cls")) == NULL) return 0;
293 [ - + ]: 1459 : if ((state->col_offset = PyUnicode_InternFromString("col_offset")) == NULL) return 0;
294 [ - + ]: 1459 : if ((state->comparators = PyUnicode_InternFromString("comparators")) == NULL) return 0;
295 [ - + ]: 1459 : if ((state->context_expr = PyUnicode_InternFromString("context_expr")) == NULL) return 0;
296 [ - + ]: 1459 : if ((state->conversion = PyUnicode_InternFromString("conversion")) == NULL) return 0;
297 [ - + ]: 1459 : if ((state->ctx = PyUnicode_InternFromString("ctx")) == NULL) return 0;
298 [ - + ]: 1459 : if ((state->decorator_list = PyUnicode_InternFromString("decorator_list")) == NULL) return 0;
299 [ - + ]: 1459 : if ((state->defaults = PyUnicode_InternFromString("defaults")) == NULL) return 0;
300 [ - + ]: 1459 : if ((state->elt = PyUnicode_InternFromString("elt")) == NULL) return 0;
301 [ - + ]: 1459 : if ((state->elts = PyUnicode_InternFromString("elts")) == NULL) return 0;
302 [ - + ]: 1459 : if ((state->end_col_offset = PyUnicode_InternFromString("end_col_offset")) == NULL) return 0;
303 [ - + ]: 1459 : if ((state->end_lineno = PyUnicode_InternFromString("end_lineno")) == NULL) return 0;
304 [ - + ]: 1459 : if ((state->exc = PyUnicode_InternFromString("exc")) == NULL) return 0;
305 [ - + ]: 1459 : if ((state->finalbody = PyUnicode_InternFromString("finalbody")) == NULL) return 0;
306 [ - + ]: 1459 : if ((state->format_spec = PyUnicode_InternFromString("format_spec")) == NULL) return 0;
307 [ - + ]: 1459 : if ((state->func = PyUnicode_InternFromString("func")) == NULL) return 0;
308 [ - + ]: 1459 : if ((state->generators = PyUnicode_InternFromString("generators")) == NULL) return 0;
309 [ - + ]: 1459 : if ((state->guard = PyUnicode_InternFromString("guard")) == NULL) return 0;
310 [ - + ]: 1459 : if ((state->handlers = PyUnicode_InternFromString("handlers")) == NULL) return 0;
311 [ - + ]: 1459 : if ((state->id = PyUnicode_InternFromString("id")) == NULL) return 0;
312 [ - + ]: 1459 : if ((state->ifs = PyUnicode_InternFromString("ifs")) == NULL) return 0;
313 [ - + ]: 1459 : if ((state->is_async = PyUnicode_InternFromString("is_async")) == NULL) return 0;
314 [ - + ]: 1459 : if ((state->items = PyUnicode_InternFromString("items")) == NULL) return 0;
315 [ - + ]: 1459 : if ((state->iter = PyUnicode_InternFromString("iter")) == NULL) return 0;
316 [ - + ]: 1459 : if ((state->key = PyUnicode_InternFromString("key")) == NULL) return 0;
317 [ - + ]: 1459 : if ((state->keys = PyUnicode_InternFromString("keys")) == NULL) return 0;
318 [ - + ]: 1459 : if ((state->keywords = PyUnicode_InternFromString("keywords")) == NULL) return 0;
319 [ - + ]: 1459 : if ((state->kind = PyUnicode_InternFromString("kind")) == NULL) return 0;
320 [ - + ]: 1459 : if ((state->kw_defaults = PyUnicode_InternFromString("kw_defaults")) == NULL) return 0;
321 [ - + ]: 1459 : if ((state->kwarg = PyUnicode_InternFromString("kwarg")) == NULL) return 0;
322 [ - + ]: 1459 : if ((state->kwd_attrs = PyUnicode_InternFromString("kwd_attrs")) == NULL) return 0;
323 [ - + ]: 1459 : if ((state->kwd_patterns = PyUnicode_InternFromString("kwd_patterns")) == NULL) return 0;
324 [ - + ]: 1459 : if ((state->kwonlyargs = PyUnicode_InternFromString("kwonlyargs")) == NULL) return 0;
325 [ - + ]: 1459 : if ((state->left = PyUnicode_InternFromString("left")) == NULL) return 0;
326 [ - + ]: 1459 : if ((state->level = PyUnicode_InternFromString("level")) == NULL) return 0;
327 [ - + ]: 1459 : if ((state->lineno = PyUnicode_InternFromString("lineno")) == NULL) return 0;
328 [ - + ]: 1459 : if ((state->lower = PyUnicode_InternFromString("lower")) == NULL) return 0;
329 [ - + ]: 1459 : if ((state->module = PyUnicode_InternFromString("module")) == NULL) return 0;
330 [ - + ]: 1459 : if ((state->msg = PyUnicode_InternFromString("msg")) == NULL) return 0;
331 [ - + ]: 1459 : if ((state->name = PyUnicode_InternFromString("name")) == NULL) return 0;
332 [ - + ]: 1459 : if ((state->names = PyUnicode_InternFromString("names")) == NULL) return 0;
333 [ - + ]: 1459 : if ((state->op = PyUnicode_InternFromString("op")) == NULL) return 0;
334 [ - + ]: 1459 : if ((state->operand = PyUnicode_InternFromString("operand")) == NULL) return 0;
335 [ - + ]: 1459 : if ((state->ops = PyUnicode_InternFromString("ops")) == NULL) return 0;
336 [ - + ]: 1459 : if ((state->optional_vars = PyUnicode_InternFromString("optional_vars")) == NULL) return 0;
337 [ - + ]: 1459 : if ((state->orelse = PyUnicode_InternFromString("orelse")) == NULL) return 0;
338 [ - + ]: 1459 : if ((state->pattern = PyUnicode_InternFromString("pattern")) == NULL) return 0;
339 [ - + ]: 1459 : if ((state->patterns = PyUnicode_InternFromString("patterns")) == NULL) return 0;
340 [ - + ]: 1459 : if ((state->posonlyargs = PyUnicode_InternFromString("posonlyargs")) == NULL) return 0;
341 [ - + ]: 1459 : if ((state->rest = PyUnicode_InternFromString("rest")) == NULL) return 0;
342 [ - + ]: 1459 : if ((state->returns = PyUnicode_InternFromString("returns")) == NULL) return 0;
343 [ - + ]: 1459 : if ((state->right = PyUnicode_InternFromString("right")) == NULL) return 0;
344 [ - + ]: 1459 : if ((state->simple = PyUnicode_InternFromString("simple")) == NULL) return 0;
345 [ - + ]: 1459 : if ((state->slice = PyUnicode_InternFromString("slice")) == NULL) return 0;
346 [ - + ]: 1459 : if ((state->step = PyUnicode_InternFromString("step")) == NULL) return 0;
347 [ - + ]: 1459 : if ((state->subject = PyUnicode_InternFromString("subject")) == NULL) return 0;
348 [ - + ]: 1459 : if ((state->tag = PyUnicode_InternFromString("tag")) == NULL) return 0;
349 [ - + ]: 1459 : if ((state->target = PyUnicode_InternFromString("target")) == NULL) return 0;
350 [ - + ]: 1459 : if ((state->targets = PyUnicode_InternFromString("targets")) == NULL) return 0;
351 [ - + ]: 1459 : if ((state->test = PyUnicode_InternFromString("test")) == NULL) return 0;
352 [ - + ]: 1459 : if ((state->type = PyUnicode_InternFromString("type")) == NULL) return 0;
353 [ - + ]: 1459 : if ((state->type_comment = PyUnicode_InternFromString("type_comment")) == NULL) return 0;
354 [ - + ]: 1459 : if ((state->type_ignores = PyUnicode_InternFromString("type_ignores")) == NULL) return 0;
355 [ - + ]: 1459 : if ((state->upper = PyUnicode_InternFromString("upper")) == NULL) return 0;
356 [ - + ]: 1459 : if ((state->value = PyUnicode_InternFromString("value")) == NULL) return 0;
357 [ - + ]: 1459 : if ((state->values = PyUnicode_InternFromString("values")) == NULL) return 0;
358 [ - + ]: 1459 : if ((state->vararg = PyUnicode_InternFromString("vararg")) == NULL) return 0;
359 : 1459 : return 1;
360 : : };
361 : :
362 [ # # # # : 0 : GENERATE_ASDL_SEQ_CONSTRUCTOR(mod, mod_ty)
# # # # #
# # # ]
363 [ + - + + : 41131 : GENERATE_ASDL_SEQ_CONSTRUCTOR(stmt, stmt_ty)
- + + + -
+ - + ]
364 [ + - + + : 1413810 : GENERATE_ASDL_SEQ_CONSTRUCTOR(expr, expr_ty)
- + + + -
+ - + ]
365 [ + - + + : 612 : GENERATE_ASDL_SEQ_CONSTRUCTOR(comprehension, comprehension_ty)
- + + + -
+ - + ]
366 [ + - + + : 1484 : GENERATE_ASDL_SEQ_CONSTRUCTOR(excepthandler, excepthandler_ty)
- + + + -
+ - + ]
367 [ # # # # : 0 : GENERATE_ASDL_SEQ_CONSTRUCTOR(arguments, arguments_ty)
# # # # #
# # # ]
368 [ + - + + : 1137668 : GENERATE_ASDL_SEQ_CONSTRUCTOR(arg, arg_ty)
- + + + -
+ - + ]
369 [ + - + + : 137091 : GENERATE_ASDL_SEQ_CONSTRUCTOR(keyword, keyword_ty)
- + + + -
+ - + ]
370 [ + - + + : 1332 : GENERATE_ASDL_SEQ_CONSTRUCTOR(alias, alias_ty)
- + + + -
+ - + ]
371 [ + - + + : 393 : GENERATE_ASDL_SEQ_CONSTRUCTOR(withitem, withitem_ty)
- + + + -
+ - + ]
372 [ + - + - : 29 : GENERATE_ASDL_SEQ_CONSTRUCTOR(match_case, match_case_ty)
- + + - -
+ - + ]
373 [ + - + + : 418 : GENERATE_ASDL_SEQ_CONSTRUCTOR(pattern, pattern_ty)
- + + + -
+ - + ]
374 [ + - + + : 597 : GENERATE_ASDL_SEQ_CONSTRUCTOR(type_ignore, type_ignore_ty)
- + + + -
+ - + ]
375 : :
376 : : static PyObject* ast2obj_mod(struct ast_state *state, void*);
377 : : static const char * const Module_fields[]={
378 : : "body",
379 : : "type_ignores",
380 : : };
381 : : static const char * const Interactive_fields[]={
382 : : "body",
383 : : };
384 : : static const char * const Expression_fields[]={
385 : : "body",
386 : : };
387 : : static const char * const FunctionType_fields[]={
388 : : "argtypes",
389 : : "returns",
390 : : };
391 : : static const char * const stmt_attributes[] = {
392 : : "lineno",
393 : : "col_offset",
394 : : "end_lineno",
395 : : "end_col_offset",
396 : : };
397 : : static PyObject* ast2obj_stmt(struct ast_state *state, void*);
398 : : static const char * const FunctionDef_fields[]={
399 : : "name",
400 : : "args",
401 : : "body",
402 : : "decorator_list",
403 : : "returns",
404 : : "type_comment",
405 : : };
406 : : static const char * const AsyncFunctionDef_fields[]={
407 : : "name",
408 : : "args",
409 : : "body",
410 : : "decorator_list",
411 : : "returns",
412 : : "type_comment",
413 : : };
414 : : static const char * const ClassDef_fields[]={
415 : : "name",
416 : : "bases",
417 : : "keywords",
418 : : "body",
419 : : "decorator_list",
420 : : };
421 : : static const char * const Return_fields[]={
422 : : "value",
423 : : };
424 : : static const char * const Delete_fields[]={
425 : : "targets",
426 : : };
427 : : static const char * const Assign_fields[]={
428 : : "targets",
429 : : "value",
430 : : "type_comment",
431 : : };
432 : : static const char * const AugAssign_fields[]={
433 : : "target",
434 : : "op",
435 : : "value",
436 : : };
437 : : static const char * const AnnAssign_fields[]={
438 : : "target",
439 : : "annotation",
440 : : "value",
441 : : "simple",
442 : : };
443 : : static const char * const For_fields[]={
444 : : "target",
445 : : "iter",
446 : : "body",
447 : : "orelse",
448 : : "type_comment",
449 : : };
450 : : static const char * const AsyncFor_fields[]={
451 : : "target",
452 : : "iter",
453 : : "body",
454 : : "orelse",
455 : : "type_comment",
456 : : };
457 : : static const char * const While_fields[]={
458 : : "test",
459 : : "body",
460 : : "orelse",
461 : : };
462 : : static const char * const If_fields[]={
463 : : "test",
464 : : "body",
465 : : "orelse",
466 : : };
467 : : static const char * const With_fields[]={
468 : : "items",
469 : : "body",
470 : : "type_comment",
471 : : };
472 : : static const char * const AsyncWith_fields[]={
473 : : "items",
474 : : "body",
475 : : "type_comment",
476 : : };
477 : : static const char * const Match_fields[]={
478 : : "subject",
479 : : "cases",
480 : : };
481 : : static const char * const Raise_fields[]={
482 : : "exc",
483 : : "cause",
484 : : };
485 : : static const char * const Try_fields[]={
486 : : "body",
487 : : "handlers",
488 : : "orelse",
489 : : "finalbody",
490 : : };
491 : : static const char * const TryStar_fields[]={
492 : : "body",
493 : : "handlers",
494 : : "orelse",
495 : : "finalbody",
496 : : };
497 : : static const char * const Assert_fields[]={
498 : : "test",
499 : : "msg",
500 : : };
501 : : static const char * const Import_fields[]={
502 : : "names",
503 : : };
504 : : static const char * const ImportFrom_fields[]={
505 : : "module",
506 : : "names",
507 : : "level",
508 : : };
509 : : static const char * const Global_fields[]={
510 : : "names",
511 : : };
512 : : static const char * const Nonlocal_fields[]={
513 : : "names",
514 : : };
515 : : static const char * const Expr_fields[]={
516 : : "value",
517 : : };
518 : : static const char * const expr_attributes[] = {
519 : : "lineno",
520 : : "col_offset",
521 : : "end_lineno",
522 : : "end_col_offset",
523 : : };
524 : : static PyObject* ast2obj_expr(struct ast_state *state, void*);
525 : : static const char * const BoolOp_fields[]={
526 : : "op",
527 : : "values",
528 : : };
529 : : static const char * const NamedExpr_fields[]={
530 : : "target",
531 : : "value",
532 : : };
533 : : static const char * const BinOp_fields[]={
534 : : "left",
535 : : "op",
536 : : "right",
537 : : };
538 : : static const char * const UnaryOp_fields[]={
539 : : "op",
540 : : "operand",
541 : : };
542 : : static const char * const Lambda_fields[]={
543 : : "args",
544 : : "body",
545 : : };
546 : : static const char * const IfExp_fields[]={
547 : : "test",
548 : : "body",
549 : : "orelse",
550 : : };
551 : : static const char * const Dict_fields[]={
552 : : "keys",
553 : : "values",
554 : : };
555 : : static const char * const Set_fields[]={
556 : : "elts",
557 : : };
558 : : static const char * const ListComp_fields[]={
559 : : "elt",
560 : : "generators",
561 : : };
562 : : static const char * const SetComp_fields[]={
563 : : "elt",
564 : : "generators",
565 : : };
566 : : static const char * const DictComp_fields[]={
567 : : "key",
568 : : "value",
569 : : "generators",
570 : : };
571 : : static const char * const GeneratorExp_fields[]={
572 : : "elt",
573 : : "generators",
574 : : };
575 : : static const char * const Await_fields[]={
576 : : "value",
577 : : };
578 : : static const char * const Yield_fields[]={
579 : : "value",
580 : : };
581 : : static const char * const YieldFrom_fields[]={
582 : : "value",
583 : : };
584 : : static const char * const Compare_fields[]={
585 : : "left",
586 : : "ops",
587 : : "comparators",
588 : : };
589 : : static const char * const Call_fields[]={
590 : : "func",
591 : : "args",
592 : : "keywords",
593 : : };
594 : : static const char * const FormattedValue_fields[]={
595 : : "value",
596 : : "conversion",
597 : : "format_spec",
598 : : };
599 : : static const char * const JoinedStr_fields[]={
600 : : "values",
601 : : };
602 : : static const char * const Constant_fields[]={
603 : : "value",
604 : : "kind",
605 : : };
606 : : static const char * const Attribute_fields[]={
607 : : "value",
608 : : "attr",
609 : : "ctx",
610 : : };
611 : : static const char * const Subscript_fields[]={
612 : : "value",
613 : : "slice",
614 : : "ctx",
615 : : };
616 : : static const char * const Starred_fields[]={
617 : : "value",
618 : : "ctx",
619 : : };
620 : : static const char * const Name_fields[]={
621 : : "id",
622 : : "ctx",
623 : : };
624 : : static const char * const List_fields[]={
625 : : "elts",
626 : : "ctx",
627 : : };
628 : : static const char * const Tuple_fields[]={
629 : : "elts",
630 : : "ctx",
631 : : };
632 : : static const char * const Slice_fields[]={
633 : : "lower",
634 : : "upper",
635 : : "step",
636 : : };
637 : : static PyObject* ast2obj_expr_context(struct ast_state *state, expr_context_ty);
638 : : static PyObject* ast2obj_boolop(struct ast_state *state, boolop_ty);
639 : : static PyObject* ast2obj_operator(struct ast_state *state, operator_ty);
640 : : static PyObject* ast2obj_unaryop(struct ast_state *state, unaryop_ty);
641 : : static PyObject* ast2obj_cmpop(struct ast_state *state, cmpop_ty);
642 : : static PyObject* ast2obj_comprehension(struct ast_state *state, void*);
643 : : static const char * const comprehension_fields[]={
644 : : "target",
645 : : "iter",
646 : : "ifs",
647 : : "is_async",
648 : : };
649 : : static const char * const excepthandler_attributes[] = {
650 : : "lineno",
651 : : "col_offset",
652 : : "end_lineno",
653 : : "end_col_offset",
654 : : };
655 : : static PyObject* ast2obj_excepthandler(struct ast_state *state, void*);
656 : : static const char * const ExceptHandler_fields[]={
657 : : "type",
658 : : "name",
659 : : "body",
660 : : };
661 : : static PyObject* ast2obj_arguments(struct ast_state *state, void*);
662 : : static const char * const arguments_fields[]={
663 : : "posonlyargs",
664 : : "args",
665 : : "vararg",
666 : : "kwonlyargs",
667 : : "kw_defaults",
668 : : "kwarg",
669 : : "defaults",
670 : : };
671 : : static PyObject* ast2obj_arg(struct ast_state *state, void*);
672 : : static const char * const arg_attributes[] = {
673 : : "lineno",
674 : : "col_offset",
675 : : "end_lineno",
676 : : "end_col_offset",
677 : : };
678 : : static const char * const arg_fields[]={
679 : : "arg",
680 : : "annotation",
681 : : "type_comment",
682 : : };
683 : : static PyObject* ast2obj_keyword(struct ast_state *state, void*);
684 : : static const char * const keyword_attributes[] = {
685 : : "lineno",
686 : : "col_offset",
687 : : "end_lineno",
688 : : "end_col_offset",
689 : : };
690 : : static const char * const keyword_fields[]={
691 : : "arg",
692 : : "value",
693 : : };
694 : : static PyObject* ast2obj_alias(struct ast_state *state, void*);
695 : : static const char * const alias_attributes[] = {
696 : : "lineno",
697 : : "col_offset",
698 : : "end_lineno",
699 : : "end_col_offset",
700 : : };
701 : : static const char * const alias_fields[]={
702 : : "name",
703 : : "asname",
704 : : };
705 : : static PyObject* ast2obj_withitem(struct ast_state *state, void*);
706 : : static const char * const withitem_fields[]={
707 : : "context_expr",
708 : : "optional_vars",
709 : : };
710 : : static PyObject* ast2obj_match_case(struct ast_state *state, void*);
711 : : static const char * const match_case_fields[]={
712 : : "pattern",
713 : : "guard",
714 : : "body",
715 : : };
716 : : static const char * const pattern_attributes[] = {
717 : : "lineno",
718 : : "col_offset",
719 : : "end_lineno",
720 : : "end_col_offset",
721 : : };
722 : : static PyObject* ast2obj_pattern(struct ast_state *state, void*);
723 : : static const char * const MatchValue_fields[]={
724 : : "value",
725 : : };
726 : : static const char * const MatchSingleton_fields[]={
727 : : "value",
728 : : };
729 : : static const char * const MatchSequence_fields[]={
730 : : "patterns",
731 : : };
732 : : static const char * const MatchMapping_fields[]={
733 : : "keys",
734 : : "patterns",
735 : : "rest",
736 : : };
737 : : static const char * const MatchClass_fields[]={
738 : : "cls",
739 : : "patterns",
740 : : "kwd_attrs",
741 : : "kwd_patterns",
742 : : };
743 : : static const char * const MatchStar_fields[]={
744 : : "name",
745 : : };
746 : : static const char * const MatchAs_fields[]={
747 : : "pattern",
748 : : "name",
749 : : };
750 : : static const char * const MatchOr_fields[]={
751 : : "patterns",
752 : : };
753 : : static PyObject* ast2obj_type_ignore(struct ast_state *state, void*);
754 : : static const char * const TypeIgnore_fields[]={
755 : : "lineno",
756 : : "tag",
757 : : };
758 : :
759 : :
760 : :
761 : : typedef struct {
762 : : PyObject_HEAD
763 : : PyObject *dict;
764 : : } AST_object;
765 : :
766 : : static void
767 : 4876649 : ast_dealloc(AST_object *self)
768 : : {
769 : : /* bpo-31095: UnTrack is needed before calling any callbacks */
770 : 4876649 : PyTypeObject *tp = Py_TYPE(self);
771 : 4876649 : PyObject_GC_UnTrack(self);
772 [ + + ]: 4876649 : Py_CLEAR(self->dict);
773 : 4876649 : freefunc free_func = PyType_GetSlot(tp, Py_tp_free);
774 : : assert(free_func != NULL);
775 : 4876649 : free_func(self);
776 : 4876649 : Py_DECREF(tp);
777 : 4876649 : }
778 : :
779 : : static int
780 : 19770324 : ast_traverse(AST_object *self, visitproc visit, void *arg)
781 : : {
782 [ + - - + ]: 19770324 : Py_VISIT(Py_TYPE(self));
783 [ + + - + ]: 19770324 : Py_VISIT(self->dict);
784 : 19770324 : return 0;
785 : : }
786 : :
787 : : static int
788 : 8 : ast_clear(AST_object *self)
789 : : {
790 [ + + ]: 8 : Py_CLEAR(self->dict);
791 : 8 : return 0;
792 : : }
793 : :
794 : : static int
795 : 3261 : ast_type_init(PyObject *self, PyObject *args, PyObject *kw)
796 : : {
797 : 3261 : struct ast_state *state = get_ast_state();
798 [ - + ]: 3261 : if (state == NULL) {
799 : 0 : return -1;
800 : : }
801 : :
802 : 3261 : Py_ssize_t i, numfields = 0;
803 : 3261 : int res = -1;
804 : : PyObject *key, *value, *fields;
805 [ - + ]: 3261 : if (_PyObject_LookupAttr((PyObject*)Py_TYPE(self), state->_fields, &fields) < 0) {
806 : 0 : goto cleanup;
807 : : }
808 [ + - ]: 3261 : if (fields) {
809 : 3261 : numfields = PySequence_Size(fields);
810 [ - + ]: 3261 : if (numfields == -1) {
811 : 0 : goto cleanup;
812 : : }
813 : : }
814 : :
815 : 3261 : res = 0; /* if no error occurs, this stays 0 to the end */
816 [ + + ]: 3261 : if (numfields < PyTuple_GET_SIZE(args)) {
817 [ - + ]: 5 : PyErr_Format(PyExc_TypeError, "%.400s constructor takes at most "
818 : : "%zd positional argument%s",
819 : : _PyType_Name(Py_TYPE(self)),
820 : : numfields, numfields == 1 ? "" : "s");
821 : 5 : res = -1;
822 : 5 : goto cleanup;
823 : : }
824 [ + + ]: 4968 : for (i = 0; i < PyTuple_GET_SIZE(args); i++) {
825 : : /* cannot be reached when fields is NULL */
826 : 1712 : PyObject *name = PySequence_GetItem(fields, i);
827 [ - + ]: 1712 : if (!name) {
828 : 0 : res = -1;
829 : 0 : goto cleanup;
830 : : }
831 : 1712 : res = PyObject_SetAttr(self, name, PyTuple_GET_ITEM(args, i));
832 : 1712 : Py_DECREF(name);
833 [ - + ]: 1712 : if (res < 0) {
834 : 0 : goto cleanup;
835 : : }
836 : : }
837 [ + + ]: 3256 : if (kw) {
838 : 237 : i = 0; /* needed by PyDict_Next */
839 [ + + ]: 558 : while (PyDict_Next(kw, &i, &key, &value)) {
840 : 322 : int contains = PySequence_Contains(fields, key);
841 [ - + ]: 322 : if (contains == -1) {
842 : 0 : res = -1;
843 : 0 : goto cleanup;
844 [ + + ]: 322 : } else if (contains == 1) {
845 : 218 : Py_ssize_t p = PySequence_Index(fields, key);
846 [ - + ]: 218 : if (p == -1) {
847 : 0 : res = -1;
848 : 0 : goto cleanup;
849 : : }
850 [ + + ]: 218 : if (p < PyTuple_GET_SIZE(args)) {
851 : 1 : PyErr_Format(PyExc_TypeError,
852 : : "%.400s got multiple values for argument '%U'",
853 : 1 : Py_TYPE(self)->tp_name, key);
854 : 1 : res = -1;
855 : 1 : goto cleanup;
856 : : }
857 : : }
858 : 321 : res = PyObject_SetAttr(self, key, value);
859 [ - + ]: 321 : if (res < 0) {
860 : 0 : goto cleanup;
861 : : }
862 : : }
863 : : }
864 : 3255 : cleanup:
865 : 3261 : Py_XDECREF(fields);
866 : 3261 : return res;
867 : : }
868 : :
869 : : /* Pickling support */
870 : : static PyObject *
871 : 1851 : ast_type_reduce(PyObject *self, PyObject *unused)
872 : : {
873 : 1851 : struct ast_state *state = get_ast_state();
874 [ - + ]: 1851 : if (state == NULL) {
875 : 0 : return NULL;
876 : : }
877 : :
878 : : PyObject *dict;
879 [ - + ]: 1851 : if (_PyObject_LookupAttr(self, state->__dict__, &dict) < 0) {
880 : 0 : return NULL;
881 : : }
882 [ + - ]: 1851 : if (dict) {
883 : 1851 : return Py_BuildValue("O()N", Py_TYPE(self), dict);
884 : : }
885 : 0 : return Py_BuildValue("O()", Py_TYPE(self));
886 : : }
887 : :
888 : : static PyMemberDef ast_type_members[] = {
889 : : {"__dictoffset__", T_PYSSIZET, offsetof(AST_object, dict), READONLY},
890 : : {NULL} /* Sentinel */
891 : : };
892 : :
893 : : static PyMethodDef ast_type_methods[] = {
894 : : {"__reduce__", ast_type_reduce, METH_NOARGS, NULL},
895 : : {NULL}
896 : : };
897 : :
898 : : static PyGetSetDef ast_type_getsets[] = {
899 : : {"__dict__", PyObject_GenericGetDict, PyObject_GenericSetDict},
900 : : {NULL}
901 : : };
902 : :
903 : : static PyType_Slot AST_type_slots[] = {
904 : : {Py_tp_dealloc, ast_dealloc},
905 : : {Py_tp_getattro, PyObject_GenericGetAttr},
906 : : {Py_tp_setattro, PyObject_GenericSetAttr},
907 : : {Py_tp_traverse, ast_traverse},
908 : : {Py_tp_clear, ast_clear},
909 : : {Py_tp_members, ast_type_members},
910 : : {Py_tp_methods, ast_type_methods},
911 : : {Py_tp_getset, ast_type_getsets},
912 : : {Py_tp_init, ast_type_init},
913 : : {Py_tp_alloc, PyType_GenericAlloc},
914 : : {Py_tp_new, PyType_GenericNew},
915 : : {Py_tp_free, PyObject_GC_Del},
916 : : {0, 0},
917 : : };
918 : :
919 : : static PyType_Spec AST_type_spec = {
920 : : "ast.AST",
921 : : sizeof(AST_object),
922 : : 0,
923 : : Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE | Py_TPFLAGS_HAVE_GC,
924 : : AST_type_slots
925 : : };
926 : :
927 : : static PyObject *
928 : 172162 : make_type(struct ast_state *state, const char *type, PyObject* base,
929 : : const char* const* fields, int num_fields, const char *doc)
930 : : {
931 : : PyObject *fnames, *result;
932 : : int i;
933 : 172162 : fnames = PyTuple_New(num_fields);
934 [ - + ]: 172162 : if (!fnames) return NULL;
935 [ + + ]: 431864 : for (i = 0; i < num_fields; i++) {
936 : 259702 : PyObject *field = PyUnicode_InternFromString(fields[i]);
937 [ - + ]: 259702 : if (!field) {
938 : 0 : Py_DECREF(fnames);
939 : 0 : return NULL;
940 : : }
941 : 259702 : PyTuple_SET_ITEM(fnames, i, field);
942 : : }
943 : 172162 : result = PyObject_CallFunction((PyObject*)&PyType_Type, "s(O){OOOOOOOs}",
944 : : type, base,
945 : : state->_fields, fnames,
946 : : state->__match_args__, fnames,
947 : : state->__module__,
948 : : state->ast,
949 : : state->__doc__, doc);
950 : 172162 : Py_DECREF(fnames);
951 : 172162 : return result;
952 : : }
953 : :
954 : : static int
955 : 26262 : add_attributes(struct ast_state *state, PyObject *type, const char * const *attrs, int num_fields)
956 : : {
957 : : int i, result;
958 : 26262 : PyObject *s, *l = PyTuple_New(num_fields);
959 [ - + ]: 26262 : if (!l)
960 : 0 : return 0;
961 [ + + ]: 67114 : for (i = 0; i < num_fields; i++) {
962 : 40852 : s = PyUnicode_InternFromString(attrs[i]);
963 [ - + ]: 40852 : if (!s) {
964 : 0 : Py_DECREF(l);
965 : 0 : return 0;
966 : : }
967 : 40852 : PyTuple_SET_ITEM(l, i, s);
968 : : }
969 : 26262 : result = PyObject_SetAttr(type, state->_attributes, l) >= 0;
970 : 26262 : Py_DECREF(l);
971 : 26262 : return result;
972 : : }
973 : :
974 : : /* Conversion AST -> Python */
975 : :
976 : 2368942 : static PyObject* ast2obj_list(struct ast_state *state, asdl_seq *seq, PyObject* (*func)(struct ast_state *state, void*))
977 : : {
978 [ + + ]: 2368942 : Py_ssize_t i, n = asdl_seq_LEN(seq);
979 : 2368942 : PyObject *result = PyList_New(n);
980 : : PyObject *value;
981 [ - + ]: 2368942 : if (!result)
982 : 0 : return NULL;
983 [ + + ]: 5069191 : for (i = 0; i < n; i++) {
984 : 2700249 : value = func(state, asdl_seq_GET_UNTYPED(seq, i));
985 [ - + ]: 2700249 : if (!value) {
986 : 0 : Py_DECREF(result);
987 : 0 : return NULL;
988 : : }
989 : 2700249 : PyList_SET_ITEM(result, i, value);
990 : : }
991 : 2368942 : return result;
992 : : }
993 : :
994 : 4778104 : static PyObject* ast2obj_object(struct ast_state *Py_UNUSED(state), void *o)
995 : : {
996 [ + + ]: 4778104 : if (!o)
997 : 1527388 : o = Py_None;
998 : 4778104 : Py_INCREF((PyObject*)o);
999 : 4778104 : return (PyObject*)o;
1000 : : }
1001 : : #define ast2obj_constant ast2obj_object
1002 : : #define ast2obj_identifier ast2obj_object
1003 : : #define ast2obj_string ast2obj_object
1004 : :
1005 : 18816721 : static PyObject* ast2obj_int(struct ast_state *Py_UNUSED(state), long b)
1006 : : {
1007 : 18816721 : return PyLong_FromLong(b);
1008 : : }
1009 : :
1010 : : /* Conversion Python -> AST */
1011 : :
1012 : 183648 : static int obj2ast_object(struct ast_state *Py_UNUSED(state), PyObject* obj, PyObject** out, PyArena* arena)
1013 : : {
1014 [ - + ]: 183648 : if (obj == Py_None)
1015 : 0 : obj = NULL;
1016 [ + - ]: 183648 : if (obj) {
1017 [ - + ]: 183648 : if (_PyArena_AddPyObject(arena, obj) < 0) {
1018 : 0 : *out = NULL;
1019 : 0 : return -1;
1020 : : }
1021 : 183648 : Py_INCREF(obj);
1022 : : }
1023 : 183648 : *out = obj;
1024 : 183648 : return 0;
1025 : : }
1026 : :
1027 : 46697 : static int obj2ast_constant(struct ast_state *Py_UNUSED(state), PyObject* obj, PyObject** out, PyArena* arena)
1028 : : {
1029 [ - + ]: 46697 : if (_PyArena_AddPyObject(arena, obj) < 0) {
1030 : 0 : *out = NULL;
1031 : 0 : return -1;
1032 : : }
1033 : 46697 : Py_INCREF(obj);
1034 : 46697 : *out = obj;
1035 : 46697 : return 0;
1036 : : }
1037 : :
1038 : 183649 : static int obj2ast_identifier(struct ast_state *state, PyObject* obj, PyObject** out, PyArena* arena)
1039 : : {
1040 [ + + + - ]: 183649 : if (!PyUnicode_CheckExact(obj) && obj != Py_None) {
1041 : 1 : PyErr_SetString(PyExc_TypeError, "AST identifier must be of type str");
1042 : 1 : return 1;
1043 : : }
1044 : 183648 : return obj2ast_object(state, obj, out, arena);
1045 : : }
1046 : :
1047 : 0 : static int obj2ast_string(struct ast_state *state, PyObject* obj, PyObject** out, PyArena* arena)
1048 : : {
1049 [ # # # # ]: 0 : if (!PyUnicode_CheckExact(obj) && !PyBytes_CheckExact(obj)) {
1050 : 0 : PyErr_SetString(PyExc_TypeError, "AST string must be of type str");
1051 : 0 : return 1;
1052 : : }
1053 : 0 : return obj2ast_object(state, obj, out, arena);
1054 : : }
1055 : :
1056 : 1438455 : static int obj2ast_int(struct ast_state* Py_UNUSED(state), PyObject* obj, int* out, PyArena* arena)
1057 : : {
1058 : : int i;
1059 [ + + ]: 1438455 : if (!PyLong_Check(obj)) {
1060 : 1 : PyErr_Format(PyExc_ValueError, "invalid integer value: %R", obj);
1061 : 1 : return 1;
1062 : : }
1063 : :
1064 : 1438454 : i = _PyLong_AsInt(obj);
1065 [ + + - + ]: 1438454 : if (i == -1 && PyErr_Occurred())
1066 : 0 : return 1;
1067 : 1438454 : *out = i;
1068 : 1438454 : return 0;
1069 : : }
1070 : :
1071 : 1459 : static int add_ast_fields(struct ast_state *state)
1072 : : {
1073 : : PyObject *empty_tuple;
1074 : 1459 : empty_tuple = PyTuple_New(0);
1075 [ + - + - ]: 2918 : if (!empty_tuple ||
1076 [ + - ]: 2918 : PyObject_SetAttrString(state->AST_type, "_fields", empty_tuple) < 0 ||
1077 [ - + ]: 2918 : PyObject_SetAttrString(state->AST_type, "__match_args__", empty_tuple) < 0 ||
1078 : 1459 : PyObject_SetAttrString(state->AST_type, "_attributes", empty_tuple) < 0) {
1079 : 0 : Py_XDECREF(empty_tuple);
1080 : 0 : return -1;
1081 : : }
1082 : 1459 : Py_DECREF(empty_tuple);
1083 : 1459 : return 0;
1084 : : }
1085 : :
1086 : :
1087 : :
1088 : : static int
1089 : 47758 : init_types(struct ast_state *state)
1090 : : {
1091 : : // init_types() must not be called after _PyAST_Fini()
1092 : : // has been called
1093 : : assert(state->initialized >= 0);
1094 : :
1095 [ + + ]: 47758 : if (state->initialized) {
1096 : 46299 : return 1;
1097 : : }
1098 [ - + ]: 1459 : if (init_identifiers(state) < 0) {
1099 : 0 : return 0;
1100 : : }
1101 : 1459 : state->AST_type = PyType_FromSpec(&AST_type_spec);
1102 [ - + ]: 1459 : if (!state->AST_type) {
1103 : 0 : return 0;
1104 : : }
1105 [ - + ]: 1459 : if (add_ast_fields(state) < 0) {
1106 : 0 : return 0;
1107 : : }
1108 : 1459 : state->mod_type = make_type(state, "mod", state->AST_type, NULL, 0,
1109 : : "mod = Module(stmt* body, type_ignore* type_ignores)\n"
1110 : : " | Interactive(stmt* body)\n"
1111 : : " | Expression(expr body)\n"
1112 : : " | FunctionType(expr* argtypes, expr returns)");
1113 [ - + ]: 1459 : if (!state->mod_type) return 0;
1114 [ - + ]: 1459 : if (!add_attributes(state, state->mod_type, NULL, 0)) return 0;
1115 : 1459 : state->Module_type = make_type(state, "Module", state->mod_type,
1116 : : Module_fields, 2,
1117 : : "Module(stmt* body, type_ignore* type_ignores)");
1118 [ - + ]: 1459 : if (!state->Module_type) return 0;
1119 : 1459 : state->Interactive_type = make_type(state, "Interactive", state->mod_type,
1120 : : Interactive_fields, 1,
1121 : : "Interactive(stmt* body)");
1122 [ - + ]: 1459 : if (!state->Interactive_type) return 0;
1123 : 1459 : state->Expression_type = make_type(state, "Expression", state->mod_type,
1124 : : Expression_fields, 1,
1125 : : "Expression(expr body)");
1126 [ - + ]: 1459 : if (!state->Expression_type) return 0;
1127 : 1459 : state->FunctionType_type = make_type(state, "FunctionType",
1128 : : state->mod_type, FunctionType_fields,
1129 : : 2,
1130 : : "FunctionType(expr* argtypes, expr returns)");
1131 [ - + ]: 1459 : if (!state->FunctionType_type) return 0;
1132 : 1459 : state->stmt_type = make_type(state, "stmt", state->AST_type, NULL, 0,
1133 : : "stmt = FunctionDef(identifier name, arguments args, stmt* body, expr* decorator_list, expr? returns, string? type_comment)\n"
1134 : : " | AsyncFunctionDef(identifier name, arguments args, stmt* body, expr* decorator_list, expr? returns, string? type_comment)\n"
1135 : : " | ClassDef(identifier name, expr* bases, keyword* keywords, stmt* body, expr* decorator_list)\n"
1136 : : " | Return(expr? value)\n"
1137 : : " | Delete(expr* targets)\n"
1138 : : " | Assign(expr* targets, expr value, string? type_comment)\n"
1139 : : " | AugAssign(expr target, operator op, expr value)\n"
1140 : : " | AnnAssign(expr target, expr annotation, expr? value, int simple)\n"
1141 : : " | For(expr target, expr iter, stmt* body, stmt* orelse, string? type_comment)\n"
1142 : : " | AsyncFor(expr target, expr iter, stmt* body, stmt* orelse, string? type_comment)\n"
1143 : : " | While(expr test, stmt* body, stmt* orelse)\n"
1144 : : " | If(expr test, stmt* body, stmt* orelse)\n"
1145 : : " | With(withitem* items, stmt* body, string? type_comment)\n"
1146 : : " | AsyncWith(withitem* items, stmt* body, string? type_comment)\n"
1147 : : " | Match(expr subject, match_case* cases)\n"
1148 : : " | Raise(expr? exc, expr? cause)\n"
1149 : : " | Try(stmt* body, excepthandler* handlers, stmt* orelse, stmt* finalbody)\n"
1150 : : " | TryStar(stmt* body, excepthandler* handlers, stmt* orelse, stmt* finalbody)\n"
1151 : : " | Assert(expr test, expr? msg)\n"
1152 : : " | Import(alias* names)\n"
1153 : : " | ImportFrom(identifier? module, alias* names, int? level)\n"
1154 : : " | Global(identifier* names)\n"
1155 : : " | Nonlocal(identifier* names)\n"
1156 : : " | Expr(expr value)\n"
1157 : : " | Pass\n"
1158 : : " | Break\n"
1159 : : " | Continue");
1160 [ - + ]: 1459 : if (!state->stmt_type) return 0;
1161 [ - + ]: 1459 : if (!add_attributes(state, state->stmt_type, stmt_attributes, 4)) return 0;
1162 [ - + ]: 1459 : if (PyObject_SetAttr(state->stmt_type, state->end_lineno, Py_None) == -1)
1163 : 0 : return 0;
1164 [ - + ]: 1459 : if (PyObject_SetAttr(state->stmt_type, state->end_col_offset, Py_None) ==
1165 : : -1)
1166 : 0 : return 0;
1167 : 1459 : state->FunctionDef_type = make_type(state, "FunctionDef", state->stmt_type,
1168 : : FunctionDef_fields, 6,
1169 : : "FunctionDef(identifier name, arguments args, stmt* body, expr* decorator_list, expr? returns, string? type_comment)");
1170 [ - + ]: 1459 : if (!state->FunctionDef_type) return 0;
1171 [ - + ]: 1459 : if (PyObject_SetAttr(state->FunctionDef_type, state->returns, Py_None) ==
1172 : : -1)
1173 : 0 : return 0;
1174 [ - + ]: 1459 : if (PyObject_SetAttr(state->FunctionDef_type, state->type_comment, Py_None)
1175 : : == -1)
1176 : 0 : return 0;
1177 : 1459 : state->AsyncFunctionDef_type = make_type(state, "AsyncFunctionDef",
1178 : : state->stmt_type,
1179 : : AsyncFunctionDef_fields, 6,
1180 : : "AsyncFunctionDef(identifier name, arguments args, stmt* body, expr* decorator_list, expr? returns, string? type_comment)");
1181 [ - + ]: 1459 : if (!state->AsyncFunctionDef_type) return 0;
1182 [ - + ]: 1459 : if (PyObject_SetAttr(state->AsyncFunctionDef_type, state->returns, Py_None)
1183 : : == -1)
1184 : 0 : return 0;
1185 [ - + ]: 1459 : if (PyObject_SetAttr(state->AsyncFunctionDef_type, state->type_comment,
1186 : : Py_None) == -1)
1187 : 0 : return 0;
1188 : 1459 : state->ClassDef_type = make_type(state, "ClassDef", state->stmt_type,
1189 : : ClassDef_fields, 5,
1190 : : "ClassDef(identifier name, expr* bases, keyword* keywords, stmt* body, expr* decorator_list)");
1191 [ - + ]: 1459 : if (!state->ClassDef_type) return 0;
1192 : 1459 : state->Return_type = make_type(state, "Return", state->stmt_type,
1193 : : Return_fields, 1,
1194 : : "Return(expr? value)");
1195 [ - + ]: 1459 : if (!state->Return_type) return 0;
1196 [ - + ]: 1459 : if (PyObject_SetAttr(state->Return_type, state->value, Py_None) == -1)
1197 : 0 : return 0;
1198 : 1459 : state->Delete_type = make_type(state, "Delete", state->stmt_type,
1199 : : Delete_fields, 1,
1200 : : "Delete(expr* targets)");
1201 [ - + ]: 1459 : if (!state->Delete_type) return 0;
1202 : 1459 : state->Assign_type = make_type(state, "Assign", state->stmt_type,
1203 : : Assign_fields, 3,
1204 : : "Assign(expr* targets, expr value, string? type_comment)");
1205 [ - + ]: 1459 : if (!state->Assign_type) return 0;
1206 [ - + ]: 1459 : if (PyObject_SetAttr(state->Assign_type, state->type_comment, Py_None) ==
1207 : : -1)
1208 : 0 : return 0;
1209 : 1459 : state->AugAssign_type = make_type(state, "AugAssign", state->stmt_type,
1210 : : AugAssign_fields, 3,
1211 : : "AugAssign(expr target, operator op, expr value)");
1212 [ - + ]: 1459 : if (!state->AugAssign_type) return 0;
1213 : 1459 : state->AnnAssign_type = make_type(state, "AnnAssign", state->stmt_type,
1214 : : AnnAssign_fields, 4,
1215 : : "AnnAssign(expr target, expr annotation, expr? value, int simple)");
1216 [ - + ]: 1459 : if (!state->AnnAssign_type) return 0;
1217 [ - + ]: 1459 : if (PyObject_SetAttr(state->AnnAssign_type, state->value, Py_None) == -1)
1218 : 0 : return 0;
1219 : 1459 : state->For_type = make_type(state, "For", state->stmt_type, For_fields, 5,
1220 : : "For(expr target, expr iter, stmt* body, stmt* orelse, string? type_comment)");
1221 [ - + ]: 1459 : if (!state->For_type) return 0;
1222 [ - + ]: 1459 : if (PyObject_SetAttr(state->For_type, state->type_comment, Py_None) == -1)
1223 : 0 : return 0;
1224 : 1459 : state->AsyncFor_type = make_type(state, "AsyncFor", state->stmt_type,
1225 : : AsyncFor_fields, 5,
1226 : : "AsyncFor(expr target, expr iter, stmt* body, stmt* orelse, string? type_comment)");
1227 [ - + ]: 1459 : if (!state->AsyncFor_type) return 0;
1228 [ - + ]: 1459 : if (PyObject_SetAttr(state->AsyncFor_type, state->type_comment, Py_None) ==
1229 : : -1)
1230 : 0 : return 0;
1231 : 1459 : state->While_type = make_type(state, "While", state->stmt_type,
1232 : : While_fields, 3,
1233 : : "While(expr test, stmt* body, stmt* orelse)");
1234 [ - + ]: 1459 : if (!state->While_type) return 0;
1235 : 1459 : state->If_type = make_type(state, "If", state->stmt_type, If_fields, 3,
1236 : : "If(expr test, stmt* body, stmt* orelse)");
1237 [ - + ]: 1459 : if (!state->If_type) return 0;
1238 : 1459 : state->With_type = make_type(state, "With", state->stmt_type, With_fields,
1239 : : 3,
1240 : : "With(withitem* items, stmt* body, string? type_comment)");
1241 [ - + ]: 1459 : if (!state->With_type) return 0;
1242 [ - + ]: 1459 : if (PyObject_SetAttr(state->With_type, state->type_comment, Py_None) == -1)
1243 : 0 : return 0;
1244 : 1459 : state->AsyncWith_type = make_type(state, "AsyncWith", state->stmt_type,
1245 : : AsyncWith_fields, 3,
1246 : : "AsyncWith(withitem* items, stmt* body, string? type_comment)");
1247 [ - + ]: 1459 : if (!state->AsyncWith_type) return 0;
1248 [ - + ]: 1459 : if (PyObject_SetAttr(state->AsyncWith_type, state->type_comment, Py_None)
1249 : : == -1)
1250 : 0 : return 0;
1251 : 1459 : state->Match_type = make_type(state, "Match", state->stmt_type,
1252 : : Match_fields, 2,
1253 : : "Match(expr subject, match_case* cases)");
1254 [ - + ]: 1459 : if (!state->Match_type) return 0;
1255 : 1459 : state->Raise_type = make_type(state, "Raise", state->stmt_type,
1256 : : Raise_fields, 2,
1257 : : "Raise(expr? exc, expr? cause)");
1258 [ - + ]: 1459 : if (!state->Raise_type) return 0;
1259 [ - + ]: 1459 : if (PyObject_SetAttr(state->Raise_type, state->exc, Py_None) == -1)
1260 : 0 : return 0;
1261 [ - + ]: 1459 : if (PyObject_SetAttr(state->Raise_type, state->cause, Py_None) == -1)
1262 : 0 : return 0;
1263 : 1459 : state->Try_type = make_type(state, "Try", state->stmt_type, Try_fields, 4,
1264 : : "Try(stmt* body, excepthandler* handlers, stmt* orelse, stmt* finalbody)");
1265 [ - + ]: 1459 : if (!state->Try_type) return 0;
1266 : 1459 : state->TryStar_type = make_type(state, "TryStar", state->stmt_type,
1267 : : TryStar_fields, 4,
1268 : : "TryStar(stmt* body, excepthandler* handlers, stmt* orelse, stmt* finalbody)");
1269 [ - + ]: 1459 : if (!state->TryStar_type) return 0;
1270 : 1459 : state->Assert_type = make_type(state, "Assert", state->stmt_type,
1271 : : Assert_fields, 2,
1272 : : "Assert(expr test, expr? msg)");
1273 [ - + ]: 1459 : if (!state->Assert_type) return 0;
1274 [ - + ]: 1459 : if (PyObject_SetAttr(state->Assert_type, state->msg, Py_None) == -1)
1275 : 0 : return 0;
1276 : 1459 : state->Import_type = make_type(state, "Import", state->stmt_type,
1277 : : Import_fields, 1,
1278 : : "Import(alias* names)");
1279 [ - + ]: 1459 : if (!state->Import_type) return 0;
1280 : 1459 : state->ImportFrom_type = make_type(state, "ImportFrom", state->stmt_type,
1281 : : ImportFrom_fields, 3,
1282 : : "ImportFrom(identifier? module, alias* names, int? level)");
1283 [ - + ]: 1459 : if (!state->ImportFrom_type) return 0;
1284 [ - + ]: 1459 : if (PyObject_SetAttr(state->ImportFrom_type, state->module, Py_None) == -1)
1285 : 0 : return 0;
1286 [ - + ]: 1459 : if (PyObject_SetAttr(state->ImportFrom_type, state->level, Py_None) == -1)
1287 : 0 : return 0;
1288 : 1459 : state->Global_type = make_type(state, "Global", state->stmt_type,
1289 : : Global_fields, 1,
1290 : : "Global(identifier* names)");
1291 [ - + ]: 1459 : if (!state->Global_type) return 0;
1292 : 1459 : state->Nonlocal_type = make_type(state, "Nonlocal", state->stmt_type,
1293 : : Nonlocal_fields, 1,
1294 : : "Nonlocal(identifier* names)");
1295 [ - + ]: 1459 : if (!state->Nonlocal_type) return 0;
1296 : 1459 : state->Expr_type = make_type(state, "Expr", state->stmt_type, Expr_fields,
1297 : : 1,
1298 : : "Expr(expr value)");
1299 [ - + ]: 1459 : if (!state->Expr_type) return 0;
1300 : 1459 : state->Pass_type = make_type(state, "Pass", state->stmt_type, NULL, 0,
1301 : : "Pass");
1302 [ - + ]: 1459 : if (!state->Pass_type) return 0;
1303 : 1459 : state->Break_type = make_type(state, "Break", state->stmt_type, NULL, 0,
1304 : : "Break");
1305 [ - + ]: 1459 : if (!state->Break_type) return 0;
1306 : 1459 : state->Continue_type = make_type(state, "Continue", state->stmt_type, NULL,
1307 : : 0,
1308 : : "Continue");
1309 [ - + ]: 1459 : if (!state->Continue_type) return 0;
1310 : 1459 : state->expr_type = make_type(state, "expr", state->AST_type, NULL, 0,
1311 : : "expr = BoolOp(boolop op, expr* values)\n"
1312 : : " | NamedExpr(expr target, expr value)\n"
1313 : : " | BinOp(expr left, operator op, expr right)\n"
1314 : : " | UnaryOp(unaryop op, expr operand)\n"
1315 : : " | Lambda(arguments args, expr body)\n"
1316 : : " | IfExp(expr test, expr body, expr orelse)\n"
1317 : : " | Dict(expr* keys, expr* values)\n"
1318 : : " | Set(expr* elts)\n"
1319 : : " | ListComp(expr elt, comprehension* generators)\n"
1320 : : " | SetComp(expr elt, comprehension* generators)\n"
1321 : : " | DictComp(expr key, expr value, comprehension* generators)\n"
1322 : : " | GeneratorExp(expr elt, comprehension* generators)\n"
1323 : : " | Await(expr value)\n"
1324 : : " | Yield(expr? value)\n"
1325 : : " | YieldFrom(expr value)\n"
1326 : : " | Compare(expr left, cmpop* ops, expr* comparators)\n"
1327 : : " | Call(expr func, expr* args, keyword* keywords)\n"
1328 : : " | FormattedValue(expr value, int conversion, expr? format_spec)\n"
1329 : : " | JoinedStr(expr* values)\n"
1330 : : " | Constant(constant value, string? kind)\n"
1331 : : " | Attribute(expr value, identifier attr, expr_context ctx)\n"
1332 : : " | Subscript(expr value, expr slice, expr_context ctx)\n"
1333 : : " | Starred(expr value, expr_context ctx)\n"
1334 : : " | Name(identifier id, expr_context ctx)\n"
1335 : : " | List(expr* elts, expr_context ctx)\n"
1336 : : " | Tuple(expr* elts, expr_context ctx)\n"
1337 : : " | Slice(expr? lower, expr? upper, expr? step)");
1338 [ - + ]: 1459 : if (!state->expr_type) return 0;
1339 [ - + ]: 1459 : if (!add_attributes(state, state->expr_type, expr_attributes, 4)) return 0;
1340 [ - + ]: 1459 : if (PyObject_SetAttr(state->expr_type, state->end_lineno, Py_None) == -1)
1341 : 0 : return 0;
1342 [ - + ]: 1459 : if (PyObject_SetAttr(state->expr_type, state->end_col_offset, Py_None) ==
1343 : : -1)
1344 : 0 : return 0;
1345 : 1459 : state->BoolOp_type = make_type(state, "BoolOp", state->expr_type,
1346 : : BoolOp_fields, 2,
1347 : : "BoolOp(boolop op, expr* values)");
1348 [ - + ]: 1459 : if (!state->BoolOp_type) return 0;
1349 : 1459 : state->NamedExpr_type = make_type(state, "NamedExpr", state->expr_type,
1350 : : NamedExpr_fields, 2,
1351 : : "NamedExpr(expr target, expr value)");
1352 [ - + ]: 1459 : if (!state->NamedExpr_type) return 0;
1353 : 1459 : state->BinOp_type = make_type(state, "BinOp", state->expr_type,
1354 : : BinOp_fields, 3,
1355 : : "BinOp(expr left, operator op, expr right)");
1356 [ - + ]: 1459 : if (!state->BinOp_type) return 0;
1357 : 1459 : state->UnaryOp_type = make_type(state, "UnaryOp", state->expr_type,
1358 : : UnaryOp_fields, 2,
1359 : : "UnaryOp(unaryop op, expr operand)");
1360 [ - + ]: 1459 : if (!state->UnaryOp_type) return 0;
1361 : 1459 : state->Lambda_type = make_type(state, "Lambda", state->expr_type,
1362 : : Lambda_fields, 2,
1363 : : "Lambda(arguments args, expr body)");
1364 [ - + ]: 1459 : if (!state->Lambda_type) return 0;
1365 : 1459 : state->IfExp_type = make_type(state, "IfExp", state->expr_type,
1366 : : IfExp_fields, 3,
1367 : : "IfExp(expr test, expr body, expr orelse)");
1368 [ - + ]: 1459 : if (!state->IfExp_type) return 0;
1369 : 1459 : state->Dict_type = make_type(state, "Dict", state->expr_type, Dict_fields,
1370 : : 2,
1371 : : "Dict(expr* keys, expr* values)");
1372 [ - + ]: 1459 : if (!state->Dict_type) return 0;
1373 : 1459 : state->Set_type = make_type(state, "Set", state->expr_type, Set_fields, 1,
1374 : : "Set(expr* elts)");
1375 [ - + ]: 1459 : if (!state->Set_type) return 0;
1376 : 1459 : state->ListComp_type = make_type(state, "ListComp", state->expr_type,
1377 : : ListComp_fields, 2,
1378 : : "ListComp(expr elt, comprehension* generators)");
1379 [ - + ]: 1459 : if (!state->ListComp_type) return 0;
1380 : 1459 : state->SetComp_type = make_type(state, "SetComp", state->expr_type,
1381 : : SetComp_fields, 2,
1382 : : "SetComp(expr elt, comprehension* generators)");
1383 [ - + ]: 1459 : if (!state->SetComp_type) return 0;
1384 : 1459 : state->DictComp_type = make_type(state, "DictComp", state->expr_type,
1385 : : DictComp_fields, 3,
1386 : : "DictComp(expr key, expr value, comprehension* generators)");
1387 [ - + ]: 1459 : if (!state->DictComp_type) return 0;
1388 : 1459 : state->GeneratorExp_type = make_type(state, "GeneratorExp",
1389 : : state->expr_type, GeneratorExp_fields,
1390 : : 2,
1391 : : "GeneratorExp(expr elt, comprehension* generators)");
1392 [ - + ]: 1459 : if (!state->GeneratorExp_type) return 0;
1393 : 1459 : state->Await_type = make_type(state, "Await", state->expr_type,
1394 : : Await_fields, 1,
1395 : : "Await(expr value)");
1396 [ - + ]: 1459 : if (!state->Await_type) return 0;
1397 : 1459 : state->Yield_type = make_type(state, "Yield", state->expr_type,
1398 : : Yield_fields, 1,
1399 : : "Yield(expr? value)");
1400 [ - + ]: 1459 : if (!state->Yield_type) return 0;
1401 [ - + ]: 1459 : if (PyObject_SetAttr(state->Yield_type, state->value, Py_None) == -1)
1402 : 0 : return 0;
1403 : 1459 : state->YieldFrom_type = make_type(state, "YieldFrom", state->expr_type,
1404 : : YieldFrom_fields, 1,
1405 : : "YieldFrom(expr value)");
1406 [ - + ]: 1459 : if (!state->YieldFrom_type) return 0;
1407 : 1459 : state->Compare_type = make_type(state, "Compare", state->expr_type,
1408 : : Compare_fields, 3,
1409 : : "Compare(expr left, cmpop* ops, expr* comparators)");
1410 [ - + ]: 1459 : if (!state->Compare_type) return 0;
1411 : 1459 : state->Call_type = make_type(state, "Call", state->expr_type, Call_fields,
1412 : : 3,
1413 : : "Call(expr func, expr* args, keyword* keywords)");
1414 [ - + ]: 1459 : if (!state->Call_type) return 0;
1415 : 1459 : state->FormattedValue_type = make_type(state, "FormattedValue",
1416 : : state->expr_type,
1417 : : FormattedValue_fields, 3,
1418 : : "FormattedValue(expr value, int conversion, expr? format_spec)");
1419 [ - + ]: 1459 : if (!state->FormattedValue_type) return 0;
1420 [ - + ]: 1459 : if (PyObject_SetAttr(state->FormattedValue_type, state->format_spec,
1421 : : Py_None) == -1)
1422 : 0 : return 0;
1423 : 1459 : state->JoinedStr_type = make_type(state, "JoinedStr", state->expr_type,
1424 : : JoinedStr_fields, 1,
1425 : : "JoinedStr(expr* values)");
1426 [ - + ]: 1459 : if (!state->JoinedStr_type) return 0;
1427 : 1459 : state->Constant_type = make_type(state, "Constant", state->expr_type,
1428 : : Constant_fields, 2,
1429 : : "Constant(constant value, string? kind)");
1430 [ - + ]: 1459 : if (!state->Constant_type) return 0;
1431 [ - + ]: 1459 : if (PyObject_SetAttr(state->Constant_type, state->kind, Py_None) == -1)
1432 : 0 : return 0;
1433 : 1459 : state->Attribute_type = make_type(state, "Attribute", state->expr_type,
1434 : : Attribute_fields, 3,
1435 : : "Attribute(expr value, identifier attr, expr_context ctx)");
1436 [ - + ]: 1459 : if (!state->Attribute_type) return 0;
1437 : 1459 : state->Subscript_type = make_type(state, "Subscript", state->expr_type,
1438 : : Subscript_fields, 3,
1439 : : "Subscript(expr value, expr slice, expr_context ctx)");
1440 [ - + ]: 1459 : if (!state->Subscript_type) return 0;
1441 : 1459 : state->Starred_type = make_type(state, "Starred", state->expr_type,
1442 : : Starred_fields, 2,
1443 : : "Starred(expr value, expr_context ctx)");
1444 [ - + ]: 1459 : if (!state->Starred_type) return 0;
1445 : 1459 : state->Name_type = make_type(state, "Name", state->expr_type, Name_fields,
1446 : : 2,
1447 : : "Name(identifier id, expr_context ctx)");
1448 [ - + ]: 1459 : if (!state->Name_type) return 0;
1449 : 1459 : state->List_type = make_type(state, "List", state->expr_type, List_fields,
1450 : : 2,
1451 : : "List(expr* elts, expr_context ctx)");
1452 [ - + ]: 1459 : if (!state->List_type) return 0;
1453 : 1459 : state->Tuple_type = make_type(state, "Tuple", state->expr_type,
1454 : : Tuple_fields, 2,
1455 : : "Tuple(expr* elts, expr_context ctx)");
1456 [ - + ]: 1459 : if (!state->Tuple_type) return 0;
1457 : 1459 : state->Slice_type = make_type(state, "Slice", state->expr_type,
1458 : : Slice_fields, 3,
1459 : : "Slice(expr? lower, expr? upper, expr? step)");
1460 [ - + ]: 1459 : if (!state->Slice_type) return 0;
1461 [ - + ]: 1459 : if (PyObject_SetAttr(state->Slice_type, state->lower, Py_None) == -1)
1462 : 0 : return 0;
1463 [ - + ]: 1459 : if (PyObject_SetAttr(state->Slice_type, state->upper, Py_None) == -1)
1464 : 0 : return 0;
1465 [ - + ]: 1459 : if (PyObject_SetAttr(state->Slice_type, state->step, Py_None) == -1)
1466 : 0 : return 0;
1467 : 1459 : state->expr_context_type = make_type(state, "expr_context",
1468 : : state->AST_type, NULL, 0,
1469 : : "expr_context = Load | Store | Del");
1470 [ - + ]: 1459 : if (!state->expr_context_type) return 0;
1471 [ - + ]: 1459 : if (!add_attributes(state, state->expr_context_type, NULL, 0)) return 0;
1472 : 1459 : state->Load_type = make_type(state, "Load", state->expr_context_type, NULL,
1473 : : 0,
1474 : : "Load");
1475 [ - + ]: 1459 : if (!state->Load_type) return 0;
1476 : 1459 : state->Load_singleton = PyType_GenericNew((PyTypeObject *)state->Load_type,
1477 : : NULL, NULL);
1478 [ - + ]: 1459 : if (!state->Load_singleton) return 0;
1479 : 1459 : state->Store_type = make_type(state, "Store", state->expr_context_type,
1480 : : NULL, 0,
1481 : : "Store");
1482 [ - + ]: 1459 : if (!state->Store_type) return 0;
1483 : 2918 : state->Store_singleton = PyType_GenericNew((PyTypeObject
1484 : 1459 : *)state->Store_type, NULL, NULL);
1485 [ - + ]: 1459 : if (!state->Store_singleton) return 0;
1486 : 1459 : state->Del_type = make_type(state, "Del", state->expr_context_type, NULL, 0,
1487 : : "Del");
1488 [ - + ]: 1459 : if (!state->Del_type) return 0;
1489 : 1459 : state->Del_singleton = PyType_GenericNew((PyTypeObject *)state->Del_type,
1490 : : NULL, NULL);
1491 [ - + ]: 1459 : if (!state->Del_singleton) return 0;
1492 : 1459 : state->boolop_type = make_type(state, "boolop", state->AST_type, NULL, 0,
1493 : : "boolop = And | Or");
1494 [ - + ]: 1459 : if (!state->boolop_type) return 0;
1495 [ - + ]: 1459 : if (!add_attributes(state, state->boolop_type, NULL, 0)) return 0;
1496 : 1459 : state->And_type = make_type(state, "And", state->boolop_type, NULL, 0,
1497 : : "And");
1498 [ - + ]: 1459 : if (!state->And_type) return 0;
1499 : 1459 : state->And_singleton = PyType_GenericNew((PyTypeObject *)state->And_type,
1500 : : NULL, NULL);
1501 [ - + ]: 1459 : if (!state->And_singleton) return 0;
1502 : 1459 : state->Or_type = make_type(state, "Or", state->boolop_type, NULL, 0,
1503 : : "Or");
1504 [ - + ]: 1459 : if (!state->Or_type) return 0;
1505 : 1459 : state->Or_singleton = PyType_GenericNew((PyTypeObject *)state->Or_type,
1506 : : NULL, NULL);
1507 [ - + ]: 1459 : if (!state->Or_singleton) return 0;
1508 : 1459 : state->operator_type = make_type(state, "operator", state->AST_type, NULL,
1509 : : 0,
1510 : : "operator = Add | Sub | Mult | MatMult | Div | Mod | Pow | LShift | RShift | BitOr | BitXor | BitAnd | FloorDiv");
1511 [ - + ]: 1459 : if (!state->operator_type) return 0;
1512 [ - + ]: 1459 : if (!add_attributes(state, state->operator_type, NULL, 0)) return 0;
1513 : 1459 : state->Add_type = make_type(state, "Add", state->operator_type, NULL, 0,
1514 : : "Add");
1515 [ - + ]: 1459 : if (!state->Add_type) return 0;
1516 : 1459 : state->Add_singleton = PyType_GenericNew((PyTypeObject *)state->Add_type,
1517 : : NULL, NULL);
1518 [ - + ]: 1459 : if (!state->Add_singleton) return 0;
1519 : 1459 : state->Sub_type = make_type(state, "Sub", state->operator_type, NULL, 0,
1520 : : "Sub");
1521 [ - + ]: 1459 : if (!state->Sub_type) return 0;
1522 : 1459 : state->Sub_singleton = PyType_GenericNew((PyTypeObject *)state->Sub_type,
1523 : : NULL, NULL);
1524 [ - + ]: 1459 : if (!state->Sub_singleton) return 0;
1525 : 1459 : state->Mult_type = make_type(state, "Mult", state->operator_type, NULL, 0,
1526 : : "Mult");
1527 [ - + ]: 1459 : if (!state->Mult_type) return 0;
1528 : 1459 : state->Mult_singleton = PyType_GenericNew((PyTypeObject *)state->Mult_type,
1529 : : NULL, NULL);
1530 [ - + ]: 1459 : if (!state->Mult_singleton) return 0;
1531 : 1459 : state->MatMult_type = make_type(state, "MatMult", state->operator_type,
1532 : : NULL, 0,
1533 : : "MatMult");
1534 [ - + ]: 1459 : if (!state->MatMult_type) return 0;
1535 : 2918 : state->MatMult_singleton = PyType_GenericNew((PyTypeObject
1536 : 1459 : *)state->MatMult_type, NULL,
1537 : : NULL);
1538 [ - + ]: 1459 : if (!state->MatMult_singleton) return 0;
1539 : 1459 : state->Div_type = make_type(state, "Div", state->operator_type, NULL, 0,
1540 : : "Div");
1541 [ - + ]: 1459 : if (!state->Div_type) return 0;
1542 : 1459 : state->Div_singleton = PyType_GenericNew((PyTypeObject *)state->Div_type,
1543 : : NULL, NULL);
1544 [ - + ]: 1459 : if (!state->Div_singleton) return 0;
1545 : 1459 : state->Mod_type = make_type(state, "Mod", state->operator_type, NULL, 0,
1546 : : "Mod");
1547 [ - + ]: 1459 : if (!state->Mod_type) return 0;
1548 : 1459 : state->Mod_singleton = PyType_GenericNew((PyTypeObject *)state->Mod_type,
1549 : : NULL, NULL);
1550 [ - + ]: 1459 : if (!state->Mod_singleton) return 0;
1551 : 1459 : state->Pow_type = make_type(state, "Pow", state->operator_type, NULL, 0,
1552 : : "Pow");
1553 [ - + ]: 1459 : if (!state->Pow_type) return 0;
1554 : 1459 : state->Pow_singleton = PyType_GenericNew((PyTypeObject *)state->Pow_type,
1555 : : NULL, NULL);
1556 [ - + ]: 1459 : if (!state->Pow_singleton) return 0;
1557 : 1459 : state->LShift_type = make_type(state, "LShift", state->operator_type, NULL,
1558 : : 0,
1559 : : "LShift");
1560 [ - + ]: 1459 : if (!state->LShift_type) return 0;
1561 : 2918 : state->LShift_singleton = PyType_GenericNew((PyTypeObject
1562 : 1459 : *)state->LShift_type, NULL,
1563 : : NULL);
1564 [ - + ]: 1459 : if (!state->LShift_singleton) return 0;
1565 : 1459 : state->RShift_type = make_type(state, "RShift", state->operator_type, NULL,
1566 : : 0,
1567 : : "RShift");
1568 [ - + ]: 1459 : if (!state->RShift_type) return 0;
1569 : 2918 : state->RShift_singleton = PyType_GenericNew((PyTypeObject
1570 : 1459 : *)state->RShift_type, NULL,
1571 : : NULL);
1572 [ - + ]: 1459 : if (!state->RShift_singleton) return 0;
1573 : 1459 : state->BitOr_type = make_type(state, "BitOr", state->operator_type, NULL, 0,
1574 : : "BitOr");
1575 [ - + ]: 1459 : if (!state->BitOr_type) return 0;
1576 : 2918 : state->BitOr_singleton = PyType_GenericNew((PyTypeObject
1577 : 1459 : *)state->BitOr_type, NULL, NULL);
1578 [ - + ]: 1459 : if (!state->BitOr_singleton) return 0;
1579 : 1459 : state->BitXor_type = make_type(state, "BitXor", state->operator_type, NULL,
1580 : : 0,
1581 : : "BitXor");
1582 [ - + ]: 1459 : if (!state->BitXor_type) return 0;
1583 : 2918 : state->BitXor_singleton = PyType_GenericNew((PyTypeObject
1584 : 1459 : *)state->BitXor_type, NULL,
1585 : : NULL);
1586 [ - + ]: 1459 : if (!state->BitXor_singleton) return 0;
1587 : 1459 : state->BitAnd_type = make_type(state, "BitAnd", state->operator_type, NULL,
1588 : : 0,
1589 : : "BitAnd");
1590 [ - + ]: 1459 : if (!state->BitAnd_type) return 0;
1591 : 2918 : state->BitAnd_singleton = PyType_GenericNew((PyTypeObject
1592 : 1459 : *)state->BitAnd_type, NULL,
1593 : : NULL);
1594 [ - + ]: 1459 : if (!state->BitAnd_singleton) return 0;
1595 : 1459 : state->FloorDiv_type = make_type(state, "FloorDiv", state->operator_type,
1596 : : NULL, 0,
1597 : : "FloorDiv");
1598 [ - + ]: 1459 : if (!state->FloorDiv_type) return 0;
1599 : 2918 : state->FloorDiv_singleton = PyType_GenericNew((PyTypeObject
1600 : 1459 : *)state->FloorDiv_type, NULL,
1601 : : NULL);
1602 [ - + ]: 1459 : if (!state->FloorDiv_singleton) return 0;
1603 : 1459 : state->unaryop_type = make_type(state, "unaryop", state->AST_type, NULL, 0,
1604 : : "unaryop = Invert | Not | UAdd | USub");
1605 [ - + ]: 1459 : if (!state->unaryop_type) return 0;
1606 [ - + ]: 1459 : if (!add_attributes(state, state->unaryop_type, NULL, 0)) return 0;
1607 : 1459 : state->Invert_type = make_type(state, "Invert", state->unaryop_type, NULL,
1608 : : 0,
1609 : : "Invert");
1610 [ - + ]: 1459 : if (!state->Invert_type) return 0;
1611 : 2918 : state->Invert_singleton = PyType_GenericNew((PyTypeObject
1612 : 1459 : *)state->Invert_type, NULL,
1613 : : NULL);
1614 [ - + ]: 1459 : if (!state->Invert_singleton) return 0;
1615 : 1459 : state->Not_type = make_type(state, "Not", state->unaryop_type, NULL, 0,
1616 : : "Not");
1617 [ - + ]: 1459 : if (!state->Not_type) return 0;
1618 : 1459 : state->Not_singleton = PyType_GenericNew((PyTypeObject *)state->Not_type,
1619 : : NULL, NULL);
1620 [ - + ]: 1459 : if (!state->Not_singleton) return 0;
1621 : 1459 : state->UAdd_type = make_type(state, "UAdd", state->unaryop_type, NULL, 0,
1622 : : "UAdd");
1623 [ - + ]: 1459 : if (!state->UAdd_type) return 0;
1624 : 1459 : state->UAdd_singleton = PyType_GenericNew((PyTypeObject *)state->UAdd_type,
1625 : : NULL, NULL);
1626 [ - + ]: 1459 : if (!state->UAdd_singleton) return 0;
1627 : 1459 : state->USub_type = make_type(state, "USub", state->unaryop_type, NULL, 0,
1628 : : "USub");
1629 [ - + ]: 1459 : if (!state->USub_type) return 0;
1630 : 1459 : state->USub_singleton = PyType_GenericNew((PyTypeObject *)state->USub_type,
1631 : : NULL, NULL);
1632 [ - + ]: 1459 : if (!state->USub_singleton) return 0;
1633 : 1459 : state->cmpop_type = make_type(state, "cmpop", state->AST_type, NULL, 0,
1634 : : "cmpop = Eq | NotEq | Lt | LtE | Gt | GtE | Is | IsNot | In | NotIn");
1635 [ - + ]: 1459 : if (!state->cmpop_type) return 0;
1636 [ - + ]: 1459 : if (!add_attributes(state, state->cmpop_type, NULL, 0)) return 0;
1637 : 1459 : state->Eq_type = make_type(state, "Eq", state->cmpop_type, NULL, 0,
1638 : : "Eq");
1639 [ - + ]: 1459 : if (!state->Eq_type) return 0;
1640 : 1459 : state->Eq_singleton = PyType_GenericNew((PyTypeObject *)state->Eq_type,
1641 : : NULL, NULL);
1642 [ - + ]: 1459 : if (!state->Eq_singleton) return 0;
1643 : 1459 : state->NotEq_type = make_type(state, "NotEq", state->cmpop_type, NULL, 0,
1644 : : "NotEq");
1645 [ - + ]: 1459 : if (!state->NotEq_type) return 0;
1646 : 2918 : state->NotEq_singleton = PyType_GenericNew((PyTypeObject
1647 : 1459 : *)state->NotEq_type, NULL, NULL);
1648 [ - + ]: 1459 : if (!state->NotEq_singleton) return 0;
1649 : 1459 : state->Lt_type = make_type(state, "Lt", state->cmpop_type, NULL, 0,
1650 : : "Lt");
1651 [ - + ]: 1459 : if (!state->Lt_type) return 0;
1652 : 1459 : state->Lt_singleton = PyType_GenericNew((PyTypeObject *)state->Lt_type,
1653 : : NULL, NULL);
1654 [ - + ]: 1459 : if (!state->Lt_singleton) return 0;
1655 : 1459 : state->LtE_type = make_type(state, "LtE", state->cmpop_type, NULL, 0,
1656 : : "LtE");
1657 [ - + ]: 1459 : if (!state->LtE_type) return 0;
1658 : 1459 : state->LtE_singleton = PyType_GenericNew((PyTypeObject *)state->LtE_type,
1659 : : NULL, NULL);
1660 [ - + ]: 1459 : if (!state->LtE_singleton) return 0;
1661 : 1459 : state->Gt_type = make_type(state, "Gt", state->cmpop_type, NULL, 0,
1662 : : "Gt");
1663 [ - + ]: 1459 : if (!state->Gt_type) return 0;
1664 : 1459 : state->Gt_singleton = PyType_GenericNew((PyTypeObject *)state->Gt_type,
1665 : : NULL, NULL);
1666 [ - + ]: 1459 : if (!state->Gt_singleton) return 0;
1667 : 1459 : state->GtE_type = make_type(state, "GtE", state->cmpop_type, NULL, 0,
1668 : : "GtE");
1669 [ - + ]: 1459 : if (!state->GtE_type) return 0;
1670 : 1459 : state->GtE_singleton = PyType_GenericNew((PyTypeObject *)state->GtE_type,
1671 : : NULL, NULL);
1672 [ - + ]: 1459 : if (!state->GtE_singleton) return 0;
1673 : 1459 : state->Is_type = make_type(state, "Is", state->cmpop_type, NULL, 0,
1674 : : "Is");
1675 [ - + ]: 1459 : if (!state->Is_type) return 0;
1676 : 1459 : state->Is_singleton = PyType_GenericNew((PyTypeObject *)state->Is_type,
1677 : : NULL, NULL);
1678 [ - + ]: 1459 : if (!state->Is_singleton) return 0;
1679 : 1459 : state->IsNot_type = make_type(state, "IsNot", state->cmpop_type, NULL, 0,
1680 : : "IsNot");
1681 [ - + ]: 1459 : if (!state->IsNot_type) return 0;
1682 : 2918 : state->IsNot_singleton = PyType_GenericNew((PyTypeObject
1683 : 1459 : *)state->IsNot_type, NULL, NULL);
1684 [ - + ]: 1459 : if (!state->IsNot_singleton) return 0;
1685 : 1459 : state->In_type = make_type(state, "In", state->cmpop_type, NULL, 0,
1686 : : "In");
1687 [ - + ]: 1459 : if (!state->In_type) return 0;
1688 : 1459 : state->In_singleton = PyType_GenericNew((PyTypeObject *)state->In_type,
1689 : : NULL, NULL);
1690 [ - + ]: 1459 : if (!state->In_singleton) return 0;
1691 : 1459 : state->NotIn_type = make_type(state, "NotIn", state->cmpop_type, NULL, 0,
1692 : : "NotIn");
1693 [ - + ]: 1459 : if (!state->NotIn_type) return 0;
1694 : 2918 : state->NotIn_singleton = PyType_GenericNew((PyTypeObject
1695 : 1459 : *)state->NotIn_type, NULL, NULL);
1696 [ - + ]: 1459 : if (!state->NotIn_singleton) return 0;
1697 : 1459 : state->comprehension_type = make_type(state, "comprehension",
1698 : : state->AST_type,
1699 : : comprehension_fields, 4,
1700 : : "comprehension(expr target, expr iter, expr* ifs, int is_async)");
1701 [ - + ]: 1459 : if (!state->comprehension_type) return 0;
1702 [ - + ]: 1459 : if (!add_attributes(state, state->comprehension_type, NULL, 0)) return 0;
1703 : 1459 : state->excepthandler_type = make_type(state, "excepthandler",
1704 : : state->AST_type, NULL, 0,
1705 : : "excepthandler = ExceptHandler(expr? type, identifier? name, stmt* body)");
1706 [ - + ]: 1459 : if (!state->excepthandler_type) return 0;
1707 [ - + ]: 1459 : if (!add_attributes(state, state->excepthandler_type,
1708 : 0 : excepthandler_attributes, 4)) return 0;
1709 [ - + ]: 1459 : if (PyObject_SetAttr(state->excepthandler_type, state->end_lineno, Py_None)
1710 : : == -1)
1711 : 0 : return 0;
1712 [ - + ]: 1459 : if (PyObject_SetAttr(state->excepthandler_type, state->end_col_offset,
1713 : : Py_None) == -1)
1714 : 0 : return 0;
1715 : 1459 : state->ExceptHandler_type = make_type(state, "ExceptHandler",
1716 : : state->excepthandler_type,
1717 : : ExceptHandler_fields, 3,
1718 : : "ExceptHandler(expr? type, identifier? name, stmt* body)");
1719 [ - + ]: 1459 : if (!state->ExceptHandler_type) return 0;
1720 [ - + ]: 1459 : if (PyObject_SetAttr(state->ExceptHandler_type, state->type, Py_None) == -1)
1721 : 0 : return 0;
1722 [ - + ]: 1459 : if (PyObject_SetAttr(state->ExceptHandler_type, state->name, Py_None) == -1)
1723 : 0 : return 0;
1724 : 1459 : state->arguments_type = make_type(state, "arguments", state->AST_type,
1725 : : arguments_fields, 7,
1726 : : "arguments(arg* posonlyargs, arg* args, arg? vararg, arg* kwonlyargs, expr* kw_defaults, arg? kwarg, expr* defaults)");
1727 [ - + ]: 1459 : if (!state->arguments_type) return 0;
1728 [ - + ]: 1459 : if (!add_attributes(state, state->arguments_type, NULL, 0)) return 0;
1729 [ - + ]: 1459 : if (PyObject_SetAttr(state->arguments_type, state->vararg, Py_None) == -1)
1730 : 0 : return 0;
1731 [ - + ]: 1459 : if (PyObject_SetAttr(state->arguments_type, state->kwarg, Py_None) == -1)
1732 : 0 : return 0;
1733 : 1459 : state->arg_type = make_type(state, "arg", state->AST_type, arg_fields, 3,
1734 : : "arg(identifier arg, expr? annotation, string? type_comment)");
1735 [ - + ]: 1459 : if (!state->arg_type) return 0;
1736 [ - + ]: 1459 : if (!add_attributes(state, state->arg_type, arg_attributes, 4)) return 0;
1737 [ - + ]: 1459 : if (PyObject_SetAttr(state->arg_type, state->annotation, Py_None) == -1)
1738 : 0 : return 0;
1739 [ - + ]: 1459 : if (PyObject_SetAttr(state->arg_type, state->type_comment, Py_None) == -1)
1740 : 0 : return 0;
1741 [ - + ]: 1459 : if (PyObject_SetAttr(state->arg_type, state->end_lineno, Py_None) == -1)
1742 : 0 : return 0;
1743 [ - + ]: 1459 : if (PyObject_SetAttr(state->arg_type, state->end_col_offset, Py_None) == -1)
1744 : 0 : return 0;
1745 : 1459 : state->keyword_type = make_type(state, "keyword", state->AST_type,
1746 : : keyword_fields, 2,
1747 : : "keyword(identifier? arg, expr value)");
1748 [ - + ]: 1459 : if (!state->keyword_type) return 0;
1749 [ - + ]: 1459 : if (!add_attributes(state, state->keyword_type, keyword_attributes, 4))
1750 : 0 : return 0;
1751 [ - + ]: 1459 : if (PyObject_SetAttr(state->keyword_type, state->arg, Py_None) == -1)
1752 : 0 : return 0;
1753 [ - + ]: 1459 : if (PyObject_SetAttr(state->keyword_type, state->end_lineno, Py_None) == -1)
1754 : 0 : return 0;
1755 [ - + ]: 1459 : if (PyObject_SetAttr(state->keyword_type, state->end_col_offset, Py_None)
1756 : : == -1)
1757 : 0 : return 0;
1758 : 1459 : state->alias_type = make_type(state, "alias", state->AST_type,
1759 : : alias_fields, 2,
1760 : : "alias(identifier name, identifier? asname)");
1761 [ - + ]: 1459 : if (!state->alias_type) return 0;
1762 [ - + ]: 1459 : if (!add_attributes(state, state->alias_type, alias_attributes, 4)) return
1763 : 0 : 0;
1764 [ - + ]: 1459 : if (PyObject_SetAttr(state->alias_type, state->asname, Py_None) == -1)
1765 : 0 : return 0;
1766 [ - + ]: 1459 : if (PyObject_SetAttr(state->alias_type, state->end_lineno, Py_None) == -1)
1767 : 0 : return 0;
1768 [ - + ]: 1459 : if (PyObject_SetAttr(state->alias_type, state->end_col_offset, Py_None) ==
1769 : : -1)
1770 : 0 : return 0;
1771 : 1459 : state->withitem_type = make_type(state, "withitem", state->AST_type,
1772 : : withitem_fields, 2,
1773 : : "withitem(expr context_expr, expr? optional_vars)");
1774 [ - + ]: 1459 : if (!state->withitem_type) return 0;
1775 [ - + ]: 1459 : if (!add_attributes(state, state->withitem_type, NULL, 0)) return 0;
1776 [ - + ]: 1459 : if (PyObject_SetAttr(state->withitem_type, state->optional_vars, Py_None)
1777 : : == -1)
1778 : 0 : return 0;
1779 : 1459 : state->match_case_type = make_type(state, "match_case", state->AST_type,
1780 : : match_case_fields, 3,
1781 : : "match_case(pattern pattern, expr? guard, stmt* body)");
1782 [ - + ]: 1459 : if (!state->match_case_type) return 0;
1783 [ - + ]: 1459 : if (!add_attributes(state, state->match_case_type, NULL, 0)) return 0;
1784 [ - + ]: 1459 : if (PyObject_SetAttr(state->match_case_type, state->guard, Py_None) == -1)
1785 : 0 : return 0;
1786 : 1459 : state->pattern_type = make_type(state, "pattern", state->AST_type, NULL, 0,
1787 : : "pattern = MatchValue(expr value)\n"
1788 : : " | MatchSingleton(constant value)\n"
1789 : : " | MatchSequence(pattern* patterns)\n"
1790 : : " | MatchMapping(expr* keys, pattern* patterns, identifier? rest)\n"
1791 : : " | MatchClass(expr cls, pattern* patterns, identifier* kwd_attrs, pattern* kwd_patterns)\n"
1792 : : " | MatchStar(identifier? name)\n"
1793 : : " | MatchAs(pattern? pattern, identifier? name)\n"
1794 : : " | MatchOr(pattern* patterns)");
1795 [ - + ]: 1459 : if (!state->pattern_type) return 0;
1796 [ - + ]: 1459 : if (!add_attributes(state, state->pattern_type, pattern_attributes, 4))
1797 : 0 : return 0;
1798 : 1459 : state->MatchValue_type = make_type(state, "MatchValue",
1799 : : state->pattern_type, MatchValue_fields,
1800 : : 1,
1801 : : "MatchValue(expr value)");
1802 [ - + ]: 1459 : if (!state->MatchValue_type) return 0;
1803 : 1459 : state->MatchSingleton_type = make_type(state, "MatchSingleton",
1804 : : state->pattern_type,
1805 : : MatchSingleton_fields, 1,
1806 : : "MatchSingleton(constant value)");
1807 [ - + ]: 1459 : if (!state->MatchSingleton_type) return 0;
1808 : 1459 : state->MatchSequence_type = make_type(state, "MatchSequence",
1809 : : state->pattern_type,
1810 : : MatchSequence_fields, 1,
1811 : : "MatchSequence(pattern* patterns)");
1812 [ - + ]: 1459 : if (!state->MatchSequence_type) return 0;
1813 : 1459 : state->MatchMapping_type = make_type(state, "MatchMapping",
1814 : : state->pattern_type,
1815 : : MatchMapping_fields, 3,
1816 : : "MatchMapping(expr* keys, pattern* patterns, identifier? rest)");
1817 [ - + ]: 1459 : if (!state->MatchMapping_type) return 0;
1818 [ - + ]: 1459 : if (PyObject_SetAttr(state->MatchMapping_type, state->rest, Py_None) == -1)
1819 : 0 : return 0;
1820 : 1459 : state->MatchClass_type = make_type(state, "MatchClass",
1821 : : state->pattern_type, MatchClass_fields,
1822 : : 4,
1823 : : "MatchClass(expr cls, pattern* patterns, identifier* kwd_attrs, pattern* kwd_patterns)");
1824 [ - + ]: 1459 : if (!state->MatchClass_type) return 0;
1825 : 1459 : state->MatchStar_type = make_type(state, "MatchStar", state->pattern_type,
1826 : : MatchStar_fields, 1,
1827 : : "MatchStar(identifier? name)");
1828 [ - + ]: 1459 : if (!state->MatchStar_type) return 0;
1829 [ - + ]: 1459 : if (PyObject_SetAttr(state->MatchStar_type, state->name, Py_None) == -1)
1830 : 0 : return 0;
1831 : 1459 : state->MatchAs_type = make_type(state, "MatchAs", state->pattern_type,
1832 : : MatchAs_fields, 2,
1833 : : "MatchAs(pattern? pattern, identifier? name)");
1834 [ - + ]: 1459 : if (!state->MatchAs_type) return 0;
1835 [ - + ]: 1459 : if (PyObject_SetAttr(state->MatchAs_type, state->pattern, Py_None) == -1)
1836 : 0 : return 0;
1837 [ - + ]: 1459 : if (PyObject_SetAttr(state->MatchAs_type, state->name, Py_None) == -1)
1838 : 0 : return 0;
1839 : 1459 : state->MatchOr_type = make_type(state, "MatchOr", state->pattern_type,
1840 : : MatchOr_fields, 1,
1841 : : "MatchOr(pattern* patterns)");
1842 [ - + ]: 1459 : if (!state->MatchOr_type) return 0;
1843 : 1459 : state->type_ignore_type = make_type(state, "type_ignore", state->AST_type,
1844 : : NULL, 0,
1845 : : "type_ignore = TypeIgnore(int lineno, string tag)");
1846 [ - + ]: 1459 : if (!state->type_ignore_type) return 0;
1847 [ - + ]: 1459 : if (!add_attributes(state, state->type_ignore_type, NULL, 0)) return 0;
1848 : 1459 : state->TypeIgnore_type = make_type(state, "TypeIgnore",
1849 : : state->type_ignore_type,
1850 : : TypeIgnore_fields, 2,
1851 : : "TypeIgnore(int lineno, string tag)");
1852 [ - + ]: 1459 : if (!state->TypeIgnore_type) return 0;
1853 : :
1854 : 1459 : state->initialized = 1;
1855 : 1459 : return 1;
1856 : : }
1857 : :
1858 : : static int obj2ast_mod(struct ast_state *state, PyObject* obj, mod_ty* out,
1859 : : PyArena* arena);
1860 : : static int obj2ast_stmt(struct ast_state *state, PyObject* obj, stmt_ty* out,
1861 : : PyArena* arena);
1862 : : static int obj2ast_expr(struct ast_state *state, PyObject* obj, expr_ty* out,
1863 : : PyArena* arena);
1864 : : static int obj2ast_expr_context(struct ast_state *state, PyObject* obj,
1865 : : expr_context_ty* out, PyArena* arena);
1866 : : static int obj2ast_boolop(struct ast_state *state, PyObject* obj, boolop_ty*
1867 : : out, PyArena* arena);
1868 : : static int obj2ast_operator(struct ast_state *state, PyObject* obj,
1869 : : operator_ty* out, PyArena* arena);
1870 : : static int obj2ast_unaryop(struct ast_state *state, PyObject* obj, unaryop_ty*
1871 : : out, PyArena* arena);
1872 : : static int obj2ast_cmpop(struct ast_state *state, PyObject* obj, cmpop_ty* out,
1873 : : PyArena* arena);
1874 : : static int obj2ast_comprehension(struct ast_state *state, PyObject* obj,
1875 : : comprehension_ty* out, PyArena* arena);
1876 : : static int obj2ast_excepthandler(struct ast_state *state, PyObject* obj,
1877 : : excepthandler_ty* out, PyArena* arena);
1878 : : static int obj2ast_arguments(struct ast_state *state, PyObject* obj,
1879 : : arguments_ty* out, PyArena* arena);
1880 : : static int obj2ast_arg(struct ast_state *state, PyObject* obj, arg_ty* out,
1881 : : PyArena* arena);
1882 : : static int obj2ast_keyword(struct ast_state *state, PyObject* obj, keyword_ty*
1883 : : out, PyArena* arena);
1884 : : static int obj2ast_alias(struct ast_state *state, PyObject* obj, alias_ty* out,
1885 : : PyArena* arena);
1886 : : static int obj2ast_withitem(struct ast_state *state, PyObject* obj,
1887 : : withitem_ty* out, PyArena* arena);
1888 : : static int obj2ast_match_case(struct ast_state *state, PyObject* obj,
1889 : : match_case_ty* out, PyArena* arena);
1890 : : static int obj2ast_pattern(struct ast_state *state, PyObject* obj, pattern_ty*
1891 : : out, PyArena* arena);
1892 : : static int obj2ast_type_ignore(struct ast_state *state, PyObject* obj,
1893 : : type_ignore_ty* out, PyArena* arena);
1894 : :
1895 : : mod_ty
1896 : 48445 : _PyAST_Module(asdl_stmt_seq * body, asdl_type_ignore_seq * type_ignores,
1897 : : PyArena *arena)
1898 : : {
1899 : : mod_ty p;
1900 : 48445 : p = (mod_ty)_PyArena_Malloc(arena, sizeof(*p));
1901 [ - + ]: 48445 : if (!p)
1902 : 0 : return NULL;
1903 : 48445 : p->kind = Module_kind;
1904 : 48445 : p->v.Module.body = body;
1905 : 48445 : p->v.Module.type_ignores = type_ignores;
1906 : 48445 : return p;
1907 : : }
1908 : :
1909 : : mod_ty
1910 : 4162 : _PyAST_Interactive(asdl_stmt_seq * body, PyArena *arena)
1911 : : {
1912 : : mod_ty p;
1913 : 4162 : p = (mod_ty)_PyArena_Malloc(arena, sizeof(*p));
1914 [ - + ]: 4162 : if (!p)
1915 : 0 : return NULL;
1916 : 4162 : p->kind = Interactive_kind;
1917 : 4162 : p->v.Interactive.body = body;
1918 : 4162 : return p;
1919 : : }
1920 : :
1921 : : mod_ty
1922 : 72013 : _PyAST_Expression(expr_ty body, PyArena *arena)
1923 : : {
1924 : : mod_ty p;
1925 [ - + ]: 72013 : if (!body) {
1926 : 0 : PyErr_SetString(PyExc_ValueError,
1927 : : "field 'body' is required for Expression");
1928 : 0 : return NULL;
1929 : : }
1930 : 72013 : p = (mod_ty)_PyArena_Malloc(arena, sizeof(*p));
1931 [ - + ]: 72013 : if (!p)
1932 : 0 : return NULL;
1933 : 72013 : p->kind = Expression_kind;
1934 : 72013 : p->v.Expression.body = body;
1935 : 72013 : return p;
1936 : : }
1937 : :
1938 : : mod_ty
1939 : 12 : _PyAST_FunctionType(asdl_expr_seq * argtypes, expr_ty returns, PyArena *arena)
1940 : : {
1941 : : mod_ty p;
1942 [ - + ]: 12 : if (!returns) {
1943 : 0 : PyErr_SetString(PyExc_ValueError,
1944 : : "field 'returns' is required for FunctionType");
1945 : 0 : return NULL;
1946 : : }
1947 : 12 : p = (mod_ty)_PyArena_Malloc(arena, sizeof(*p));
1948 [ - + ]: 12 : if (!p)
1949 : 0 : return NULL;
1950 : 12 : p->kind = FunctionType_kind;
1951 : 12 : p->v.FunctionType.argtypes = argtypes;
1952 : 12 : p->v.FunctionType.returns = returns;
1953 : 12 : return p;
1954 : : }
1955 : :
1956 : : stmt_ty
1957 : 374754 : _PyAST_FunctionDef(identifier name, arguments_ty args, asdl_stmt_seq * body,
1958 : : asdl_expr_seq * decorator_list, expr_ty returns, string
1959 : : type_comment, int lineno, int col_offset, int end_lineno,
1960 : : int end_col_offset, PyArena *arena)
1961 : : {
1962 : : stmt_ty p;
1963 [ - + ]: 374754 : if (!name) {
1964 : 0 : PyErr_SetString(PyExc_ValueError,
1965 : : "field 'name' is required for FunctionDef");
1966 : 0 : return NULL;
1967 : : }
1968 [ - + ]: 374754 : if (!args) {
1969 : 0 : PyErr_SetString(PyExc_ValueError,
1970 : : "field 'args' is required for FunctionDef");
1971 : 0 : return NULL;
1972 : : }
1973 : 374754 : p = (stmt_ty)_PyArena_Malloc(arena, sizeof(*p));
1974 [ - + ]: 374754 : if (!p)
1975 : 0 : return NULL;
1976 : 374754 : p->kind = FunctionDef_kind;
1977 : 374754 : p->v.FunctionDef.name = name;
1978 : 374754 : p->v.FunctionDef.args = args;
1979 : 374754 : p->v.FunctionDef.body = body;
1980 : 374754 : p->v.FunctionDef.decorator_list = decorator_list;
1981 : 374754 : p->v.FunctionDef.returns = returns;
1982 : 374754 : p->v.FunctionDef.type_comment = type_comment;
1983 : 374754 : p->lineno = lineno;
1984 : 374754 : p->col_offset = col_offset;
1985 : 374754 : p->end_lineno = end_lineno;
1986 : 374754 : p->end_col_offset = end_col_offset;
1987 : 374754 : return p;
1988 : : }
1989 : :
1990 : : stmt_ty
1991 : 3820 : _PyAST_AsyncFunctionDef(identifier name, arguments_ty args, asdl_stmt_seq *
1992 : : body, asdl_expr_seq * decorator_list, expr_ty returns,
1993 : : string type_comment, int lineno, int col_offset, int
1994 : : end_lineno, int end_col_offset, PyArena *arena)
1995 : : {
1996 : : stmt_ty p;
1997 [ - + ]: 3820 : if (!name) {
1998 : 0 : PyErr_SetString(PyExc_ValueError,
1999 : : "field 'name' is required for AsyncFunctionDef");
2000 : 0 : return NULL;
2001 : : }
2002 [ - + ]: 3820 : if (!args) {
2003 : 0 : PyErr_SetString(PyExc_ValueError,
2004 : : "field 'args' is required for AsyncFunctionDef");
2005 : 0 : return NULL;
2006 : : }
2007 : 3820 : p = (stmt_ty)_PyArena_Malloc(arena, sizeof(*p));
2008 [ - + ]: 3820 : if (!p)
2009 : 0 : return NULL;
2010 : 3820 : p->kind = AsyncFunctionDef_kind;
2011 : 3820 : p->v.AsyncFunctionDef.name = name;
2012 : 3820 : p->v.AsyncFunctionDef.args = args;
2013 : 3820 : p->v.AsyncFunctionDef.body = body;
2014 : 3820 : p->v.AsyncFunctionDef.decorator_list = decorator_list;
2015 : 3820 : p->v.AsyncFunctionDef.returns = returns;
2016 : 3820 : p->v.AsyncFunctionDef.type_comment = type_comment;
2017 : 3820 : p->lineno = lineno;
2018 : 3820 : p->col_offset = col_offset;
2019 : 3820 : p->end_lineno = end_lineno;
2020 : 3820 : p->end_col_offset = end_col_offset;
2021 : 3820 : return p;
2022 : : }
2023 : :
2024 : : stmt_ty
2025 : 60459 : _PyAST_ClassDef(identifier name, asdl_expr_seq * bases, asdl_keyword_seq *
2026 : : keywords, asdl_stmt_seq * body, asdl_expr_seq * decorator_list,
2027 : : int lineno, int col_offset, int end_lineno, int end_col_offset,
2028 : : PyArena *arena)
2029 : : {
2030 : : stmt_ty p;
2031 [ - + ]: 60459 : if (!name) {
2032 : 0 : PyErr_SetString(PyExc_ValueError,
2033 : : "field 'name' is required for ClassDef");
2034 : 0 : return NULL;
2035 : : }
2036 : 60459 : p = (stmt_ty)_PyArena_Malloc(arena, sizeof(*p));
2037 [ - + ]: 60459 : if (!p)
2038 : 0 : return NULL;
2039 : 60459 : p->kind = ClassDef_kind;
2040 : 60459 : p->v.ClassDef.name = name;
2041 : 60459 : p->v.ClassDef.bases = bases;
2042 : 60459 : p->v.ClassDef.keywords = keywords;
2043 : 60459 : p->v.ClassDef.body = body;
2044 : 60459 : p->v.ClassDef.decorator_list = decorator_list;
2045 : 60459 : p->lineno = lineno;
2046 : 60459 : p->col_offset = col_offset;
2047 : 60459 : p->end_lineno = end_lineno;
2048 : 60459 : p->end_col_offset = end_col_offset;
2049 : 60459 : return p;
2050 : : }
2051 : :
2052 : : stmt_ty
2053 : 246137 : _PyAST_Return(expr_ty value, int lineno, int col_offset, int end_lineno, int
2054 : : end_col_offset, PyArena *arena)
2055 : : {
2056 : : stmt_ty p;
2057 : 246137 : p = (stmt_ty)_PyArena_Malloc(arena, sizeof(*p));
2058 [ - + ]: 246137 : if (!p)
2059 : 0 : return NULL;
2060 : 246137 : p->kind = Return_kind;
2061 : 246137 : p->v.Return.value = value;
2062 : 246137 : p->lineno = lineno;
2063 : 246137 : p->col_offset = col_offset;
2064 : 246137 : p->end_lineno = end_lineno;
2065 : 246137 : p->end_col_offset = end_col_offset;
2066 : 246137 : return p;
2067 : : }
2068 : :
2069 : : stmt_ty
2070 : 8987 : _PyAST_Delete(asdl_expr_seq * targets, int lineno, int col_offset, int
2071 : : end_lineno, int end_col_offset, PyArena *arena)
2072 : : {
2073 : : stmt_ty p;
2074 : 8987 : p = (stmt_ty)_PyArena_Malloc(arena, sizeof(*p));
2075 [ - + ]: 8987 : if (!p)
2076 : 0 : return NULL;
2077 : 8987 : p->kind = Delete_kind;
2078 : 8987 : p->v.Delete.targets = targets;
2079 : 8987 : p->lineno = lineno;
2080 : 8987 : p->col_offset = col_offset;
2081 : 8987 : p->end_lineno = end_lineno;
2082 : 8987 : p->end_col_offset = end_col_offset;
2083 : 8987 : return p;
2084 : : }
2085 : :
2086 : : stmt_ty
2087 : 824016 : _PyAST_Assign(asdl_expr_seq * targets, expr_ty value, string type_comment, int
2088 : : lineno, int col_offset, int end_lineno, int end_col_offset,
2089 : : PyArena *arena)
2090 : : {
2091 : : stmt_ty p;
2092 [ - + ]: 824016 : if (!value) {
2093 : 0 : PyErr_SetString(PyExc_ValueError,
2094 : : "field 'value' is required for Assign");
2095 : 0 : return NULL;
2096 : : }
2097 : 824016 : p = (stmt_ty)_PyArena_Malloc(arena, sizeof(*p));
2098 [ - + ]: 824016 : if (!p)
2099 : 0 : return NULL;
2100 : 824016 : p->kind = Assign_kind;
2101 : 824016 : p->v.Assign.targets = targets;
2102 : 824016 : p->v.Assign.value = value;
2103 : 824016 : p->v.Assign.type_comment = type_comment;
2104 : 824016 : p->lineno = lineno;
2105 : 824016 : p->col_offset = col_offset;
2106 : 824016 : p->end_lineno = end_lineno;
2107 : 824016 : p->end_col_offset = end_col_offset;
2108 : 824016 : return p;
2109 : : }
2110 : :
2111 : : stmt_ty
2112 : 26448 : _PyAST_AugAssign(expr_ty target, operator_ty op, expr_ty value, int lineno, int
2113 : : col_offset, int end_lineno, int end_col_offset, PyArena *arena)
2114 : : {
2115 : : stmt_ty p;
2116 [ - + ]: 26448 : if (!target) {
2117 : 0 : PyErr_SetString(PyExc_ValueError,
2118 : : "field 'target' is required for AugAssign");
2119 : 0 : return NULL;
2120 : : }
2121 [ - + ]: 26448 : if (!op) {
2122 : 0 : PyErr_SetString(PyExc_ValueError,
2123 : : "field 'op' is required for AugAssign");
2124 : 0 : return NULL;
2125 : : }
2126 [ - + ]: 26448 : if (!value) {
2127 : 0 : PyErr_SetString(PyExc_ValueError,
2128 : : "field 'value' is required for AugAssign");
2129 : 0 : return NULL;
2130 : : }
2131 : 26448 : p = (stmt_ty)_PyArena_Malloc(arena, sizeof(*p));
2132 [ - + ]: 26448 : if (!p)
2133 : 0 : return NULL;
2134 : 26448 : p->kind = AugAssign_kind;
2135 : 26448 : p->v.AugAssign.target = target;
2136 : 26448 : p->v.AugAssign.op = op;
2137 : 26448 : p->v.AugAssign.value = value;
2138 : 26448 : p->lineno = lineno;
2139 : 26448 : p->col_offset = col_offset;
2140 : 26448 : p->end_lineno = end_lineno;
2141 : 26448 : p->end_col_offset = end_col_offset;
2142 : 26448 : return p;
2143 : : }
2144 : :
2145 : : stmt_ty
2146 : 11492 : _PyAST_AnnAssign(expr_ty target, expr_ty annotation, expr_ty value, int simple,
2147 : : int lineno, int col_offset, int end_lineno, int
2148 : : end_col_offset, PyArena *arena)
2149 : : {
2150 : : stmt_ty p;
2151 [ - + ]: 11492 : if (!target) {
2152 : 0 : PyErr_SetString(PyExc_ValueError,
2153 : : "field 'target' is required for AnnAssign");
2154 : 0 : return NULL;
2155 : : }
2156 [ - + ]: 11492 : if (!annotation) {
2157 : 0 : PyErr_SetString(PyExc_ValueError,
2158 : : "field 'annotation' is required for AnnAssign");
2159 : 0 : return NULL;
2160 : : }
2161 : 11492 : p = (stmt_ty)_PyArena_Malloc(arena, sizeof(*p));
2162 [ - + ]: 11492 : if (!p)
2163 : 0 : return NULL;
2164 : 11492 : p->kind = AnnAssign_kind;
2165 : 11492 : p->v.AnnAssign.target = target;
2166 : 11492 : p->v.AnnAssign.annotation = annotation;
2167 : 11492 : p->v.AnnAssign.value = value;
2168 : 11492 : p->v.AnnAssign.simple = simple;
2169 : 11492 : p->lineno = lineno;
2170 : 11492 : p->col_offset = col_offset;
2171 : 11492 : p->end_lineno = end_lineno;
2172 : 11492 : p->end_col_offset = end_col_offset;
2173 : 11492 : return p;
2174 : : }
2175 : :
2176 : : stmt_ty
2177 : 62440 : _PyAST_For(expr_ty target, expr_ty iter, asdl_stmt_seq * body, asdl_stmt_seq *
2178 : : orelse, string type_comment, int lineno, int col_offset, int
2179 : : end_lineno, int end_col_offset, PyArena *arena)
2180 : : {
2181 : : stmt_ty p;
2182 [ - + ]: 62440 : if (!target) {
2183 : 0 : PyErr_SetString(PyExc_ValueError,
2184 : : "field 'target' is required for For");
2185 : 0 : return NULL;
2186 : : }
2187 [ - + ]: 62440 : if (!iter) {
2188 : 0 : PyErr_SetString(PyExc_ValueError,
2189 : : "field 'iter' is required for For");
2190 : 0 : return NULL;
2191 : : }
2192 : 62440 : p = (stmt_ty)_PyArena_Malloc(arena, sizeof(*p));
2193 [ - + ]: 62440 : if (!p)
2194 : 0 : return NULL;
2195 : 62440 : p->kind = For_kind;
2196 : 62440 : p->v.For.target = target;
2197 : 62440 : p->v.For.iter = iter;
2198 : 62440 : p->v.For.body = body;
2199 : 62440 : p->v.For.orelse = orelse;
2200 : 62440 : p->v.For.type_comment = type_comment;
2201 : 62440 : p->lineno = lineno;
2202 : 62440 : p->col_offset = col_offset;
2203 : 62440 : p->end_lineno = end_lineno;
2204 : 62440 : p->end_col_offset = end_col_offset;
2205 : 62440 : return p;
2206 : : }
2207 : :
2208 : : stmt_ty
2209 : 197 : _PyAST_AsyncFor(expr_ty target, expr_ty iter, asdl_stmt_seq * body,
2210 : : asdl_stmt_seq * orelse, string type_comment, int lineno, int
2211 : : col_offset, int end_lineno, int end_col_offset, PyArena *arena)
2212 : : {
2213 : : stmt_ty p;
2214 [ - + ]: 197 : if (!target) {
2215 : 0 : PyErr_SetString(PyExc_ValueError,
2216 : : "field 'target' is required for AsyncFor");
2217 : 0 : return NULL;
2218 : : }
2219 [ - + ]: 197 : if (!iter) {
2220 : 0 : PyErr_SetString(PyExc_ValueError,
2221 : : "field 'iter' is required for AsyncFor");
2222 : 0 : return NULL;
2223 : : }
2224 : 197 : p = (stmt_ty)_PyArena_Malloc(arena, sizeof(*p));
2225 [ - + ]: 197 : if (!p)
2226 : 0 : return NULL;
2227 : 197 : p->kind = AsyncFor_kind;
2228 : 197 : p->v.AsyncFor.target = target;
2229 : 197 : p->v.AsyncFor.iter = iter;
2230 : 197 : p->v.AsyncFor.body = body;
2231 : 197 : p->v.AsyncFor.orelse = orelse;
2232 : 197 : p->v.AsyncFor.type_comment = type_comment;
2233 : 197 : p->lineno = lineno;
2234 : 197 : p->col_offset = col_offset;
2235 : 197 : p->end_lineno = end_lineno;
2236 : 197 : p->end_col_offset = end_col_offset;
2237 : 197 : return p;
2238 : : }
2239 : :
2240 : : stmt_ty
2241 : 12083 : _PyAST_While(expr_ty test, asdl_stmt_seq * body, asdl_stmt_seq * orelse, int
2242 : : lineno, int col_offset, int end_lineno, int end_col_offset,
2243 : : PyArena *arena)
2244 : : {
2245 : : stmt_ty p;
2246 [ - + ]: 12083 : if (!test) {
2247 : 0 : PyErr_SetString(PyExc_ValueError,
2248 : : "field 'test' is required for While");
2249 : 0 : return NULL;
2250 : : }
2251 : 12083 : p = (stmt_ty)_PyArena_Malloc(arena, sizeof(*p));
2252 [ - + ]: 12083 : if (!p)
2253 : 0 : return NULL;
2254 : 12083 : p->kind = While_kind;
2255 : 12083 : p->v.While.test = test;
2256 : 12083 : p->v.While.body = body;
2257 : 12083 : p->v.While.orelse = orelse;
2258 : 12083 : p->lineno = lineno;
2259 : 12083 : p->col_offset = col_offset;
2260 : 12083 : p->end_lineno = end_lineno;
2261 : 12083 : p->end_col_offset = end_col_offset;
2262 : 12083 : return p;
2263 : : }
2264 : :
2265 : : stmt_ty
2266 : 532296 : _PyAST_If(expr_ty test, asdl_stmt_seq * body, asdl_stmt_seq * orelse, int
2267 : : lineno, int col_offset, int end_lineno, int end_col_offset, PyArena
2268 : : *arena)
2269 : : {
2270 : : stmt_ty p;
2271 [ - + ]: 532296 : if (!test) {
2272 : 0 : PyErr_SetString(PyExc_ValueError,
2273 : : "field 'test' is required for If");
2274 : 0 : return NULL;
2275 : : }
2276 : 532296 : p = (stmt_ty)_PyArena_Malloc(arena, sizeof(*p));
2277 [ - + ]: 532296 : if (!p)
2278 : 0 : return NULL;
2279 : 532296 : p->kind = If_kind;
2280 : 532296 : p->v.If.test = test;
2281 : 532296 : p->v.If.body = body;
2282 : 532296 : p->v.If.orelse = orelse;
2283 : 532296 : p->lineno = lineno;
2284 : 532296 : p->col_offset = col_offset;
2285 : 532296 : p->end_lineno = end_lineno;
2286 : 532296 : p->end_col_offset = end_col_offset;
2287 : 532296 : return p;
2288 : : }
2289 : :
2290 : : stmt_ty
2291 : 38960 : _PyAST_With(asdl_withitem_seq * items, asdl_stmt_seq * body, string
2292 : : type_comment, int lineno, int col_offset, int end_lineno, int
2293 : : end_col_offset, PyArena *arena)
2294 : : {
2295 : : stmt_ty p;
2296 : 38960 : p = (stmt_ty)_PyArena_Malloc(arena, sizeof(*p));
2297 [ - + ]: 38960 : if (!p)
2298 : 0 : return NULL;
2299 : 38960 : p->kind = With_kind;
2300 : 38960 : p->v.With.items = items;
2301 : 38960 : p->v.With.body = body;
2302 : 38960 : p->v.With.type_comment = type_comment;
2303 : 38960 : p->lineno = lineno;
2304 : 38960 : p->col_offset = col_offset;
2305 : 38960 : p->end_lineno = end_lineno;
2306 : 38960 : p->end_col_offset = end_col_offset;
2307 : 38960 : return p;
2308 : : }
2309 : :
2310 : : stmt_ty
2311 : 380 : _PyAST_AsyncWith(asdl_withitem_seq * items, asdl_stmt_seq * body, string
2312 : : type_comment, int lineno, int col_offset, int end_lineno, int
2313 : : end_col_offset, PyArena *arena)
2314 : : {
2315 : : stmt_ty p;
2316 : 380 : p = (stmt_ty)_PyArena_Malloc(arena, sizeof(*p));
2317 [ - + ]: 380 : if (!p)
2318 : 0 : return NULL;
2319 : 380 : p->kind = AsyncWith_kind;
2320 : 380 : p->v.AsyncWith.items = items;
2321 : 380 : p->v.AsyncWith.body = body;
2322 : 380 : p->v.AsyncWith.type_comment = type_comment;
2323 : 380 : p->lineno = lineno;
2324 : 380 : p->col_offset = col_offset;
2325 : 380 : p->end_lineno = end_lineno;
2326 : 380 : p->end_col_offset = end_col_offset;
2327 : 380 : return p;
2328 : : }
2329 : :
2330 : : stmt_ty
2331 : 1252 : _PyAST_Match(expr_ty subject, asdl_match_case_seq * cases, int lineno, int
2332 : : col_offset, int end_lineno, int end_col_offset, PyArena *arena)
2333 : : {
2334 : : stmt_ty p;
2335 [ - + ]: 1252 : if (!subject) {
2336 : 0 : PyErr_SetString(PyExc_ValueError,
2337 : : "field 'subject' is required for Match");
2338 : 0 : return NULL;
2339 : : }
2340 : 1252 : p = (stmt_ty)_PyArena_Malloc(arena, sizeof(*p));
2341 [ - + ]: 1252 : if (!p)
2342 : 0 : return NULL;
2343 : 1252 : p->kind = Match_kind;
2344 : 1252 : p->v.Match.subject = subject;
2345 : 1252 : p->v.Match.cases = cases;
2346 : 1252 : p->lineno = lineno;
2347 : 1252 : p->col_offset = col_offset;
2348 : 1252 : p->end_lineno = end_lineno;
2349 : 1252 : p->end_col_offset = end_col_offset;
2350 : 1252 : return p;
2351 : : }
2352 : :
2353 : : stmt_ty
2354 : 63324 : _PyAST_Raise(expr_ty exc, expr_ty cause, int lineno, int col_offset, int
2355 : : end_lineno, int end_col_offset, PyArena *arena)
2356 : : {
2357 : : stmt_ty p;
2358 : 63324 : p = (stmt_ty)_PyArena_Malloc(arena, sizeof(*p));
2359 [ - + ]: 63324 : if (!p)
2360 : 0 : return NULL;
2361 : 63324 : p->kind = Raise_kind;
2362 : 63324 : p->v.Raise.exc = exc;
2363 : 63324 : p->v.Raise.cause = cause;
2364 : 63324 : p->lineno = lineno;
2365 : 63324 : p->col_offset = col_offset;
2366 : 63324 : p->end_lineno = end_lineno;
2367 : 63324 : p->end_col_offset = end_col_offset;
2368 : 63324 : return p;
2369 : : }
2370 : :
2371 : : stmt_ty
2372 : 50177 : _PyAST_Try(asdl_stmt_seq * body, asdl_excepthandler_seq * handlers,
2373 : : asdl_stmt_seq * orelse, asdl_stmt_seq * finalbody, int lineno, int
2374 : : col_offset, int end_lineno, int end_col_offset, PyArena *arena)
2375 : : {
2376 : : stmt_ty p;
2377 : 50177 : p = (stmt_ty)_PyArena_Malloc(arena, sizeof(*p));
2378 [ - + ]: 50177 : if (!p)
2379 : 0 : return NULL;
2380 : 50177 : p->kind = Try_kind;
2381 : 50177 : p->v.Try.body = body;
2382 : 50177 : p->v.Try.handlers = handlers;
2383 : 50177 : p->v.Try.orelse = orelse;
2384 : 50177 : p->v.Try.finalbody = finalbody;
2385 : 50177 : p->lineno = lineno;
2386 : 50177 : p->col_offset = col_offset;
2387 : 50177 : p->end_lineno = end_lineno;
2388 : 50177 : p->end_col_offset = end_col_offset;
2389 : 50177 : return p;
2390 : : }
2391 : :
2392 : : stmt_ty
2393 : 269 : _PyAST_TryStar(asdl_stmt_seq * body, asdl_excepthandler_seq * handlers,
2394 : : asdl_stmt_seq * orelse, asdl_stmt_seq * finalbody, int lineno,
2395 : : int col_offset, int end_lineno, int end_col_offset, PyArena
2396 : : *arena)
2397 : : {
2398 : : stmt_ty p;
2399 : 269 : p = (stmt_ty)_PyArena_Malloc(arena, sizeof(*p));
2400 [ - + ]: 269 : if (!p)
2401 : 0 : return NULL;
2402 : 269 : p->kind = TryStar_kind;
2403 : 269 : p->v.TryStar.body = body;
2404 : 269 : p->v.TryStar.handlers = handlers;
2405 : 269 : p->v.TryStar.orelse = orelse;
2406 : 269 : p->v.TryStar.finalbody = finalbody;
2407 : 269 : p->lineno = lineno;
2408 : 269 : p->col_offset = col_offset;
2409 : 269 : p->end_lineno = end_lineno;
2410 : 269 : p->end_col_offset = end_col_offset;
2411 : 269 : return p;
2412 : : }
2413 : :
2414 : : stmt_ty
2415 : 10032 : _PyAST_Assert(expr_ty test, expr_ty msg, int lineno, int col_offset, int
2416 : : end_lineno, int end_col_offset, PyArena *arena)
2417 : : {
2418 : : stmt_ty p;
2419 [ - + ]: 10032 : if (!test) {
2420 : 0 : PyErr_SetString(PyExc_ValueError,
2421 : : "field 'test' is required for Assert");
2422 : 0 : return NULL;
2423 : : }
2424 : 10032 : p = (stmt_ty)_PyArena_Malloc(arena, sizeof(*p));
2425 [ - + ]: 10032 : if (!p)
2426 : 0 : return NULL;
2427 : 10032 : p->kind = Assert_kind;
2428 : 10032 : p->v.Assert.test = test;
2429 : 10032 : p->v.Assert.msg = msg;
2430 : 10032 : p->lineno = lineno;
2431 : 10032 : p->col_offset = col_offset;
2432 : 10032 : p->end_lineno = end_lineno;
2433 : 10032 : p->end_col_offset = end_col_offset;
2434 : 10032 : return p;
2435 : : }
2436 : :
2437 : : stmt_ty
2438 : 45780 : _PyAST_Import(asdl_alias_seq * names, int lineno, int col_offset, int
2439 : : end_lineno, int end_col_offset, PyArena *arena)
2440 : : {
2441 : : stmt_ty p;
2442 : 45780 : p = (stmt_ty)_PyArena_Malloc(arena, sizeof(*p));
2443 [ - + ]: 45780 : if (!p)
2444 : 0 : return NULL;
2445 : 45780 : p->kind = Import_kind;
2446 : 45780 : p->v.Import.names = names;
2447 : 45780 : p->lineno = lineno;
2448 : 45780 : p->col_offset = col_offset;
2449 : 45780 : p->end_lineno = end_lineno;
2450 : 45780 : p->end_col_offset = end_col_offset;
2451 : 45780 : return p;
2452 : : }
2453 : :
2454 : : stmt_ty
2455 : 46123 : _PyAST_ImportFrom(identifier module, asdl_alias_seq * names, int level, int
2456 : : lineno, int col_offset, int end_lineno, int end_col_offset,
2457 : : PyArena *arena)
2458 : : {
2459 : : stmt_ty p;
2460 : 46123 : p = (stmt_ty)_PyArena_Malloc(arena, sizeof(*p));
2461 [ - + ]: 46123 : if (!p)
2462 : 0 : return NULL;
2463 : 46123 : p->kind = ImportFrom_kind;
2464 : 46123 : p->v.ImportFrom.module = module;
2465 : 46123 : p->v.ImportFrom.names = names;
2466 : 46123 : p->v.ImportFrom.level = level;
2467 : 46123 : p->lineno = lineno;
2468 : 46123 : p->col_offset = col_offset;
2469 : 46123 : p->end_lineno = end_lineno;
2470 : 46123 : p->end_col_offset = end_col_offset;
2471 : 46123 : return p;
2472 : : }
2473 : :
2474 : : stmt_ty
2475 : 1882 : _PyAST_Global(asdl_identifier_seq * names, int lineno, int col_offset, int
2476 : : end_lineno, int end_col_offset, PyArena *arena)
2477 : : {
2478 : : stmt_ty p;
2479 : 1882 : p = (stmt_ty)_PyArena_Malloc(arena, sizeof(*p));
2480 [ - + ]: 1882 : if (!p)
2481 : 0 : return NULL;
2482 : 1882 : p->kind = Global_kind;
2483 : 1882 : p->v.Global.names = names;
2484 : 1882 : p->lineno = lineno;
2485 : 1882 : p->col_offset = col_offset;
2486 : 1882 : p->end_lineno = end_lineno;
2487 : 1882 : p->end_col_offset = end_col_offset;
2488 : 1882 : return p;
2489 : : }
2490 : :
2491 : : stmt_ty
2492 : 949 : _PyAST_Nonlocal(asdl_identifier_seq * names, int lineno, int col_offset, int
2493 : : end_lineno, int end_col_offset, PyArena *arena)
2494 : : {
2495 : : stmt_ty p;
2496 : 949 : p = (stmt_ty)_PyArena_Malloc(arena, sizeof(*p));
2497 [ - + ]: 949 : if (!p)
2498 : 0 : return NULL;
2499 : 949 : p->kind = Nonlocal_kind;
2500 : 949 : p->v.Nonlocal.names = names;
2501 : 949 : p->lineno = lineno;
2502 : 949 : p->col_offset = col_offset;
2503 : 949 : p->end_lineno = end_lineno;
2504 : 949 : p->end_col_offset = end_col_offset;
2505 : 949 : return p;
2506 : : }
2507 : :
2508 : : stmt_ty
2509 : 886860 : _PyAST_Expr(expr_ty value, int lineno, int col_offset, int end_lineno, int
2510 : : end_col_offset, PyArena *arena)
2511 : : {
2512 : : stmt_ty p;
2513 [ - + ]: 886860 : if (!value) {
2514 : 0 : PyErr_SetString(PyExc_ValueError,
2515 : : "field 'value' is required for Expr");
2516 : 0 : return NULL;
2517 : : }
2518 : 886860 : p = (stmt_ty)_PyArena_Malloc(arena, sizeof(*p));
2519 [ - + ]: 886860 : if (!p)
2520 : 0 : return NULL;
2521 : 886860 : p->kind = Expr_kind;
2522 : 886860 : p->v.Expr.value = value;
2523 : 886860 : p->lineno = lineno;
2524 : 886860 : p->col_offset = col_offset;
2525 : 886860 : p->end_lineno = end_lineno;
2526 : 886860 : p->end_col_offset = end_col_offset;
2527 : 886860 : return p;
2528 : : }
2529 : :
2530 : : stmt_ty
2531 : 27974 : _PyAST_Pass(int lineno, int col_offset, int end_lineno, int end_col_offset,
2532 : : PyArena *arena)
2533 : : {
2534 : : stmt_ty p;
2535 : 27974 : p = (stmt_ty)_PyArena_Malloc(arena, sizeof(*p));
2536 [ - + ]: 27974 : if (!p)
2537 : 0 : return NULL;
2538 : 27974 : p->kind = Pass_kind;
2539 : 27974 : p->lineno = lineno;
2540 : 27974 : p->col_offset = col_offset;
2541 : 27974 : p->end_lineno = end_lineno;
2542 : 27974 : p->end_col_offset = end_col_offset;
2543 : 27974 : return p;
2544 : : }
2545 : :
2546 : : stmt_ty
2547 : 10105 : _PyAST_Break(int lineno, int col_offset, int end_lineno, int end_col_offset,
2548 : : PyArena *arena)
2549 : : {
2550 : : stmt_ty p;
2551 : 10105 : p = (stmt_ty)_PyArena_Malloc(arena, sizeof(*p));
2552 [ - + ]: 10105 : if (!p)
2553 : 0 : return NULL;
2554 : 10105 : p->kind = Break_kind;
2555 : 10105 : p->lineno = lineno;
2556 : 10105 : p->col_offset = col_offset;
2557 : 10105 : p->end_lineno = end_lineno;
2558 : 10105 : p->end_col_offset = end_col_offset;
2559 : 10105 : return p;
2560 : : }
2561 : :
2562 : : stmt_ty
2563 : 8937 : _PyAST_Continue(int lineno, int col_offset, int end_lineno, int end_col_offset,
2564 : : PyArena *arena)
2565 : : {
2566 : : stmt_ty p;
2567 : 8937 : p = (stmt_ty)_PyArena_Malloc(arena, sizeof(*p));
2568 [ - + ]: 8937 : if (!p)
2569 : 0 : return NULL;
2570 : 8937 : p->kind = Continue_kind;
2571 : 8937 : p->lineno = lineno;
2572 : 8937 : p->col_offset = col_offset;
2573 : 8937 : p->end_lineno = end_lineno;
2574 : 8937 : p->end_col_offset = end_col_offset;
2575 : 8937 : return p;
2576 : : }
2577 : :
2578 : : expr_ty
2579 : 67260 : _PyAST_BoolOp(boolop_ty op, asdl_expr_seq * values, int lineno, int col_offset,
2580 : : int end_lineno, int end_col_offset, PyArena *arena)
2581 : : {
2582 : : expr_ty p;
2583 [ - + ]: 67260 : if (!op) {
2584 : 0 : PyErr_SetString(PyExc_ValueError,
2585 : : "field 'op' is required for BoolOp");
2586 : 0 : return NULL;
2587 : : }
2588 : 67260 : p = (expr_ty)_PyArena_Malloc(arena, sizeof(*p));
2589 [ - + ]: 67260 : if (!p)
2590 : 0 : return NULL;
2591 : 67260 : p->kind = BoolOp_kind;
2592 : 67260 : p->v.BoolOp.op = op;
2593 : 67260 : p->v.BoolOp.values = values;
2594 : 67260 : p->lineno = lineno;
2595 : 67260 : p->col_offset = col_offset;
2596 : 67260 : p->end_lineno = end_lineno;
2597 : 67260 : p->end_col_offset = end_col_offset;
2598 : 67260 : return p;
2599 : : }
2600 : :
2601 : : expr_ty
2602 : 3532 : _PyAST_NamedExpr(expr_ty target, expr_ty value, int lineno, int col_offset, int
2603 : : end_lineno, int end_col_offset, PyArena *arena)
2604 : : {
2605 : : expr_ty p;
2606 [ - + ]: 3532 : if (!target) {
2607 : 0 : PyErr_SetString(PyExc_ValueError,
2608 : : "field 'target' is required for NamedExpr");
2609 : 0 : return NULL;
2610 : : }
2611 [ - + ]: 3532 : if (!value) {
2612 : 0 : PyErr_SetString(PyExc_ValueError,
2613 : : "field 'value' is required for NamedExpr");
2614 : 0 : return NULL;
2615 : : }
2616 : 3532 : p = (expr_ty)_PyArena_Malloc(arena, sizeof(*p));
2617 [ - + ]: 3532 : if (!p)
2618 : 0 : return NULL;
2619 : 3532 : p->kind = NamedExpr_kind;
2620 : 3532 : p->v.NamedExpr.target = target;
2621 : 3532 : p->v.NamedExpr.value = value;
2622 : 3532 : p->lineno = lineno;
2623 : 3532 : p->col_offset = col_offset;
2624 : 3532 : p->end_lineno = end_lineno;
2625 : 3532 : p->end_col_offset = end_col_offset;
2626 : 3532 : return p;
2627 : : }
2628 : :
2629 : : expr_ty
2630 : 582296 : _PyAST_BinOp(expr_ty left, operator_ty op, expr_ty right, int lineno, int
2631 : : col_offset, int end_lineno, int end_col_offset, PyArena *arena)
2632 : : {
2633 : : expr_ty p;
2634 [ - + ]: 582296 : if (!left) {
2635 : 0 : PyErr_SetString(PyExc_ValueError,
2636 : : "field 'left' is required for BinOp");
2637 : 0 : return NULL;
2638 : : }
2639 [ - + ]: 582296 : if (!op) {
2640 : 0 : PyErr_SetString(PyExc_ValueError,
2641 : : "field 'op' is required for BinOp");
2642 : 0 : return NULL;
2643 : : }
2644 [ - + ]: 582296 : if (!right) {
2645 : 0 : PyErr_SetString(PyExc_ValueError,
2646 : : "field 'right' is required for BinOp");
2647 : 0 : return NULL;
2648 : : }
2649 : 582296 : p = (expr_ty)_PyArena_Malloc(arena, sizeof(*p));
2650 [ - + ]: 582296 : if (!p)
2651 : 0 : return NULL;
2652 : 582296 : p->kind = BinOp_kind;
2653 : 582296 : p->v.BinOp.left = left;
2654 : 582296 : p->v.BinOp.op = op;
2655 : 582296 : p->v.BinOp.right = right;
2656 : 582296 : p->lineno = lineno;
2657 : 582296 : p->col_offset = col_offset;
2658 : 582296 : p->end_lineno = end_lineno;
2659 : 582296 : p->end_col_offset = end_col_offset;
2660 : 582296 : return p;
2661 : : }
2662 : :
2663 : : expr_ty
2664 : 105547 : _PyAST_UnaryOp(unaryop_ty op, expr_ty operand, int lineno, int col_offset, int
2665 : : end_lineno, int end_col_offset, PyArena *arena)
2666 : : {
2667 : : expr_ty p;
2668 [ - + ]: 105547 : if (!op) {
2669 : 0 : PyErr_SetString(PyExc_ValueError,
2670 : : "field 'op' is required for UnaryOp");
2671 : 0 : return NULL;
2672 : : }
2673 [ - + ]: 105547 : if (!operand) {
2674 : 0 : PyErr_SetString(PyExc_ValueError,
2675 : : "field 'operand' is required for UnaryOp");
2676 : 0 : return NULL;
2677 : : }
2678 : 105547 : p = (expr_ty)_PyArena_Malloc(arena, sizeof(*p));
2679 [ - + ]: 105547 : if (!p)
2680 : 0 : return NULL;
2681 : 105547 : p->kind = UnaryOp_kind;
2682 : 105547 : p->v.UnaryOp.op = op;
2683 : 105547 : p->v.UnaryOp.operand = operand;
2684 : 105547 : p->lineno = lineno;
2685 : 105547 : p->col_offset = col_offset;
2686 : 105547 : p->end_lineno = end_lineno;
2687 : 105547 : p->end_col_offset = end_col_offset;
2688 : 105547 : return p;
2689 : : }
2690 : :
2691 : : expr_ty
2692 : 37374 : _PyAST_Lambda(arguments_ty args, expr_ty body, int lineno, int col_offset, int
2693 : : end_lineno, int end_col_offset, PyArena *arena)
2694 : : {
2695 : : expr_ty p;
2696 [ - + ]: 37374 : if (!args) {
2697 : 0 : PyErr_SetString(PyExc_ValueError,
2698 : : "field 'args' is required for Lambda");
2699 : 0 : return NULL;
2700 : : }
2701 [ - + ]: 37374 : if (!body) {
2702 : 0 : PyErr_SetString(PyExc_ValueError,
2703 : : "field 'body' is required for Lambda");
2704 : 0 : return NULL;
2705 : : }
2706 : 37374 : p = (expr_ty)_PyArena_Malloc(arena, sizeof(*p));
2707 [ - + ]: 37374 : if (!p)
2708 : 0 : return NULL;
2709 : 37374 : p->kind = Lambda_kind;
2710 : 37374 : p->v.Lambda.args = args;
2711 : 37374 : p->v.Lambda.body = body;
2712 : 37374 : p->lineno = lineno;
2713 : 37374 : p->col_offset = col_offset;
2714 : 37374 : p->end_lineno = end_lineno;
2715 : 37374 : p->end_col_offset = end_col_offset;
2716 : 37374 : return p;
2717 : : }
2718 : :
2719 : : expr_ty
2720 : 11316 : _PyAST_IfExp(expr_ty test, expr_ty body, expr_ty orelse, int lineno, int
2721 : : col_offset, int end_lineno, int end_col_offset, PyArena *arena)
2722 : : {
2723 : : expr_ty p;
2724 [ - + ]: 11316 : if (!test) {
2725 : 0 : PyErr_SetString(PyExc_ValueError,
2726 : : "field 'test' is required for IfExp");
2727 : 0 : return NULL;
2728 : : }
2729 [ - + ]: 11316 : if (!body) {
2730 : 0 : PyErr_SetString(PyExc_ValueError,
2731 : : "field 'body' is required for IfExp");
2732 : 0 : return NULL;
2733 : : }
2734 [ - + ]: 11316 : if (!orelse) {
2735 : 0 : PyErr_SetString(PyExc_ValueError,
2736 : : "field 'orelse' is required for IfExp");
2737 : 0 : return NULL;
2738 : : }
2739 : 11316 : p = (expr_ty)_PyArena_Malloc(arena, sizeof(*p));
2740 [ - + ]: 11316 : if (!p)
2741 : 0 : return NULL;
2742 : 11316 : p->kind = IfExp_kind;
2743 : 11316 : p->v.IfExp.test = test;
2744 : 11316 : p->v.IfExp.body = body;
2745 : 11316 : p->v.IfExp.orelse = orelse;
2746 : 11316 : p->lineno = lineno;
2747 : 11316 : p->col_offset = col_offset;
2748 : 11316 : p->end_lineno = end_lineno;
2749 : 11316 : p->end_col_offset = end_col_offset;
2750 : 11316 : return p;
2751 : : }
2752 : :
2753 : : expr_ty
2754 : 99798 : _PyAST_Dict(asdl_expr_seq * keys, asdl_expr_seq * values, int lineno, int
2755 : : col_offset, int end_lineno, int end_col_offset, PyArena *arena)
2756 : : {
2757 : : expr_ty p;
2758 : 99798 : p = (expr_ty)_PyArena_Malloc(arena, sizeof(*p));
2759 [ - + ]: 99798 : if (!p)
2760 : 0 : return NULL;
2761 : 99798 : p->kind = Dict_kind;
2762 : 99798 : p->v.Dict.keys = keys;
2763 : 99798 : p->v.Dict.values = values;
2764 : 99798 : p->lineno = lineno;
2765 : 99798 : p->col_offset = col_offset;
2766 : 99798 : p->end_lineno = end_lineno;
2767 : 99798 : p->end_col_offset = end_col_offset;
2768 : 99798 : return p;
2769 : : }
2770 : :
2771 : : expr_ty
2772 : 8505 : _PyAST_Set(asdl_expr_seq * elts, int lineno, int col_offset, int end_lineno,
2773 : : int end_col_offset, PyArena *arena)
2774 : : {
2775 : : expr_ty p;
2776 : 8505 : p = (expr_ty)_PyArena_Malloc(arena, sizeof(*p));
2777 [ - + ]: 8505 : if (!p)
2778 : 0 : return NULL;
2779 : 8505 : p->kind = Set_kind;
2780 : 8505 : p->v.Set.elts = elts;
2781 : 8505 : p->lineno = lineno;
2782 : 8505 : p->col_offset = col_offset;
2783 : 8505 : p->end_lineno = end_lineno;
2784 : 8505 : p->end_col_offset = end_col_offset;
2785 : 8505 : return p;
2786 : : }
2787 : :
2788 : : expr_ty
2789 : 29454 : _PyAST_ListComp(expr_ty elt, asdl_comprehension_seq * generators, int lineno,
2790 : : int col_offset, int end_lineno, int end_col_offset, PyArena
2791 : : *arena)
2792 : : {
2793 : : expr_ty p;
2794 [ - + ]: 29454 : if (!elt) {
2795 : 0 : PyErr_SetString(PyExc_ValueError,
2796 : : "field 'elt' is required for ListComp");
2797 : 0 : return NULL;
2798 : : }
2799 : 29454 : p = (expr_ty)_PyArena_Malloc(arena, sizeof(*p));
2800 [ - + ]: 29454 : if (!p)
2801 : 0 : return NULL;
2802 : 29454 : p->kind = ListComp_kind;
2803 : 29454 : p->v.ListComp.elt = elt;
2804 : 29454 : p->v.ListComp.generators = generators;
2805 : 29454 : p->lineno = lineno;
2806 : 29454 : p->col_offset = col_offset;
2807 : 29454 : p->end_lineno = end_lineno;
2808 : 29454 : p->end_col_offset = end_col_offset;
2809 : 29454 : return p;
2810 : : }
2811 : :
2812 : : expr_ty
2813 : 1551 : _PyAST_SetComp(expr_ty elt, asdl_comprehension_seq * generators, int lineno,
2814 : : int col_offset, int end_lineno, int end_col_offset, PyArena
2815 : : *arena)
2816 : : {
2817 : : expr_ty p;
2818 [ - + ]: 1551 : if (!elt) {
2819 : 0 : PyErr_SetString(PyExc_ValueError,
2820 : : "field 'elt' is required for SetComp");
2821 : 0 : return NULL;
2822 : : }
2823 : 1551 : p = (expr_ty)_PyArena_Malloc(arena, sizeof(*p));
2824 [ - + ]: 1551 : if (!p)
2825 : 0 : return NULL;
2826 : 1551 : p->kind = SetComp_kind;
2827 : 1551 : p->v.SetComp.elt = elt;
2828 : 1551 : p->v.SetComp.generators = generators;
2829 : 1551 : p->lineno = lineno;
2830 : 1551 : p->col_offset = col_offset;
2831 : 1551 : p->end_lineno = end_lineno;
2832 : 1551 : p->end_col_offset = end_col_offset;
2833 : 1551 : return p;
2834 : : }
2835 : :
2836 : : expr_ty
2837 : 3817 : _PyAST_DictComp(expr_ty key, expr_ty value, asdl_comprehension_seq *
2838 : : generators, int lineno, int col_offset, int end_lineno, int
2839 : : end_col_offset, PyArena *arena)
2840 : : {
2841 : : expr_ty p;
2842 [ - + ]: 3817 : if (!key) {
2843 : 0 : PyErr_SetString(PyExc_ValueError,
2844 : : "field 'key' is required for DictComp");
2845 : 0 : return NULL;
2846 : : }
2847 [ - + ]: 3817 : if (!value) {
2848 : 0 : PyErr_SetString(PyExc_ValueError,
2849 : : "field 'value' is required for DictComp");
2850 : 0 : return NULL;
2851 : : }
2852 : 3817 : p = (expr_ty)_PyArena_Malloc(arena, sizeof(*p));
2853 [ - + ]: 3817 : if (!p)
2854 : 0 : return NULL;
2855 : 3817 : p->kind = DictComp_kind;
2856 : 3817 : p->v.DictComp.key = key;
2857 : 3817 : p->v.DictComp.value = value;
2858 : 3817 : p->v.DictComp.generators = generators;
2859 : 3817 : p->lineno = lineno;
2860 : 3817 : p->col_offset = col_offset;
2861 : 3817 : p->end_lineno = end_lineno;
2862 : 3817 : p->end_col_offset = end_col_offset;
2863 : 3817 : return p;
2864 : : }
2865 : :
2866 : : expr_ty
2867 : 15346 : _PyAST_GeneratorExp(expr_ty elt, asdl_comprehension_seq * generators, int
2868 : : lineno, int col_offset, int end_lineno, int end_col_offset,
2869 : : PyArena *arena)
2870 : : {
2871 : : expr_ty p;
2872 [ - + ]: 15346 : if (!elt) {
2873 : 0 : PyErr_SetString(PyExc_ValueError,
2874 : : "field 'elt' is required for GeneratorExp");
2875 : 0 : return NULL;
2876 : : }
2877 : 15346 : p = (expr_ty)_PyArena_Malloc(arena, sizeof(*p));
2878 [ - + ]: 15346 : if (!p)
2879 : 0 : return NULL;
2880 : 15346 : p->kind = GeneratorExp_kind;
2881 : 15346 : p->v.GeneratorExp.elt = elt;
2882 : 15346 : p->v.GeneratorExp.generators = generators;
2883 : 15346 : p->lineno = lineno;
2884 : 15346 : p->col_offset = col_offset;
2885 : 15346 : p->end_lineno = end_lineno;
2886 : 15346 : p->end_col_offset = end_col_offset;
2887 : 15346 : return p;
2888 : : }
2889 : :
2890 : : expr_ty
2891 : 2386 : _PyAST_Await(expr_ty value, int lineno, int col_offset, int end_lineno, int
2892 : : end_col_offset, PyArena *arena)
2893 : : {
2894 : : expr_ty p;
2895 [ - + ]: 2386 : if (!value) {
2896 : 0 : PyErr_SetString(PyExc_ValueError,
2897 : : "field 'value' is required for Await");
2898 : 0 : return NULL;
2899 : : }
2900 : 2386 : p = (expr_ty)_PyArena_Malloc(arena, sizeof(*p));
2901 [ - + ]: 2386 : if (!p)
2902 : 0 : return NULL;
2903 : 2386 : p->kind = Await_kind;
2904 : 2386 : p->v.Await.value = value;
2905 : 2386 : p->lineno = lineno;
2906 : 2386 : p->col_offset = col_offset;
2907 : 2386 : p->end_lineno = end_lineno;
2908 : 2386 : p->end_col_offset = end_col_offset;
2909 : 2386 : return p;
2910 : : }
2911 : :
2912 : : expr_ty
2913 : 13838 : _PyAST_Yield(expr_ty value, int lineno, int col_offset, int end_lineno, int
2914 : : end_col_offset, PyArena *arena)
2915 : : {
2916 : : expr_ty p;
2917 : 13838 : p = (expr_ty)_PyArena_Malloc(arena, sizeof(*p));
2918 [ - + ]: 13838 : if (!p)
2919 : 0 : return NULL;
2920 : 13838 : p->kind = Yield_kind;
2921 : 13838 : p->v.Yield.value = value;
2922 : 13838 : p->lineno = lineno;
2923 : 13838 : p->col_offset = col_offset;
2924 : 13838 : p->end_lineno = end_lineno;
2925 : 13838 : p->end_col_offset = end_col_offset;
2926 : 13838 : return p;
2927 : : }
2928 : :
2929 : : expr_ty
2930 : 2293 : _PyAST_YieldFrom(expr_ty value, int lineno, int col_offset, int end_lineno, int
2931 : : end_col_offset, PyArena *arena)
2932 : : {
2933 : : expr_ty p;
2934 [ + + ]: 2293 : if (!value) {
2935 : 1 : PyErr_SetString(PyExc_ValueError,
2936 : : "field 'value' is required for YieldFrom");
2937 : 1 : return NULL;
2938 : : }
2939 : 2292 : p = (expr_ty)_PyArena_Malloc(arena, sizeof(*p));
2940 [ - + ]: 2292 : if (!p)
2941 : 0 : return NULL;
2942 : 2292 : p->kind = YieldFrom_kind;
2943 : 2292 : p->v.YieldFrom.value = value;
2944 : 2292 : p->lineno = lineno;
2945 : 2292 : p->col_offset = col_offset;
2946 : 2292 : p->end_lineno = end_lineno;
2947 : 2292 : p->end_col_offset = end_col_offset;
2948 : 2292 : return p;
2949 : : }
2950 : :
2951 : : expr_ty
2952 : 249964 : _PyAST_Compare(expr_ty left, asdl_int_seq * ops, asdl_expr_seq * comparators,
2953 : : int lineno, int col_offset, int end_lineno, int end_col_offset,
2954 : : PyArena *arena)
2955 : : {
2956 : : expr_ty p;
2957 [ - + ]: 249964 : if (!left) {
2958 : 0 : PyErr_SetString(PyExc_ValueError,
2959 : : "field 'left' is required for Compare");
2960 : 0 : return NULL;
2961 : : }
2962 : 249964 : p = (expr_ty)_PyArena_Malloc(arena, sizeof(*p));
2963 [ - + ]: 249964 : if (!p)
2964 : 0 : return NULL;
2965 : 249964 : p->kind = Compare_kind;
2966 : 249964 : p->v.Compare.left = left;
2967 : 249964 : p->v.Compare.ops = ops;
2968 : 249964 : p->v.Compare.comparators = comparators;
2969 : 249964 : p->lineno = lineno;
2970 : 249964 : p->col_offset = col_offset;
2971 : 249964 : p->end_lineno = end_lineno;
2972 : 249964 : p->end_col_offset = end_col_offset;
2973 : 249964 : return p;
2974 : : }
2975 : :
2976 : : expr_ty
2977 : 3631708 : _PyAST_Call(expr_ty func, asdl_expr_seq * args, asdl_keyword_seq * keywords,
2978 : : int lineno, int col_offset, int end_lineno, int end_col_offset,
2979 : : PyArena *arena)
2980 : : {
2981 : : expr_ty p;
2982 [ - + ]: 3631708 : if (!func) {
2983 : 0 : PyErr_SetString(PyExc_ValueError,
2984 : : "field 'func' is required for Call");
2985 : 0 : return NULL;
2986 : : }
2987 : 3631708 : p = (expr_ty)_PyArena_Malloc(arena, sizeof(*p));
2988 [ - + ]: 3631708 : if (!p)
2989 : 0 : return NULL;
2990 : 3631708 : p->kind = Call_kind;
2991 : 3631708 : p->v.Call.func = func;
2992 : 3631708 : p->v.Call.args = args;
2993 : 3631708 : p->v.Call.keywords = keywords;
2994 : 3631708 : p->lineno = lineno;
2995 : 3631708 : p->col_offset = col_offset;
2996 : 3631708 : p->end_lineno = end_lineno;
2997 : 3631708 : p->end_col_offset = end_col_offset;
2998 : 3631708 : return p;
2999 : : }
3000 : :
3001 : : expr_ty
3002 : 124528 : _PyAST_FormattedValue(expr_ty value, int conversion, expr_ty format_spec, int
3003 : : lineno, int col_offset, int end_lineno, int
3004 : : end_col_offset, PyArena *arena)
3005 : : {
3006 : : expr_ty p;
3007 [ - + ]: 124528 : if (!value) {
3008 : 0 : PyErr_SetString(PyExc_ValueError,
3009 : : "field 'value' is required for FormattedValue");
3010 : 0 : return NULL;
3011 : : }
3012 : 124528 : p = (expr_ty)_PyArena_Malloc(arena, sizeof(*p));
3013 [ - + ]: 124528 : if (!p)
3014 : 0 : return NULL;
3015 : 124528 : p->kind = FormattedValue_kind;
3016 : 124528 : p->v.FormattedValue.value = value;
3017 : 124528 : p->v.FormattedValue.conversion = conversion;
3018 : 124528 : p->v.FormattedValue.format_spec = format_spec;
3019 : 124528 : p->lineno = lineno;
3020 : 124528 : p->col_offset = col_offset;
3021 : 124528 : p->end_lineno = end_lineno;
3022 : 124528 : p->end_col_offset = end_col_offset;
3023 : 124528 : return p;
3024 : : }
3025 : :
3026 : : expr_ty
3027 : 34579 : _PyAST_JoinedStr(asdl_expr_seq * values, int lineno, int col_offset, int
3028 : : end_lineno, int end_col_offset, PyArena *arena)
3029 : : {
3030 : : expr_ty p;
3031 : 34579 : p = (expr_ty)_PyArena_Malloc(arena, sizeof(*p));
3032 [ - + ]: 34579 : if (!p)
3033 : 0 : return NULL;
3034 : 34579 : p->kind = JoinedStr_kind;
3035 : 34579 : p->v.JoinedStr.values = values;
3036 : 34579 : p->lineno = lineno;
3037 : 34579 : p->col_offset = col_offset;
3038 : 34579 : p->end_lineno = end_lineno;
3039 : 34579 : p->end_col_offset = end_col_offset;
3040 : 34579 : return p;
3041 : : }
3042 : :
3043 : : expr_ty
3044 : 8253781 : _PyAST_Constant(constant value, string kind, int lineno, int col_offset, int
3045 : : end_lineno, int end_col_offset, PyArena *arena)
3046 : : {
3047 : : expr_ty p;
3048 [ - + ]: 8253781 : if (!value) {
3049 : 0 : PyErr_SetString(PyExc_ValueError,
3050 : : "field 'value' is required for Constant");
3051 : 0 : return NULL;
3052 : : }
3053 : 8253781 : p = (expr_ty)_PyArena_Malloc(arena, sizeof(*p));
3054 [ - + ]: 8253781 : if (!p)
3055 : 0 : return NULL;
3056 : 8253781 : p->kind = Constant_kind;
3057 : 8253781 : p->v.Constant.value = value;
3058 : 8253781 : p->v.Constant.kind = kind;
3059 : 8253781 : p->lineno = lineno;
3060 : 8253781 : p->col_offset = col_offset;
3061 : 8253781 : p->end_lineno = end_lineno;
3062 : 8253781 : p->end_col_offset = end_col_offset;
3063 : 8253781 : return p;
3064 : : }
3065 : :
3066 : : expr_ty
3067 : 3427125 : _PyAST_Attribute(expr_ty value, identifier attr, expr_context_ty ctx, int
3068 : : lineno, int col_offset, int end_lineno, int end_col_offset,
3069 : : PyArena *arena)
3070 : : {
3071 : : expr_ty p;
3072 [ - + ]: 3427125 : if (!value) {
3073 : 0 : PyErr_SetString(PyExc_ValueError,
3074 : : "field 'value' is required for Attribute");
3075 : 0 : return NULL;
3076 : : }
3077 [ - + ]: 3427125 : if (!attr) {
3078 : 0 : PyErr_SetString(PyExc_ValueError,
3079 : : "field 'attr' is required for Attribute");
3080 : 0 : return NULL;
3081 : : }
3082 [ - + ]: 3427125 : if (!ctx) {
3083 : 0 : PyErr_SetString(PyExc_ValueError,
3084 : : "field 'ctx' is required for Attribute");
3085 : 0 : return NULL;
3086 : : }
3087 : 3427125 : p = (expr_ty)_PyArena_Malloc(arena, sizeof(*p));
3088 [ - + ]: 3427125 : if (!p)
3089 : 0 : return NULL;
3090 : 3427125 : p->kind = Attribute_kind;
3091 : 3427125 : p->v.Attribute.value = value;
3092 : 3427125 : p->v.Attribute.attr = attr;
3093 : 3427125 : p->v.Attribute.ctx = ctx;
3094 : 3427125 : p->lineno = lineno;
3095 : 3427125 : p->col_offset = col_offset;
3096 : 3427125 : p->end_lineno = end_lineno;
3097 : 3427125 : p->end_col_offset = end_col_offset;
3098 : 3427125 : return p;
3099 : : }
3100 : :
3101 : : expr_ty
3102 : 924067 : _PyAST_Subscript(expr_ty value, expr_ty slice, expr_context_ty ctx, int lineno,
3103 : : int col_offset, int end_lineno, int end_col_offset, PyArena
3104 : : *arena)
3105 : : {
3106 : : expr_ty p;
3107 [ - + ]: 924067 : if (!value) {
3108 : 0 : PyErr_SetString(PyExc_ValueError,
3109 : : "field 'value' is required for Subscript");
3110 : 0 : return NULL;
3111 : : }
3112 [ - + ]: 924067 : if (!slice) {
3113 : 0 : PyErr_SetString(PyExc_ValueError,
3114 : : "field 'slice' is required for Subscript");
3115 : 0 : return NULL;
3116 : : }
3117 [ - + ]: 924067 : if (!ctx) {
3118 : 0 : PyErr_SetString(PyExc_ValueError,
3119 : : "field 'ctx' is required for Subscript");
3120 : 0 : return NULL;
3121 : : }
3122 : 924067 : p = (expr_ty)_PyArena_Malloc(arena, sizeof(*p));
3123 [ - + ]: 924067 : if (!p)
3124 : 0 : return NULL;
3125 : 924067 : p->kind = Subscript_kind;
3126 : 924067 : p->v.Subscript.value = value;
3127 : 924067 : p->v.Subscript.slice = slice;
3128 : 924067 : p->v.Subscript.ctx = ctx;
3129 : 924067 : p->lineno = lineno;
3130 : 924067 : p->col_offset = col_offset;
3131 : 924067 : p->end_lineno = end_lineno;
3132 : 924067 : p->end_col_offset = end_col_offset;
3133 : 924067 : return p;
3134 : : }
3135 : :
3136 : : expr_ty
3137 : 16298 : _PyAST_Starred(expr_ty value, expr_context_ty ctx, int lineno, int col_offset,
3138 : : int end_lineno, int end_col_offset, PyArena *arena)
3139 : : {
3140 : : expr_ty p;
3141 [ - + ]: 16298 : if (!value) {
3142 : 0 : PyErr_SetString(PyExc_ValueError,
3143 : : "field 'value' is required for Starred");
3144 : 0 : return NULL;
3145 : : }
3146 [ - + ]: 16298 : if (!ctx) {
3147 : 0 : PyErr_SetString(PyExc_ValueError,
3148 : : "field 'ctx' is required for Starred");
3149 : 0 : return NULL;
3150 : : }
3151 : 16298 : p = (expr_ty)_PyArena_Malloc(arena, sizeof(*p));
3152 [ - + ]: 16298 : if (!p)
3153 : 0 : return NULL;
3154 : 16298 : p->kind = Starred_kind;
3155 : 16298 : p->v.Starred.value = value;
3156 : 16298 : p->v.Starred.ctx = ctx;
3157 : 16298 : p->lineno = lineno;
3158 : 16298 : p->col_offset = col_offset;
3159 : 16298 : p->end_lineno = end_lineno;
3160 : 16298 : p->end_col_offset = end_col_offset;
3161 : 16298 : return p;
3162 : : }
3163 : :
3164 : : expr_ty
3165 : 36912895 : _PyAST_Name(identifier id, expr_context_ty ctx, int lineno, int col_offset, int
3166 : : end_lineno, int end_col_offset, PyArena *arena)
3167 : : {
3168 : : expr_ty p;
3169 [ - + ]: 36912895 : if (!id) {
3170 : 0 : PyErr_SetString(PyExc_ValueError,
3171 : : "field 'id' is required for Name");
3172 : 0 : return NULL;
3173 : : }
3174 [ - + ]: 36912895 : if (!ctx) {
3175 : 0 : PyErr_SetString(PyExc_ValueError,
3176 : : "field 'ctx' is required for Name");
3177 : 0 : return NULL;
3178 : : }
3179 : 36912895 : p = (expr_ty)_PyArena_Malloc(arena, sizeof(*p));
3180 [ - + ]: 36912895 : if (!p)
3181 : 0 : return NULL;
3182 : 36912895 : p->kind = Name_kind;
3183 : 36912895 : p->v.Name.id = id;
3184 : 36912895 : p->v.Name.ctx = ctx;
3185 : 36912895 : p->lineno = lineno;
3186 : 36912895 : p->col_offset = col_offset;
3187 : 36912895 : p->end_lineno = end_lineno;
3188 : 36912895 : p->end_col_offset = end_col_offset;
3189 : 36912895 : return p;
3190 : : }
3191 : :
3192 : : expr_ty
3193 : 253832 : _PyAST_List(asdl_expr_seq * elts, expr_context_ty ctx, int lineno, int
3194 : : col_offset, int end_lineno, int end_col_offset, PyArena *arena)
3195 : : {
3196 : : expr_ty p;
3197 [ - + ]: 253832 : if (!ctx) {
3198 : 0 : PyErr_SetString(PyExc_ValueError,
3199 : : "field 'ctx' is required for List");
3200 : 0 : return NULL;
3201 : : }
3202 : 253832 : p = (expr_ty)_PyArena_Malloc(arena, sizeof(*p));
3203 [ - + ]: 253832 : if (!p)
3204 : 0 : return NULL;
3205 : 253832 : p->kind = List_kind;
3206 : 253832 : p->v.List.elts = elts;
3207 : 253832 : p->v.List.ctx = ctx;
3208 : 253832 : p->lineno = lineno;
3209 : 253832 : p->col_offset = col_offset;
3210 : 253832 : p->end_lineno = end_lineno;
3211 : 253832 : p->end_col_offset = end_col_offset;
3212 : 253832 : return p;
3213 : : }
3214 : :
3215 : : expr_ty
3216 : 683780 : _PyAST_Tuple(asdl_expr_seq * elts, expr_context_ty ctx, int lineno, int
3217 : : col_offset, int end_lineno, int end_col_offset, PyArena *arena)
3218 : : {
3219 : : expr_ty p;
3220 [ - + ]: 683780 : if (!ctx) {
3221 : 0 : PyErr_SetString(PyExc_ValueError,
3222 : : "field 'ctx' is required for Tuple");
3223 : 0 : return NULL;
3224 : : }
3225 : 683780 : p = (expr_ty)_PyArena_Malloc(arena, sizeof(*p));
3226 [ - + ]: 683780 : if (!p)
3227 : 0 : return NULL;
3228 : 683780 : p->kind = Tuple_kind;
3229 : 683780 : p->v.Tuple.elts = elts;
3230 : 683780 : p->v.Tuple.ctx = ctx;
3231 : 683780 : p->lineno = lineno;
3232 : 683780 : p->col_offset = col_offset;
3233 : 683780 : p->end_lineno = end_lineno;
3234 : 683780 : p->end_col_offset = end_col_offset;
3235 : 683780 : return p;
3236 : : }
3237 : :
3238 : : expr_ty
3239 : 69821 : _PyAST_Slice(expr_ty lower, expr_ty upper, expr_ty step, int lineno, int
3240 : : col_offset, int end_lineno, int end_col_offset, PyArena *arena)
3241 : : {
3242 : : expr_ty p;
3243 : 69821 : p = (expr_ty)_PyArena_Malloc(arena, sizeof(*p));
3244 [ - + ]: 69821 : if (!p)
3245 : 0 : return NULL;
3246 : 69821 : p->kind = Slice_kind;
3247 : 69821 : p->v.Slice.lower = lower;
3248 : 69821 : p->v.Slice.upper = upper;
3249 : 69821 : p->v.Slice.step = step;
3250 : 69821 : p->lineno = lineno;
3251 : 69821 : p->col_offset = col_offset;
3252 : 69821 : p->end_lineno = end_lineno;
3253 : 69821 : p->end_col_offset = end_col_offset;
3254 : 69821 : return p;
3255 : : }
3256 : :
3257 : : comprehension_ty
3258 : 52215 : _PyAST_comprehension(expr_ty target, expr_ty iter, asdl_expr_seq * ifs, int
3259 : : is_async, PyArena *arena)
3260 : : {
3261 : : comprehension_ty p;
3262 [ - + ]: 52215 : if (!target) {
3263 : 0 : PyErr_SetString(PyExc_ValueError,
3264 : : "field 'target' is required for comprehension");
3265 : 0 : return NULL;
3266 : : }
3267 [ - + ]: 52215 : if (!iter) {
3268 : 0 : PyErr_SetString(PyExc_ValueError,
3269 : : "field 'iter' is required for comprehension");
3270 : 0 : return NULL;
3271 : : }
3272 : 52215 : p = (comprehension_ty)_PyArena_Malloc(arena, sizeof(*p));
3273 [ - + ]: 52215 : if (!p)
3274 : 0 : return NULL;
3275 : 52215 : p->target = target;
3276 : 52215 : p->iter = iter;
3277 : 52215 : p->ifs = ifs;
3278 : 52215 : p->is_async = is_async;
3279 : 52215 : return p;
3280 : : }
3281 : :
3282 : : excepthandler_ty
3283 : 45696 : _PyAST_ExceptHandler(expr_ty type, identifier name, asdl_stmt_seq * body, int
3284 : : lineno, int col_offset, int end_lineno, int
3285 : : end_col_offset, PyArena *arena)
3286 : : {
3287 : : excepthandler_ty p;
3288 : 45696 : p = (excepthandler_ty)_PyArena_Malloc(arena, sizeof(*p));
3289 [ - + ]: 45696 : if (!p)
3290 : 0 : return NULL;
3291 : 45696 : p->kind = ExceptHandler_kind;
3292 : 45696 : p->v.ExceptHandler.type = type;
3293 : 45696 : p->v.ExceptHandler.name = name;
3294 : 45696 : p->v.ExceptHandler.body = body;
3295 : 45696 : p->lineno = lineno;
3296 : 45696 : p->col_offset = col_offset;
3297 : 45696 : p->end_lineno = end_lineno;
3298 : 45696 : p->end_col_offset = end_col_offset;
3299 : 45696 : return p;
3300 : : }
3301 : :
3302 : : arguments_ty
3303 : 385107 : _PyAST_arguments(asdl_arg_seq * posonlyargs, asdl_arg_seq * args, arg_ty
3304 : : vararg, asdl_arg_seq * kwonlyargs, asdl_expr_seq *
3305 : : kw_defaults, arg_ty kwarg, asdl_expr_seq * defaults, PyArena
3306 : : *arena)
3307 : : {
3308 : : arguments_ty p;
3309 : 385107 : p = (arguments_ty)_PyArena_Malloc(arena, sizeof(*p));
3310 [ - + ]: 385107 : if (!p)
3311 : 0 : return NULL;
3312 : 385107 : p->posonlyargs = posonlyargs;
3313 : 385107 : p->args = args;
3314 : 385107 : p->vararg = vararg;
3315 : 385107 : p->kwonlyargs = kwonlyargs;
3316 : 385107 : p->kw_defaults = kw_defaults;
3317 : 385107 : p->kwarg = kwarg;
3318 : 385107 : p->defaults = defaults;
3319 : 385107 : return p;
3320 : : }
3321 : :
3322 : : arg_ty
3323 : 5436349 : _PyAST_arg(identifier arg, expr_ty annotation, string type_comment, int lineno,
3324 : : int col_offset, int end_lineno, int end_col_offset, PyArena *arena)
3325 : : {
3326 : : arg_ty p;
3327 [ - + ]: 5436349 : if (!arg) {
3328 : 0 : PyErr_SetString(PyExc_ValueError,
3329 : : "field 'arg' is required for arg");
3330 : 0 : return NULL;
3331 : : }
3332 : 5436349 : p = (arg_ty)_PyArena_Malloc(arena, sizeof(*p));
3333 [ - + ]: 5436349 : if (!p)
3334 : 0 : return NULL;
3335 : 5436349 : p->arg = arg;
3336 : 5436349 : p->annotation = annotation;
3337 : 5436349 : p->type_comment = type_comment;
3338 : 5436349 : p->lineno = lineno;
3339 : 5436349 : p->col_offset = col_offset;
3340 : 5436349 : p->end_lineno = end_lineno;
3341 : 5436349 : p->end_col_offset = end_col_offset;
3342 : 5436349 : return p;
3343 : : }
3344 : :
3345 : : keyword_ty
3346 : 359673 : _PyAST_keyword(identifier arg, expr_ty value, int lineno, int col_offset, int
3347 : : end_lineno, int end_col_offset, PyArena *arena)
3348 : : {
3349 : : keyword_ty p;
3350 [ - + ]: 359673 : if (!value) {
3351 : 0 : PyErr_SetString(PyExc_ValueError,
3352 : : "field 'value' is required for keyword");
3353 : 0 : return NULL;
3354 : : }
3355 : 359673 : p = (keyword_ty)_PyArena_Malloc(arena, sizeof(*p));
3356 [ - + ]: 359673 : if (!p)
3357 : 0 : return NULL;
3358 : 359673 : p->arg = arg;
3359 : 359673 : p->value = value;
3360 : 359673 : p->lineno = lineno;
3361 : 359673 : p->col_offset = col_offset;
3362 : 359673 : p->end_lineno = end_lineno;
3363 : 359673 : p->end_col_offset = end_col_offset;
3364 : 359673 : return p;
3365 : : }
3366 : :
3367 : : alias_ty
3368 : 125663 : _PyAST_alias(identifier name, identifier asname, int lineno, int col_offset,
3369 : : int end_lineno, int end_col_offset, PyArena *arena)
3370 : : {
3371 : : alias_ty p;
3372 [ - + ]: 125663 : if (!name) {
3373 : 0 : PyErr_SetString(PyExc_ValueError,
3374 : : "field 'name' is required for alias");
3375 : 0 : return NULL;
3376 : : }
3377 : 125663 : p = (alias_ty)_PyArena_Malloc(arena, sizeof(*p));
3378 [ - + ]: 125663 : if (!p)
3379 : 0 : return NULL;
3380 : 125663 : p->name = name;
3381 : 125663 : p->asname = asname;
3382 : 125663 : p->lineno = lineno;
3383 : 125663 : p->col_offset = col_offset;
3384 : 125663 : p->end_lineno = end_lineno;
3385 : 125663 : p->end_col_offset = end_col_offset;
3386 : 125663 : return p;
3387 : : }
3388 : :
3389 : : withitem_ty
3390 : 40249 : _PyAST_withitem(expr_ty context_expr, expr_ty optional_vars, PyArena *arena)
3391 : : {
3392 : : withitem_ty p;
3393 [ - + ]: 40249 : if (!context_expr) {
3394 : 0 : PyErr_SetString(PyExc_ValueError,
3395 : : "field 'context_expr' is required for withitem");
3396 : 0 : return NULL;
3397 : : }
3398 : 40249 : p = (withitem_ty)_PyArena_Malloc(arena, sizeof(*p));
3399 [ - + ]: 40249 : if (!p)
3400 : 0 : return NULL;
3401 : 40249 : p->context_expr = context_expr;
3402 : 40249 : p->optional_vars = optional_vars;
3403 : 40249 : return p;
3404 : : }
3405 : :
3406 : : match_case_ty
3407 : 1817 : _PyAST_match_case(pattern_ty pattern, expr_ty guard, asdl_stmt_seq * body,
3408 : : PyArena *arena)
3409 : : {
3410 : : match_case_ty p;
3411 [ - + ]: 1817 : if (!pattern) {
3412 : 0 : PyErr_SetString(PyExc_ValueError,
3413 : : "field 'pattern' is required for match_case");
3414 : 0 : return NULL;
3415 : : }
3416 : 1817 : p = (match_case_ty)_PyArena_Malloc(arena, sizeof(*p));
3417 [ - + ]: 1817 : if (!p)
3418 : 0 : return NULL;
3419 : 1817 : p->pattern = pattern;
3420 : 1817 : p->guard = guard;
3421 : 1817 : p->body = body;
3422 : 1817 : return p;
3423 : : }
3424 : :
3425 : : pattern_ty
3426 : 1565 : _PyAST_MatchValue(expr_ty value, int lineno, int col_offset, int end_lineno,
3427 : : int end_col_offset, PyArena *arena)
3428 : : {
3429 : : pattern_ty p;
3430 [ - + ]: 1565 : if (!value) {
3431 : 0 : PyErr_SetString(PyExc_ValueError,
3432 : : "field 'value' is required for MatchValue");
3433 : 0 : return NULL;
3434 : : }
3435 : 1565 : p = (pattern_ty)_PyArena_Malloc(arena, sizeof(*p));
3436 [ - + ]: 1565 : if (!p)
3437 : 0 : return NULL;
3438 : 1565 : p->kind = MatchValue_kind;
3439 : 1565 : p->v.MatchValue.value = value;
3440 : 1565 : p->lineno = lineno;
3441 : 1565 : p->col_offset = col_offset;
3442 : 1565 : p->end_lineno = end_lineno;
3443 : 1565 : p->end_col_offset = end_col_offset;
3444 : 1565 : return p;
3445 : : }
3446 : :
3447 : : pattern_ty
3448 : 68 : _PyAST_MatchSingleton(constant value, int lineno, int col_offset, int
3449 : : end_lineno, int end_col_offset, PyArena *arena)
3450 : : {
3451 : : pattern_ty p;
3452 [ - + ]: 68 : if (!value) {
3453 : 0 : PyErr_SetString(PyExc_ValueError,
3454 : : "field 'value' is required for MatchSingleton");
3455 : 0 : return NULL;
3456 : : }
3457 : 68 : p = (pattern_ty)_PyArena_Malloc(arena, sizeof(*p));
3458 [ - + ]: 68 : if (!p)
3459 : 0 : return NULL;
3460 : 68 : p->kind = MatchSingleton_kind;
3461 : 68 : p->v.MatchSingleton.value = value;
3462 : 68 : p->lineno = lineno;
3463 : 68 : p->col_offset = col_offset;
3464 : 68 : p->end_lineno = end_lineno;
3465 : 68 : p->end_col_offset = end_col_offset;
3466 : 68 : return p;
3467 : : }
3468 : :
3469 : : pattern_ty
3470 : 768 : _PyAST_MatchSequence(asdl_pattern_seq * patterns, int lineno, int col_offset,
3471 : : int end_lineno, int end_col_offset, PyArena *arena)
3472 : : {
3473 : : pattern_ty p;
3474 : 768 : p = (pattern_ty)_PyArena_Malloc(arena, sizeof(*p));
3475 [ - + ]: 768 : if (!p)
3476 : 0 : return NULL;
3477 : 768 : p->kind = MatchSequence_kind;
3478 : 768 : p->v.MatchSequence.patterns = patterns;
3479 : 768 : p->lineno = lineno;
3480 : 768 : p->col_offset = col_offset;
3481 : 768 : p->end_lineno = end_lineno;
3482 : 768 : p->end_col_offset = end_col_offset;
3483 : 768 : return p;
3484 : : }
3485 : :
3486 : : pattern_ty
3487 : 433 : _PyAST_MatchMapping(asdl_expr_seq * keys, asdl_pattern_seq * patterns,
3488 : : identifier rest, int lineno, int col_offset, int
3489 : : end_lineno, int end_col_offset, PyArena *arena)
3490 : : {
3491 : : pattern_ty p;
3492 : 433 : p = (pattern_ty)_PyArena_Malloc(arena, sizeof(*p));
3493 [ - + ]: 433 : if (!p)
3494 : 0 : return NULL;
3495 : 433 : p->kind = MatchMapping_kind;
3496 : 433 : p->v.MatchMapping.keys = keys;
3497 : 433 : p->v.MatchMapping.patterns = patterns;
3498 : 433 : p->v.MatchMapping.rest = rest;
3499 : 433 : p->lineno = lineno;
3500 : 433 : p->col_offset = col_offset;
3501 : 433 : p->end_lineno = end_lineno;
3502 : 433 : p->end_col_offset = end_col_offset;
3503 : 433 : return p;
3504 : : }
3505 : :
3506 : : pattern_ty
3507 : 302 : _PyAST_MatchClass(expr_ty cls, asdl_pattern_seq * patterns, asdl_identifier_seq
3508 : : * kwd_attrs, asdl_pattern_seq * kwd_patterns, int lineno, int
3509 : : col_offset, int end_lineno, int end_col_offset, PyArena
3510 : : *arena)
3511 : : {
3512 : : pattern_ty p;
3513 [ - + ]: 302 : if (!cls) {
3514 : 0 : PyErr_SetString(PyExc_ValueError,
3515 : : "field 'cls' is required for MatchClass");
3516 : 0 : return NULL;
3517 : : }
3518 : 302 : p = (pattern_ty)_PyArena_Malloc(arena, sizeof(*p));
3519 [ - + ]: 302 : if (!p)
3520 : 0 : return NULL;
3521 : 302 : p->kind = MatchClass_kind;
3522 : 302 : p->v.MatchClass.cls = cls;
3523 : 302 : p->v.MatchClass.patterns = patterns;
3524 : 302 : p->v.MatchClass.kwd_attrs = kwd_attrs;
3525 : 302 : p->v.MatchClass.kwd_patterns = kwd_patterns;
3526 : 302 : p->lineno = lineno;
3527 : 302 : p->col_offset = col_offset;
3528 : 302 : p->end_lineno = end_lineno;
3529 : 302 : p->end_col_offset = end_col_offset;
3530 : 302 : return p;
3531 : : }
3532 : :
3533 : : pattern_ty
3534 : 180 : _PyAST_MatchStar(identifier name, int lineno, int col_offset, int end_lineno,
3535 : : int end_col_offset, PyArena *arena)
3536 : : {
3537 : : pattern_ty p;
3538 : 180 : p = (pattern_ty)_PyArena_Malloc(arena, sizeof(*p));
3539 [ - + ]: 180 : if (!p)
3540 : 0 : return NULL;
3541 : 180 : p->kind = MatchStar_kind;
3542 : 180 : p->v.MatchStar.name = name;
3543 : 180 : p->lineno = lineno;
3544 : 180 : p->col_offset = col_offset;
3545 : 180 : p->end_lineno = end_lineno;
3546 : 180 : p->end_col_offset = end_col_offset;
3547 : 180 : return p;
3548 : : }
3549 : :
3550 : : pattern_ty
3551 : 1536 : _PyAST_MatchAs(pattern_ty pattern, identifier name, int lineno, int col_offset,
3552 : : int end_lineno, int end_col_offset, PyArena *arena)
3553 : : {
3554 : : pattern_ty p;
3555 : 1536 : p = (pattern_ty)_PyArena_Malloc(arena, sizeof(*p));
3556 [ - + ]: 1536 : if (!p)
3557 : 0 : return NULL;
3558 : 1536 : p->kind = MatchAs_kind;
3559 : 1536 : p->v.MatchAs.pattern = pattern;
3560 : 1536 : p->v.MatchAs.name = name;
3561 : 1536 : p->lineno = lineno;
3562 : 1536 : p->col_offset = col_offset;
3563 : 1536 : p->end_lineno = end_lineno;
3564 : 1536 : p->end_col_offset = end_col_offset;
3565 : 1536 : return p;
3566 : : }
3567 : :
3568 : : pattern_ty
3569 : 693 : _PyAST_MatchOr(asdl_pattern_seq * patterns, int lineno, int col_offset, int
3570 : : end_lineno, int end_col_offset, PyArena *arena)
3571 : : {
3572 : : pattern_ty p;
3573 : 693 : p = (pattern_ty)_PyArena_Malloc(arena, sizeof(*p));
3574 [ - + ]: 693 : if (!p)
3575 : 0 : return NULL;
3576 : 693 : p->kind = MatchOr_kind;
3577 : 693 : p->v.MatchOr.patterns = patterns;
3578 : 693 : p->lineno = lineno;
3579 : 693 : p->col_offset = col_offset;
3580 : 693 : p->end_lineno = end_lineno;
3581 : 693 : p->end_col_offset = end_col_offset;
3582 : 693 : return p;
3583 : : }
3584 : :
3585 : : type_ignore_ty
3586 : 74 : _PyAST_TypeIgnore(int lineno, string tag, PyArena *arena)
3587 : : {
3588 : : type_ignore_ty p;
3589 [ - + ]: 74 : if (!tag) {
3590 : 0 : PyErr_SetString(PyExc_ValueError,
3591 : : "field 'tag' is required for TypeIgnore");
3592 : 0 : return NULL;
3593 : : }
3594 : 74 : p = (type_ignore_ty)_PyArena_Malloc(arena, sizeof(*p));
3595 [ - + ]: 74 : if (!p)
3596 : 0 : return NULL;
3597 : 74 : p->kind = TypeIgnore_kind;
3598 : 74 : p->v.TypeIgnore.lineno = lineno;
3599 : 74 : p->v.TypeIgnore.tag = tag;
3600 : 74 : return p;
3601 : : }
3602 : :
3603 : :
3604 : : PyObject*
3605 : 10350 : ast2obj_mod(struct ast_state *state, void* _o)
3606 : : {
3607 : 10350 : mod_ty o = (mod_ty)_o;
3608 : 10350 : PyObject *result = NULL, *value = NULL;
3609 : : PyTypeObject *tp;
3610 [ - + ]: 10350 : if (!o) {
3611 : 0 : Py_RETURN_NONE;
3612 : : }
3613 [ + + + + : 10350 : switch (o->kind) {
- ]
3614 : 9673 : case Module_kind:
3615 : 9673 : tp = (PyTypeObject *)state->Module_type;
3616 : 9673 : result = PyType_GenericNew(tp, NULL, NULL);
3617 [ - + ]: 9673 : if (!result) goto failed;
3618 : 9673 : value = ast2obj_list(state, (asdl_seq*)o->v.Module.body, ast2obj_stmt);
3619 [ - + ]: 9673 : if (!value) goto failed;
3620 [ - + ]: 9673 : if (PyObject_SetAttr(result, state->body, value) == -1)
3621 : 0 : goto failed;
3622 : 9673 : Py_DECREF(value);
3623 : 9673 : value = ast2obj_list(state, (asdl_seq*)o->v.Module.type_ignores,
3624 : : ast2obj_type_ignore);
3625 [ - + ]: 9673 : if (!value) goto failed;
3626 [ - + ]: 9673 : if (PyObject_SetAttr(result, state->type_ignores, value) == -1)
3627 : 0 : goto failed;
3628 : 9673 : Py_DECREF(value);
3629 : 9673 : break;
3630 : 1 : case Interactive_kind:
3631 : 1 : tp = (PyTypeObject *)state->Interactive_type;
3632 : 1 : result = PyType_GenericNew(tp, NULL, NULL);
3633 [ - + ]: 1 : if (!result) goto failed;
3634 : 1 : value = ast2obj_list(state, (asdl_seq*)o->v.Interactive.body,
3635 : : ast2obj_stmt);
3636 [ - + ]: 1 : if (!value) goto failed;
3637 [ - + ]: 1 : if (PyObject_SetAttr(result, state->body, value) == -1)
3638 : 0 : goto failed;
3639 : 1 : Py_DECREF(value);
3640 : 1 : break;
3641 : 664 : case Expression_kind:
3642 : 664 : tp = (PyTypeObject *)state->Expression_type;
3643 : 664 : result = PyType_GenericNew(tp, NULL, NULL);
3644 [ - + ]: 664 : if (!result) goto failed;
3645 : 664 : value = ast2obj_expr(state, o->v.Expression.body);
3646 [ - + ]: 664 : if (!value) goto failed;
3647 [ - + ]: 664 : if (PyObject_SetAttr(result, state->body, value) == -1)
3648 : 0 : goto failed;
3649 : 664 : Py_DECREF(value);
3650 : 664 : break;
3651 : 12 : case FunctionType_kind:
3652 : 12 : tp = (PyTypeObject *)state->FunctionType_type;
3653 : 12 : result = PyType_GenericNew(tp, NULL, NULL);
3654 [ - + ]: 12 : if (!result) goto failed;
3655 : 12 : value = ast2obj_list(state, (asdl_seq*)o->v.FunctionType.argtypes,
3656 : : ast2obj_expr);
3657 [ - + ]: 12 : if (!value) goto failed;
3658 [ - + ]: 12 : if (PyObject_SetAttr(result, state->argtypes, value) == -1)
3659 : 0 : goto failed;
3660 : 12 : Py_DECREF(value);
3661 : 12 : value = ast2obj_expr(state, o->v.FunctionType.returns);
3662 [ - + ]: 12 : if (!value) goto failed;
3663 [ - + ]: 12 : if (PyObject_SetAttr(result, state->returns, value) == -1)
3664 : 0 : goto failed;
3665 : 12 : Py_DECREF(value);
3666 : 12 : break;
3667 : : }
3668 : 10350 : return result;
3669 : 0 : failed:
3670 : 0 : Py_XDECREF(value);
3671 : 0 : Py_XDECREF(result);
3672 : 0 : return NULL;
3673 : : }
3674 : :
3675 : : PyObject*
3676 : 725705 : ast2obj_stmt(struct ast_state *state, void* _o)
3677 : : {
3678 : 725705 : stmt_ty o = (stmt_ty)_o;
3679 : 725705 : PyObject *result = NULL, *value = NULL;
3680 : : PyTypeObject *tp;
3681 [ - + ]: 725705 : if (!o) {
3682 : 0 : Py_RETURN_NONE;
3683 : : }
3684 [ + + + + : 725705 : switch (o->kind) {
+ + + + +
+ + + + +
+ + + + +
+ + + + +
+ + + - ]
3685 : 87722 : case FunctionDef_kind:
3686 : 87722 : tp = (PyTypeObject *)state->FunctionDef_type;
3687 : 87722 : result = PyType_GenericNew(tp, NULL, NULL);
3688 [ - + ]: 87722 : if (!result) goto failed;
3689 : 87722 : value = ast2obj_identifier(state, o->v.FunctionDef.name);
3690 [ - + ]: 87722 : if (!value) goto failed;
3691 [ - + ]: 87722 : if (PyObject_SetAttr(result, state->name, value) == -1)
3692 : 0 : goto failed;
3693 : 87722 : Py_DECREF(value);
3694 : 87722 : value = ast2obj_arguments(state, o->v.FunctionDef.args);
3695 [ - + ]: 87722 : if (!value) goto failed;
3696 [ - + ]: 87722 : if (PyObject_SetAttr(result, state->args, value) == -1)
3697 : 0 : goto failed;
3698 : 87722 : Py_DECREF(value);
3699 : 87722 : value = ast2obj_list(state, (asdl_seq*)o->v.FunctionDef.body,
3700 : : ast2obj_stmt);
3701 [ - + ]: 87722 : if (!value) goto failed;
3702 [ - + ]: 87722 : if (PyObject_SetAttr(result, state->body, value) == -1)
3703 : 0 : goto failed;
3704 : 87722 : Py_DECREF(value);
3705 : 87722 : value = ast2obj_list(state, (asdl_seq*)o->v.FunctionDef.decorator_list,
3706 : : ast2obj_expr);
3707 [ - + ]: 87722 : if (!value) goto failed;
3708 [ - + ]: 87722 : if (PyObject_SetAttr(result, state->decorator_list, value) == -1)
3709 : 0 : goto failed;
3710 : 87722 : Py_DECREF(value);
3711 : 87722 : value = ast2obj_expr(state, o->v.FunctionDef.returns);
3712 [ - + ]: 87722 : if (!value) goto failed;
3713 [ - + ]: 87722 : if (PyObject_SetAttr(result, state->returns, value) == -1)
3714 : 0 : goto failed;
3715 : 87722 : Py_DECREF(value);
3716 : 87722 : value = ast2obj_string(state, o->v.FunctionDef.type_comment);
3717 [ - + ]: 87722 : if (!value) goto failed;
3718 [ - + ]: 87722 : if (PyObject_SetAttr(result, state->type_comment, value) == -1)
3719 : 0 : goto failed;
3720 : 87722 : Py_DECREF(value);
3721 : 87722 : break;
3722 : 1154 : case AsyncFunctionDef_kind:
3723 : 1154 : tp = (PyTypeObject *)state->AsyncFunctionDef_type;
3724 : 1154 : result = PyType_GenericNew(tp, NULL, NULL);
3725 [ - + ]: 1154 : if (!result) goto failed;
3726 : 1154 : value = ast2obj_identifier(state, o->v.AsyncFunctionDef.name);
3727 [ - + ]: 1154 : if (!value) goto failed;
3728 [ - + ]: 1154 : if (PyObject_SetAttr(result, state->name, value) == -1)
3729 : 0 : goto failed;
3730 : 1154 : Py_DECREF(value);
3731 : 1154 : value = ast2obj_arguments(state, o->v.AsyncFunctionDef.args);
3732 [ - + ]: 1154 : if (!value) goto failed;
3733 [ - + ]: 1154 : if (PyObject_SetAttr(result, state->args, value) == -1)
3734 : 0 : goto failed;
3735 : 1154 : Py_DECREF(value);
3736 : 1154 : value = ast2obj_list(state, (asdl_seq*)o->v.AsyncFunctionDef.body,
3737 : : ast2obj_stmt);
3738 [ - + ]: 1154 : if (!value) goto failed;
3739 [ - + ]: 1154 : if (PyObject_SetAttr(result, state->body, value) == -1)
3740 : 0 : goto failed;
3741 : 1154 : Py_DECREF(value);
3742 : 1154 : value = ast2obj_list(state,
3743 : 1154 : (asdl_seq*)o->v.AsyncFunctionDef.decorator_list,
3744 : : ast2obj_expr);
3745 [ - + ]: 1154 : if (!value) goto failed;
3746 [ - + ]: 1154 : if (PyObject_SetAttr(result, state->decorator_list, value) == -1)
3747 : 0 : goto failed;
3748 : 1154 : Py_DECREF(value);
3749 : 1154 : value = ast2obj_expr(state, o->v.AsyncFunctionDef.returns);
3750 [ - + ]: 1154 : if (!value) goto failed;
3751 [ - + ]: 1154 : if (PyObject_SetAttr(result, state->returns, value) == -1)
3752 : 0 : goto failed;
3753 : 1154 : Py_DECREF(value);
3754 : 1154 : value = ast2obj_string(state, o->v.AsyncFunctionDef.type_comment);
3755 [ - + ]: 1154 : if (!value) goto failed;
3756 [ - + ]: 1154 : if (PyObject_SetAttr(result, state->type_comment, value) == -1)
3757 : 0 : goto failed;
3758 : 1154 : Py_DECREF(value);
3759 : 1154 : break;
3760 : 19892 : case ClassDef_kind:
3761 : 19892 : tp = (PyTypeObject *)state->ClassDef_type;
3762 : 19892 : result = PyType_GenericNew(tp, NULL, NULL);
3763 [ - + ]: 19892 : if (!result) goto failed;
3764 : 19892 : value = ast2obj_identifier(state, o->v.ClassDef.name);
3765 [ - + ]: 19892 : if (!value) goto failed;
3766 [ - + ]: 19892 : if (PyObject_SetAttr(result, state->name, value) == -1)
3767 : 0 : goto failed;
3768 : 19892 : Py_DECREF(value);
3769 : 19892 : value = ast2obj_list(state, (asdl_seq*)o->v.ClassDef.bases,
3770 : : ast2obj_expr);
3771 [ - + ]: 19892 : if (!value) goto failed;
3772 [ - + ]: 19892 : if (PyObject_SetAttr(result, state->bases, value) == -1)
3773 : 0 : goto failed;
3774 : 19892 : Py_DECREF(value);
3775 : 19892 : value = ast2obj_list(state, (asdl_seq*)o->v.ClassDef.keywords,
3776 : : ast2obj_keyword);
3777 [ - + ]: 19892 : if (!value) goto failed;
3778 [ - + ]: 19892 : if (PyObject_SetAttr(result, state->keywords, value) == -1)
3779 : 0 : goto failed;
3780 : 19892 : Py_DECREF(value);
3781 : 19892 : value = ast2obj_list(state, (asdl_seq*)o->v.ClassDef.body,
3782 : : ast2obj_stmt);
3783 [ - + ]: 19892 : if (!value) goto failed;
3784 [ - + ]: 19892 : if (PyObject_SetAttr(result, state->body, value) == -1)
3785 : 0 : goto failed;
3786 : 19892 : Py_DECREF(value);
3787 : 19892 : value = ast2obj_list(state, (asdl_seq*)o->v.ClassDef.decorator_list,
3788 : : ast2obj_expr);
3789 [ - + ]: 19892 : if (!value) goto failed;
3790 [ - + ]: 19892 : if (PyObject_SetAttr(result, state->decorator_list, value) == -1)
3791 : 0 : goto failed;
3792 : 19892 : Py_DECREF(value);
3793 : 19892 : break;
3794 : 35768 : case Return_kind:
3795 : 35768 : tp = (PyTypeObject *)state->Return_type;
3796 : 35768 : result = PyType_GenericNew(tp, NULL, NULL);
3797 [ - + ]: 35768 : if (!result) goto failed;
3798 : 35768 : value = ast2obj_expr(state, o->v.Return.value);
3799 [ - + ]: 35768 : if (!value) goto failed;
3800 [ - + ]: 35768 : if (PyObject_SetAttr(result, state->value, value) == -1)
3801 : 0 : goto failed;
3802 : 35768 : Py_DECREF(value);
3803 : 35768 : break;
3804 : 2646 : case Delete_kind:
3805 : 2646 : tp = (PyTypeObject *)state->Delete_type;
3806 : 2646 : result = PyType_GenericNew(tp, NULL, NULL);
3807 [ - + ]: 2646 : if (!result) goto failed;
3808 : 2646 : value = ast2obj_list(state, (asdl_seq*)o->v.Delete.targets,
3809 : : ast2obj_expr);
3810 [ - + ]: 2646 : if (!value) goto failed;
3811 [ - + ]: 2646 : if (PyObject_SetAttr(result, state->targets, value) == -1)
3812 : 0 : goto failed;
3813 : 2646 : Py_DECREF(value);
3814 : 2646 : break;
3815 : 192620 : case Assign_kind:
3816 : 192620 : tp = (PyTypeObject *)state->Assign_type;
3817 : 192620 : result = PyType_GenericNew(tp, NULL, NULL);
3818 [ - + ]: 192620 : if (!result) goto failed;
3819 : 192620 : value = ast2obj_list(state, (asdl_seq*)o->v.Assign.targets,
3820 : : ast2obj_expr);
3821 [ - + ]: 192620 : if (!value) goto failed;
3822 [ - + ]: 192620 : if (PyObject_SetAttr(result, state->targets, value) == -1)
3823 : 0 : goto failed;
3824 : 192620 : Py_DECREF(value);
3825 : 192620 : value = ast2obj_expr(state, o->v.Assign.value);
3826 [ - + ]: 192620 : if (!value) goto failed;
3827 [ - + ]: 192620 : if (PyObject_SetAttr(result, state->value, value) == -1)
3828 : 0 : goto failed;
3829 : 192620 : Py_DECREF(value);
3830 : 192620 : value = ast2obj_string(state, o->v.Assign.type_comment);
3831 [ - + ]: 192620 : if (!value) goto failed;
3832 [ - + ]: 192620 : if (PyObject_SetAttr(result, state->type_comment, value) == -1)
3833 : 0 : goto failed;
3834 : 192620 : Py_DECREF(value);
3835 : 192620 : break;
3836 : 5049 : case AugAssign_kind:
3837 : 5049 : tp = (PyTypeObject *)state->AugAssign_type;
3838 : 5049 : result = PyType_GenericNew(tp, NULL, NULL);
3839 [ - + ]: 5049 : if (!result) goto failed;
3840 : 5049 : value = ast2obj_expr(state, o->v.AugAssign.target);
3841 [ - + ]: 5049 : if (!value) goto failed;
3842 [ - + ]: 5049 : if (PyObject_SetAttr(result, state->target, value) == -1)
3843 : 0 : goto failed;
3844 : 5049 : Py_DECREF(value);
3845 : 5049 : value = ast2obj_operator(state, o->v.AugAssign.op);
3846 [ - + ]: 5049 : if (!value) goto failed;
3847 [ - + ]: 5049 : if (PyObject_SetAttr(result, state->op, value) == -1)
3848 : 0 : goto failed;
3849 : 5049 : Py_DECREF(value);
3850 : 5049 : value = ast2obj_expr(state, o->v.AugAssign.value);
3851 [ - + ]: 5049 : if (!value) goto failed;
3852 [ - + ]: 5049 : if (PyObject_SetAttr(result, state->value, value) == -1)
3853 : 0 : goto failed;
3854 : 5049 : Py_DECREF(value);
3855 : 5049 : break;
3856 : 1614 : case AnnAssign_kind:
3857 : 1614 : tp = (PyTypeObject *)state->AnnAssign_type;
3858 : 1614 : result = PyType_GenericNew(tp, NULL, NULL);
3859 [ - + ]: 1614 : if (!result) goto failed;
3860 : 1614 : value = ast2obj_expr(state, o->v.AnnAssign.target);
3861 [ - + ]: 1614 : if (!value) goto failed;
3862 [ - + ]: 1614 : if (PyObject_SetAttr(result, state->target, value) == -1)
3863 : 0 : goto failed;
3864 : 1614 : Py_DECREF(value);
3865 : 1614 : value = ast2obj_expr(state, o->v.AnnAssign.annotation);
3866 [ - + ]: 1614 : if (!value) goto failed;
3867 [ - + ]: 1614 : if (PyObject_SetAttr(result, state->annotation, value) == -1)
3868 : 0 : goto failed;
3869 : 1614 : Py_DECREF(value);
3870 : 1614 : value = ast2obj_expr(state, o->v.AnnAssign.value);
3871 [ - + ]: 1614 : if (!value) goto failed;
3872 [ - + ]: 1614 : if (PyObject_SetAttr(result, state->value, value) == -1)
3873 : 0 : goto failed;
3874 : 1614 : Py_DECREF(value);
3875 : 1614 : value = ast2obj_int(state, o->v.AnnAssign.simple);
3876 [ - + ]: 1614 : if (!value) goto failed;
3877 [ - + ]: 1614 : if (PyObject_SetAttr(result, state->simple, value) == -1)
3878 : 0 : goto failed;
3879 : 1614 : Py_DECREF(value);
3880 : 1614 : break;
3881 : 16558 : case For_kind:
3882 : 16558 : tp = (PyTypeObject *)state->For_type;
3883 : 16558 : result = PyType_GenericNew(tp, NULL, NULL);
3884 [ - + ]: 16558 : if (!result) goto failed;
3885 : 16558 : value = ast2obj_expr(state, o->v.For.target);
3886 [ - + ]: 16558 : if (!value) goto failed;
3887 [ - + ]: 16558 : if (PyObject_SetAttr(result, state->target, value) == -1)
3888 : 0 : goto failed;
3889 : 16558 : Py_DECREF(value);
3890 : 16558 : value = ast2obj_expr(state, o->v.For.iter);
3891 [ - + ]: 16558 : if (!value) goto failed;
3892 [ - + ]: 16558 : if (PyObject_SetAttr(result, state->iter, value) == -1)
3893 : 0 : goto failed;
3894 : 16558 : Py_DECREF(value);
3895 : 16558 : value = ast2obj_list(state, (asdl_seq*)o->v.For.body, ast2obj_stmt);
3896 [ - + ]: 16558 : if (!value) goto failed;
3897 [ - + ]: 16558 : if (PyObject_SetAttr(result, state->body, value) == -1)
3898 : 0 : goto failed;
3899 : 16558 : Py_DECREF(value);
3900 : 16558 : value = ast2obj_list(state, (asdl_seq*)o->v.For.orelse, ast2obj_stmt);
3901 [ - + ]: 16558 : if (!value) goto failed;
3902 [ - + ]: 16558 : if (PyObject_SetAttr(result, state->orelse, value) == -1)
3903 : 0 : goto failed;
3904 : 16558 : Py_DECREF(value);
3905 : 16558 : value = ast2obj_string(state, o->v.For.type_comment);
3906 [ - + ]: 16558 : if (!value) goto failed;
3907 [ - + ]: 16558 : if (PyObject_SetAttr(result, state->type_comment, value) == -1)
3908 : 0 : goto failed;
3909 : 16558 : Py_DECREF(value);
3910 : 16558 : break;
3911 : 115 : case AsyncFor_kind:
3912 : 115 : tp = (PyTypeObject *)state->AsyncFor_type;
3913 : 115 : result = PyType_GenericNew(tp, NULL, NULL);
3914 [ - + ]: 115 : if (!result) goto failed;
3915 : 115 : value = ast2obj_expr(state, o->v.AsyncFor.target);
3916 [ - + ]: 115 : if (!value) goto failed;
3917 [ - + ]: 115 : if (PyObject_SetAttr(result, state->target, value) == -1)
3918 : 0 : goto failed;
3919 : 115 : Py_DECREF(value);
3920 : 115 : value = ast2obj_expr(state, o->v.AsyncFor.iter);
3921 [ - + ]: 115 : if (!value) goto failed;
3922 [ - + ]: 115 : if (PyObject_SetAttr(result, state->iter, value) == -1)
3923 : 0 : goto failed;
3924 : 115 : Py_DECREF(value);
3925 : 115 : value = ast2obj_list(state, (asdl_seq*)o->v.AsyncFor.body,
3926 : : ast2obj_stmt);
3927 [ - + ]: 115 : if (!value) goto failed;
3928 [ - + ]: 115 : if (PyObject_SetAttr(result, state->body, value) == -1)
3929 : 0 : goto failed;
3930 : 115 : Py_DECREF(value);
3931 : 115 : value = ast2obj_list(state, (asdl_seq*)o->v.AsyncFor.orelse,
3932 : : ast2obj_stmt);
3933 [ - + ]: 115 : if (!value) goto failed;
3934 [ - + ]: 115 : if (PyObject_SetAttr(result, state->orelse, value) == -1)
3935 : 0 : goto failed;
3936 : 115 : Py_DECREF(value);
3937 : 115 : value = ast2obj_string(state, o->v.AsyncFor.type_comment);
3938 [ - + ]: 115 : if (!value) goto failed;
3939 [ - + ]: 115 : if (PyObject_SetAttr(result, state->type_comment, value) == -1)
3940 : 0 : goto failed;
3941 : 115 : Py_DECREF(value);
3942 : 115 : break;
3943 : 2216 : case While_kind:
3944 : 2216 : tp = (PyTypeObject *)state->While_type;
3945 : 2216 : result = PyType_GenericNew(tp, NULL, NULL);
3946 [ - + ]: 2216 : if (!result) goto failed;
3947 : 2216 : value = ast2obj_expr(state, o->v.While.test);
3948 [ - + ]: 2216 : if (!value) goto failed;
3949 [ - + ]: 2216 : if (PyObject_SetAttr(result, state->test, value) == -1)
3950 : 0 : goto failed;
3951 : 2216 : Py_DECREF(value);
3952 : 2216 : value = ast2obj_list(state, (asdl_seq*)o->v.While.body, ast2obj_stmt);
3953 [ - + ]: 2216 : if (!value) goto failed;
3954 [ - + ]: 2216 : if (PyObject_SetAttr(result, state->body, value) == -1)
3955 : 0 : goto failed;
3956 : 2216 : Py_DECREF(value);
3957 : 2216 : value = ast2obj_list(state, (asdl_seq*)o->v.While.orelse, ast2obj_stmt);
3958 [ - + ]: 2216 : if (!value) goto failed;
3959 [ - + ]: 2216 : if (PyObject_SetAttr(result, state->orelse, value) == -1)
3960 : 0 : goto failed;
3961 : 2216 : Py_DECREF(value);
3962 : 2216 : break;
3963 : 49297 : case If_kind:
3964 : 49297 : tp = (PyTypeObject *)state->If_type;
3965 : 49297 : result = PyType_GenericNew(tp, NULL, NULL);
3966 [ - + ]: 49297 : if (!result) goto failed;
3967 : 49297 : value = ast2obj_expr(state, o->v.If.test);
3968 [ - + ]: 49297 : if (!value) goto failed;
3969 [ - + ]: 49297 : if (PyObject_SetAttr(result, state->test, value) == -1)
3970 : 0 : goto failed;
3971 : 49297 : Py_DECREF(value);
3972 : 49297 : value = ast2obj_list(state, (asdl_seq*)o->v.If.body, ast2obj_stmt);
3973 [ - + ]: 49297 : if (!value) goto failed;
3974 [ - + ]: 49297 : if (PyObject_SetAttr(result, state->body, value) == -1)
3975 : 0 : goto failed;
3976 : 49297 : Py_DECREF(value);
3977 : 49297 : value = ast2obj_list(state, (asdl_seq*)o->v.If.orelse, ast2obj_stmt);
3978 [ - + ]: 49297 : if (!value) goto failed;
3979 [ - + ]: 49297 : if (PyObject_SetAttr(result, state->orelse, value) == -1)
3980 : 0 : goto failed;
3981 : 49297 : Py_DECREF(value);
3982 : 49297 : break;
3983 : 18361 : case With_kind:
3984 : 18361 : tp = (PyTypeObject *)state->With_type;
3985 : 18361 : result = PyType_GenericNew(tp, NULL, NULL);
3986 [ - + ]: 18361 : if (!result) goto failed;
3987 : 18361 : value = ast2obj_list(state, (asdl_seq*)o->v.With.items,
3988 : : ast2obj_withitem);
3989 [ - + ]: 18361 : if (!value) goto failed;
3990 [ - + ]: 18361 : if (PyObject_SetAttr(result, state->items, value) == -1)
3991 : 0 : goto failed;
3992 : 18361 : Py_DECREF(value);
3993 : 18361 : value = ast2obj_list(state, (asdl_seq*)o->v.With.body, ast2obj_stmt);
3994 [ - + ]: 18361 : if (!value) goto failed;
3995 [ - + ]: 18361 : if (PyObject_SetAttr(result, state->body, value) == -1)
3996 : 0 : goto failed;
3997 : 18361 : Py_DECREF(value);
3998 : 18361 : value = ast2obj_string(state, o->v.With.type_comment);
3999 [ - + ]: 18361 : if (!value) goto failed;
4000 [ - + ]: 18361 : if (PyObject_SetAttr(result, state->type_comment, value) == -1)
4001 : 0 : goto failed;
4002 : 18361 : Py_DECREF(value);
4003 : 18361 : break;
4004 : 155 : case AsyncWith_kind:
4005 : 155 : tp = (PyTypeObject *)state->AsyncWith_type;
4006 : 155 : result = PyType_GenericNew(tp, NULL, NULL);
4007 [ - + ]: 155 : if (!result) goto failed;
4008 : 155 : value = ast2obj_list(state, (asdl_seq*)o->v.AsyncWith.items,
4009 : : ast2obj_withitem);
4010 [ - + ]: 155 : if (!value) goto failed;
4011 [ - + ]: 155 : if (PyObject_SetAttr(result, state->items, value) == -1)
4012 : 0 : goto failed;
4013 : 155 : Py_DECREF(value);
4014 : 155 : value = ast2obj_list(state, (asdl_seq*)o->v.AsyncWith.body,
4015 : : ast2obj_stmt);
4016 [ - + ]: 155 : if (!value) goto failed;
4017 [ - + ]: 155 : if (PyObject_SetAttr(result, state->body, value) == -1)
4018 : 0 : goto failed;
4019 : 155 : Py_DECREF(value);
4020 : 155 : value = ast2obj_string(state, o->v.AsyncWith.type_comment);
4021 [ - + ]: 155 : if (!value) goto failed;
4022 [ - + ]: 155 : if (PyObject_SetAttr(result, state->type_comment, value) == -1)
4023 : 0 : goto failed;
4024 : 155 : Py_DECREF(value);
4025 : 155 : break;
4026 : 544 : case Match_kind:
4027 : 544 : tp = (PyTypeObject *)state->Match_type;
4028 : 544 : result = PyType_GenericNew(tp, NULL, NULL);
4029 [ - + ]: 544 : if (!result) goto failed;
4030 : 544 : value = ast2obj_expr(state, o->v.Match.subject);
4031 [ - + ]: 544 : if (!value) goto failed;
4032 [ - + ]: 544 : if (PyObject_SetAttr(result, state->subject, value) == -1)
4033 : 0 : goto failed;
4034 : 544 : Py_DECREF(value);
4035 : 544 : value = ast2obj_list(state, (asdl_seq*)o->v.Match.cases,
4036 : : ast2obj_match_case);
4037 [ - + ]: 544 : if (!value) goto failed;
4038 [ - + ]: 544 : if (PyObject_SetAttr(result, state->cases, value) == -1)
4039 : 0 : goto failed;
4040 : 544 : Py_DECREF(value);
4041 : 544 : break;
4042 : 10917 : case Raise_kind:
4043 : 10917 : tp = (PyTypeObject *)state->Raise_type;
4044 : 10917 : result = PyType_GenericNew(tp, NULL, NULL);
4045 [ - + ]: 10917 : if (!result) goto failed;
4046 : 10917 : value = ast2obj_expr(state, o->v.Raise.exc);
4047 [ - + ]: 10917 : if (!value) goto failed;
4048 [ - + ]: 10917 : if (PyObject_SetAttr(result, state->exc, value) == -1)
4049 : 0 : goto failed;
4050 : 10917 : Py_DECREF(value);
4051 : 10917 : value = ast2obj_expr(state, o->v.Raise.cause);
4052 [ - + ]: 10917 : if (!value) goto failed;
4053 [ - + ]: 10917 : if (PyObject_SetAttr(result, state->cause, value) == -1)
4054 : 0 : goto failed;
4055 : 10917 : Py_DECREF(value);
4056 : 10917 : break;
4057 : 10766 : case Try_kind:
4058 : 10766 : tp = (PyTypeObject *)state->Try_type;
4059 : 10766 : result = PyType_GenericNew(tp, NULL, NULL);
4060 [ - + ]: 10766 : if (!result) goto failed;
4061 : 10766 : value = ast2obj_list(state, (asdl_seq*)o->v.Try.body, ast2obj_stmt);
4062 [ - + ]: 10766 : if (!value) goto failed;
4063 [ - + ]: 10766 : if (PyObject_SetAttr(result, state->body, value) == -1)
4064 : 0 : goto failed;
4065 : 10766 : Py_DECREF(value);
4066 : 10766 : value = ast2obj_list(state, (asdl_seq*)o->v.Try.handlers,
4067 : : ast2obj_excepthandler);
4068 [ - + ]: 10766 : if (!value) goto failed;
4069 [ - + ]: 10766 : if (PyObject_SetAttr(result, state->handlers, value) == -1)
4070 : 0 : goto failed;
4071 : 10766 : Py_DECREF(value);
4072 : 10766 : value = ast2obj_list(state, (asdl_seq*)o->v.Try.orelse, ast2obj_stmt);
4073 [ - + ]: 10766 : if (!value) goto failed;
4074 [ - + ]: 10766 : if (PyObject_SetAttr(result, state->orelse, value) == -1)
4075 : 0 : goto failed;
4076 : 10766 : Py_DECREF(value);
4077 : 10766 : value = ast2obj_list(state, (asdl_seq*)o->v.Try.finalbody,
4078 : : ast2obj_stmt);
4079 [ - + ]: 10766 : if (!value) goto failed;
4080 [ - + ]: 10766 : if (PyObject_SetAttr(result, state->finalbody, value) == -1)
4081 : 0 : goto failed;
4082 : 10766 : Py_DECREF(value);
4083 : 10766 : break;
4084 : 145 : case TryStar_kind:
4085 : 145 : tp = (PyTypeObject *)state->TryStar_type;
4086 : 145 : result = PyType_GenericNew(tp, NULL, NULL);
4087 [ - + ]: 145 : if (!result) goto failed;
4088 : 145 : value = ast2obj_list(state, (asdl_seq*)o->v.TryStar.body, ast2obj_stmt);
4089 [ - + ]: 145 : if (!value) goto failed;
4090 [ - + ]: 145 : if (PyObject_SetAttr(result, state->body, value) == -1)
4091 : 0 : goto failed;
4092 : 145 : Py_DECREF(value);
4093 : 145 : value = ast2obj_list(state, (asdl_seq*)o->v.TryStar.handlers,
4094 : : ast2obj_excepthandler);
4095 [ - + ]: 145 : if (!value) goto failed;
4096 [ - + ]: 145 : if (PyObject_SetAttr(result, state->handlers, value) == -1)
4097 : 0 : goto failed;
4098 : 145 : Py_DECREF(value);
4099 : 145 : value = ast2obj_list(state, (asdl_seq*)o->v.TryStar.orelse,
4100 : : ast2obj_stmt);
4101 [ - + ]: 145 : if (!value) goto failed;
4102 [ - + ]: 145 : if (PyObject_SetAttr(result, state->orelse, value) == -1)
4103 : 0 : goto failed;
4104 : 145 : Py_DECREF(value);
4105 : 145 : value = ast2obj_list(state, (asdl_seq*)o->v.TryStar.finalbody,
4106 : : ast2obj_stmt);
4107 [ - + ]: 145 : if (!value) goto failed;
4108 [ - + ]: 145 : if (PyObject_SetAttr(result, state->finalbody, value) == -1)
4109 : 0 : goto failed;
4110 : 145 : Py_DECREF(value);
4111 : 145 : break;
4112 : 1560 : case Assert_kind:
4113 : 1560 : tp = (PyTypeObject *)state->Assert_type;
4114 : 1560 : result = PyType_GenericNew(tp, NULL, NULL);
4115 [ - + ]: 1560 : if (!result) goto failed;
4116 : 1560 : value = ast2obj_expr(state, o->v.Assert.test);
4117 [ - + ]: 1560 : if (!value) goto failed;
4118 [ - + ]: 1560 : if (PyObject_SetAttr(result, state->test, value) == -1)
4119 : 0 : goto failed;
4120 : 1560 : Py_DECREF(value);
4121 : 1560 : value = ast2obj_expr(state, o->v.Assert.msg);
4122 [ - + ]: 1560 : if (!value) goto failed;
4123 [ - + ]: 1560 : if (PyObject_SetAttr(result, state->msg, value) == -1)
4124 : 0 : goto failed;
4125 : 1560 : Py_DECREF(value);
4126 : 1560 : break;
4127 : 9657 : case Import_kind:
4128 : 9657 : tp = (PyTypeObject *)state->Import_type;
4129 : 9657 : result = PyType_GenericNew(tp, NULL, NULL);
4130 [ - + ]: 9657 : if (!result) goto failed;
4131 : 9657 : value = ast2obj_list(state, (asdl_seq*)o->v.Import.names,
4132 : : ast2obj_alias);
4133 [ - + ]: 9657 : if (!value) goto failed;
4134 [ - + ]: 9657 : if (PyObject_SetAttr(result, state->names, value) == -1)
4135 : 0 : goto failed;
4136 : 9657 : Py_DECREF(value);
4137 : 9657 : break;
4138 : 4806 : case ImportFrom_kind:
4139 : 4806 : tp = (PyTypeObject *)state->ImportFrom_type;
4140 : 4806 : result = PyType_GenericNew(tp, NULL, NULL);
4141 [ - + ]: 4806 : if (!result) goto failed;
4142 : 4806 : value = ast2obj_identifier(state, o->v.ImportFrom.module);
4143 [ - + ]: 4806 : if (!value) goto failed;
4144 [ - + ]: 4806 : if (PyObject_SetAttr(result, state->module, value) == -1)
4145 : 0 : goto failed;
4146 : 4806 : Py_DECREF(value);
4147 : 4806 : value = ast2obj_list(state, (asdl_seq*)o->v.ImportFrom.names,
4148 : : ast2obj_alias);
4149 [ - + ]: 4806 : if (!value) goto failed;
4150 [ - + ]: 4806 : if (PyObject_SetAttr(result, state->names, value) == -1)
4151 : 0 : goto failed;
4152 : 4806 : Py_DECREF(value);
4153 : 4806 : value = ast2obj_int(state, o->v.ImportFrom.level);
4154 [ - + ]: 4806 : if (!value) goto failed;
4155 [ - + ]: 4806 : if (PyObject_SetAttr(result, state->level, value) == -1)
4156 : 0 : goto failed;
4157 : 4806 : Py_DECREF(value);
4158 : 4806 : break;
4159 : 380 : case Global_kind:
4160 : 380 : tp = (PyTypeObject *)state->Global_type;
4161 : 380 : result = PyType_GenericNew(tp, NULL, NULL);
4162 [ - + ]: 380 : if (!result) goto failed;
4163 : 380 : value = ast2obj_list(state, (asdl_seq*)o->v.Global.names,
4164 : : ast2obj_identifier);
4165 [ - + ]: 380 : if (!value) goto failed;
4166 [ - + ]: 380 : if (PyObject_SetAttr(result, state->names, value) == -1)
4167 : 0 : goto failed;
4168 : 380 : Py_DECREF(value);
4169 : 380 : break;
4170 : 364 : case Nonlocal_kind:
4171 : 364 : tp = (PyTypeObject *)state->Nonlocal_type;
4172 : 364 : result = PyType_GenericNew(tp, NULL, NULL);
4173 [ - + ]: 364 : if (!result) goto failed;
4174 : 364 : value = ast2obj_list(state, (asdl_seq*)o->v.Nonlocal.names,
4175 : : ast2obj_identifier);
4176 [ - + ]: 364 : if (!value) goto failed;
4177 [ - + ]: 364 : if (PyObject_SetAttr(result, state->names, value) == -1)
4178 : 0 : goto failed;
4179 : 364 : Py_DECREF(value);
4180 : 364 : break;
4181 : 239146 : case Expr_kind:
4182 : 239146 : tp = (PyTypeObject *)state->Expr_type;
4183 : 239146 : result = PyType_GenericNew(tp, NULL, NULL);
4184 [ - + ]: 239146 : if (!result) goto failed;
4185 : 239146 : value = ast2obj_expr(state, o->v.Expr.value);
4186 [ - + ]: 239146 : if (!value) goto failed;
4187 [ - + ]: 239146 : if (PyObject_SetAttr(result, state->value, value) == -1)
4188 : 0 : goto failed;
4189 : 239146 : Py_DECREF(value);
4190 : 239146 : break;
4191 : 11089 : case Pass_kind:
4192 : 11089 : tp = (PyTypeObject *)state->Pass_type;
4193 : 11089 : result = PyType_GenericNew(tp, NULL, NULL);
4194 [ - + ]: 11089 : if (!result) goto failed;
4195 : 11089 : break;
4196 : 1707 : case Break_kind:
4197 : 1707 : tp = (PyTypeObject *)state->Break_type;
4198 : 1707 : result = PyType_GenericNew(tp, NULL, NULL);
4199 [ - + ]: 1707 : if (!result) goto failed;
4200 : 1707 : break;
4201 : 1457 : case Continue_kind:
4202 : 1457 : tp = (PyTypeObject *)state->Continue_type;
4203 : 1457 : result = PyType_GenericNew(tp, NULL, NULL);
4204 [ - + ]: 1457 : if (!result) goto failed;
4205 : 1457 : break;
4206 : : }
4207 : 725705 : value = ast2obj_int(state, o->lineno);
4208 [ - + ]: 725705 : if (!value) goto failed;
4209 [ - + ]: 725705 : if (PyObject_SetAttr(result, state->lineno, value) < 0)
4210 : 0 : goto failed;
4211 : 725705 : Py_DECREF(value);
4212 : 725705 : value = ast2obj_int(state, o->col_offset);
4213 [ - + ]: 725705 : if (!value) goto failed;
4214 [ - + ]: 725705 : if (PyObject_SetAttr(result, state->col_offset, value) < 0)
4215 : 0 : goto failed;
4216 : 725705 : Py_DECREF(value);
4217 : 725705 : value = ast2obj_int(state, o->end_lineno);
4218 [ - + ]: 725705 : if (!value) goto failed;
4219 [ - + ]: 725705 : if (PyObject_SetAttr(result, state->end_lineno, value) < 0)
4220 : 0 : goto failed;
4221 : 725705 : Py_DECREF(value);
4222 : 725705 : value = ast2obj_int(state, o->end_col_offset);
4223 [ - + ]: 725705 : if (!value) goto failed;
4224 [ - + ]: 725705 : if (PyObject_SetAttr(result, state->end_col_offset, value) < 0)
4225 : 0 : goto failed;
4226 : 725705 : Py_DECREF(value);
4227 : 725705 : return result;
4228 : 0 : failed:
4229 : 0 : Py_XDECREF(value);
4230 : 0 : Py_XDECREF(result);
4231 : 0 : return NULL;
4232 : : }
4233 : :
4234 : : PyObject*
4235 : 4029564 : ast2obj_expr(struct ast_state *state, void* _o)
4236 : : {
4237 : 4029564 : expr_ty o = (expr_ty)_o;
4238 : 4029564 : PyObject *result = NULL, *value = NULL;
4239 : : PyTypeObject *tp;
4240 [ + + ]: 4029564 : if (!o) {
4241 : 269197 : Py_RETURN_NONE;
4242 : : }
4243 [ + + + + : 3760367 : switch (o->kind) {
+ + + + +
+ + + + +
+ + + + +
+ + + + +
+ + + - ]
4244 : 9448 : case BoolOp_kind:
4245 : 9448 : tp = (PyTypeObject *)state->BoolOp_type;
4246 : 9448 : result = PyType_GenericNew(tp, NULL, NULL);
4247 [ - + ]: 9448 : if (!result) goto failed;
4248 : 9448 : value = ast2obj_boolop(state, o->v.BoolOp.op);
4249 [ - + ]: 9448 : if (!value) goto failed;
4250 [ - + ]: 9448 : if (PyObject_SetAttr(result, state->op, value) == -1)
4251 : 0 : goto failed;
4252 : 9448 : Py_DECREF(value);
4253 : 9448 : value = ast2obj_list(state, (asdl_seq*)o->v.BoolOp.values,
4254 : : ast2obj_expr);
4255 [ - + ]: 9448 : if (!value) goto failed;
4256 [ - + ]: 9448 : if (PyObject_SetAttr(result, state->values, value) == -1)
4257 : 0 : goto failed;
4258 : 9448 : Py_DECREF(value);
4259 : 9448 : break;
4260 : 197 : case NamedExpr_kind:
4261 : 197 : tp = (PyTypeObject *)state->NamedExpr_type;
4262 : 197 : result = PyType_GenericNew(tp, NULL, NULL);
4263 [ - + ]: 197 : if (!result) goto failed;
4264 : 197 : value = ast2obj_expr(state, o->v.NamedExpr.target);
4265 [ - + ]: 197 : if (!value) goto failed;
4266 [ - + ]: 197 : if (PyObject_SetAttr(result, state->target, value) == -1)
4267 : 0 : goto failed;
4268 : 197 : Py_DECREF(value);
4269 : 197 : value = ast2obj_expr(state, o->v.NamedExpr.value);
4270 [ - + ]: 197 : if (!value) goto failed;
4271 [ - + ]: 197 : if (PyObject_SetAttr(result, state->value, value) == -1)
4272 : 0 : goto failed;
4273 : 197 : Py_DECREF(value);
4274 : 197 : break;
4275 : 59807 : case BinOp_kind:
4276 : 59807 : tp = (PyTypeObject *)state->BinOp_type;
4277 : 59807 : result = PyType_GenericNew(tp, NULL, NULL);
4278 [ - + ]: 59807 : if (!result) goto failed;
4279 : 59807 : value = ast2obj_expr(state, o->v.BinOp.left);
4280 [ - + ]: 59807 : if (!value) goto failed;
4281 [ - + ]: 59807 : if (PyObject_SetAttr(result, state->left, value) == -1)
4282 : 0 : goto failed;
4283 : 59807 : Py_DECREF(value);
4284 : 59807 : value = ast2obj_operator(state, o->v.BinOp.op);
4285 [ - + ]: 59807 : if (!value) goto failed;
4286 [ - + ]: 59807 : if (PyObject_SetAttr(result, state->op, value) == -1)
4287 : 0 : goto failed;
4288 : 59807 : Py_DECREF(value);
4289 : 59807 : value = ast2obj_expr(state, o->v.BinOp.right);
4290 [ - + ]: 59807 : if (!value) goto failed;
4291 [ - + ]: 59807 : if (PyObject_SetAttr(result, state->right, value) == -1)
4292 : 0 : goto failed;
4293 : 59807 : Py_DECREF(value);
4294 : 59807 : break;
4295 : 23517 : case UnaryOp_kind:
4296 : 23517 : tp = (PyTypeObject *)state->UnaryOp_type;
4297 : 23517 : result = PyType_GenericNew(tp, NULL, NULL);
4298 [ - + ]: 23517 : if (!result) goto failed;
4299 : 23517 : value = ast2obj_unaryop(state, o->v.UnaryOp.op);
4300 [ - + ]: 23517 : if (!value) goto failed;
4301 [ - + ]: 23517 : if (PyObject_SetAttr(result, state->op, value) == -1)
4302 : 0 : goto failed;
4303 : 23517 : Py_DECREF(value);
4304 : 23517 : value = ast2obj_expr(state, o->v.UnaryOp.operand);
4305 [ - + ]: 23517 : if (!value) goto failed;
4306 [ - + ]: 23517 : if (PyObject_SetAttr(result, state->operand, value) == -1)
4307 : 0 : goto failed;
4308 : 23517 : Py_DECREF(value);
4309 : 23517 : break;
4310 : 2647 : case Lambda_kind:
4311 : 2647 : tp = (PyTypeObject *)state->Lambda_type;
4312 : 2647 : result = PyType_GenericNew(tp, NULL, NULL);
4313 [ - + ]: 2647 : if (!result) goto failed;
4314 : 2647 : value = ast2obj_arguments(state, o->v.Lambda.args);
4315 [ - + ]: 2647 : if (!value) goto failed;
4316 [ - + ]: 2647 : if (PyObject_SetAttr(result, state->args, value) == -1)
4317 : 0 : goto failed;
4318 : 2647 : Py_DECREF(value);
4319 : 2647 : value = ast2obj_expr(state, o->v.Lambda.body);
4320 [ - + ]: 2647 : if (!value) goto failed;
4321 [ - + ]: 2647 : if (PyObject_SetAttr(result, state->body, value) == -1)
4322 : 0 : goto failed;
4323 : 2647 : Py_DECREF(value);
4324 : 2647 : break;
4325 : 1417 : case IfExp_kind:
4326 : 1417 : tp = (PyTypeObject *)state->IfExp_type;
4327 : 1417 : result = PyType_GenericNew(tp, NULL, NULL);
4328 [ - + ]: 1417 : if (!result) goto failed;
4329 : 1417 : value = ast2obj_expr(state, o->v.IfExp.test);
4330 [ - + ]: 1417 : if (!value) goto failed;
4331 [ - + ]: 1417 : if (PyObject_SetAttr(result, state->test, value) == -1)
4332 : 0 : goto failed;
4333 : 1417 : Py_DECREF(value);
4334 : 1417 : value = ast2obj_expr(state, o->v.IfExp.body);
4335 [ - + ]: 1417 : if (!value) goto failed;
4336 [ - + ]: 1417 : if (PyObject_SetAttr(result, state->body, value) == -1)
4337 : 0 : goto failed;
4338 : 1417 : Py_DECREF(value);
4339 : 1417 : value = ast2obj_expr(state, o->v.IfExp.orelse);
4340 [ - + ]: 1417 : if (!value) goto failed;
4341 [ - + ]: 1417 : if (PyObject_SetAttr(result, state->orelse, value) == -1)
4342 : 0 : goto failed;
4343 : 1417 : Py_DECREF(value);
4344 : 1417 : break;
4345 : 9803 : case Dict_kind:
4346 : 9803 : tp = (PyTypeObject *)state->Dict_type;
4347 : 9803 : result = PyType_GenericNew(tp, NULL, NULL);
4348 [ - + ]: 9803 : if (!result) goto failed;
4349 : 9803 : value = ast2obj_list(state, (asdl_seq*)o->v.Dict.keys, ast2obj_expr);
4350 [ - + ]: 9803 : if (!value) goto failed;
4351 [ - + ]: 9803 : if (PyObject_SetAttr(result, state->keys, value) == -1)
4352 : 0 : goto failed;
4353 : 9803 : Py_DECREF(value);
4354 : 9803 : value = ast2obj_list(state, (asdl_seq*)o->v.Dict.values, ast2obj_expr);
4355 [ - + ]: 9803 : if (!value) goto failed;
4356 [ - + ]: 9803 : if (PyObject_SetAttr(result, state->values, value) == -1)
4357 : 0 : goto failed;
4358 : 9803 : Py_DECREF(value);
4359 : 9803 : break;
4360 : 1312 : case Set_kind:
4361 : 1312 : tp = (PyTypeObject *)state->Set_type;
4362 : 1312 : result = PyType_GenericNew(tp, NULL, NULL);
4363 [ - + ]: 1312 : if (!result) goto failed;
4364 : 1312 : value = ast2obj_list(state, (asdl_seq*)o->v.Set.elts, ast2obj_expr);
4365 [ - + ]: 1312 : if (!value) goto failed;
4366 [ - + ]: 1312 : if (PyObject_SetAttr(result, state->elts, value) == -1)
4367 : 0 : goto failed;
4368 : 1312 : Py_DECREF(value);
4369 : 1312 : break;
4370 : 2888 : case ListComp_kind:
4371 : 2888 : tp = (PyTypeObject *)state->ListComp_type;
4372 : 2888 : result = PyType_GenericNew(tp, NULL, NULL);
4373 [ - + ]: 2888 : if (!result) goto failed;
4374 : 2888 : value = ast2obj_expr(state, o->v.ListComp.elt);
4375 [ - + ]: 2888 : if (!value) goto failed;
4376 [ - + ]: 2888 : if (PyObject_SetAttr(result, state->elt, value) == -1)
4377 : 0 : goto failed;
4378 : 2888 : Py_DECREF(value);
4379 : 2888 : value = ast2obj_list(state, (asdl_seq*)o->v.ListComp.generators,
4380 : : ast2obj_comprehension);
4381 [ - + ]: 2888 : if (!value) goto failed;
4382 [ - + ]: 2888 : if (PyObject_SetAttr(result, state->generators, value) == -1)
4383 : 0 : goto failed;
4384 : 2888 : Py_DECREF(value);
4385 : 2888 : break;
4386 : 127 : case SetComp_kind:
4387 : 127 : tp = (PyTypeObject *)state->SetComp_type;
4388 : 127 : result = PyType_GenericNew(tp, NULL, NULL);
4389 [ - + ]: 127 : if (!result) goto failed;
4390 : 127 : value = ast2obj_expr(state, o->v.SetComp.elt);
4391 [ - + ]: 127 : if (!value) goto failed;
4392 [ - + ]: 127 : if (PyObject_SetAttr(result, state->elt, value) == -1)
4393 : 0 : goto failed;
4394 : 127 : Py_DECREF(value);
4395 : 127 : value = ast2obj_list(state, (asdl_seq*)o->v.SetComp.generators,
4396 : : ast2obj_comprehension);
4397 [ - + ]: 127 : if (!value) goto failed;
4398 [ - + ]: 127 : if (PyObject_SetAttr(result, state->generators, value) == -1)
4399 : 0 : goto failed;
4400 : 127 : Py_DECREF(value);
4401 : 127 : break;
4402 : 247 : case DictComp_kind:
4403 : 247 : tp = (PyTypeObject *)state->DictComp_type;
4404 : 247 : result = PyType_GenericNew(tp, NULL, NULL);
4405 [ - + ]: 247 : if (!result) goto failed;
4406 : 247 : value = ast2obj_expr(state, o->v.DictComp.key);
4407 [ - + ]: 247 : if (!value) goto failed;
4408 [ - + ]: 247 : if (PyObject_SetAttr(result, state->key, value) == -1)
4409 : 0 : goto failed;
4410 : 247 : Py_DECREF(value);
4411 : 247 : value = ast2obj_expr(state, o->v.DictComp.value);
4412 [ - + ]: 247 : if (!value) goto failed;
4413 [ - + ]: 247 : if (PyObject_SetAttr(result, state->value, value) == -1)
4414 : 0 : goto failed;
4415 : 247 : Py_DECREF(value);
4416 : 247 : value = ast2obj_list(state, (asdl_seq*)o->v.DictComp.generators,
4417 : : ast2obj_comprehension);
4418 [ - + ]: 247 : if (!value) goto failed;
4419 [ - + ]: 247 : if (PyObject_SetAttr(result, state->generators, value) == -1)
4420 : 0 : goto failed;
4421 : 247 : Py_DECREF(value);
4422 : 247 : break;
4423 : 1495 : case GeneratorExp_kind:
4424 : 1495 : tp = (PyTypeObject *)state->GeneratorExp_type;
4425 : 1495 : result = PyType_GenericNew(tp, NULL, NULL);
4426 [ - + ]: 1495 : if (!result) goto failed;
4427 : 1495 : value = ast2obj_expr(state, o->v.GeneratorExp.elt);
4428 [ - + ]: 1495 : if (!value) goto failed;
4429 [ - + ]: 1495 : if (PyObject_SetAttr(result, state->elt, value) == -1)
4430 : 0 : goto failed;
4431 : 1495 : Py_DECREF(value);
4432 : 1495 : value = ast2obj_list(state, (asdl_seq*)o->v.GeneratorExp.generators,
4433 : : ast2obj_comprehension);
4434 [ - + ]: 1495 : if (!value) goto failed;
4435 [ - + ]: 1495 : if (PyObject_SetAttr(result, state->generators, value) == -1)
4436 : 0 : goto failed;
4437 : 1495 : Py_DECREF(value);
4438 : 1495 : break;
4439 : 661 : case Await_kind:
4440 : 661 : tp = (PyTypeObject *)state->Await_type;
4441 : 661 : result = PyType_GenericNew(tp, NULL, NULL);
4442 [ - + ]: 661 : if (!result) goto failed;
4443 : 661 : value = ast2obj_expr(state, o->v.Await.value);
4444 [ - + ]: 661 : if (!value) goto failed;
4445 [ - + ]: 661 : if (PyObject_SetAttr(result, state->value, value) == -1)
4446 : 0 : goto failed;
4447 : 661 : Py_DECREF(value);
4448 : 661 : break;
4449 : 2199 : case Yield_kind:
4450 : 2199 : tp = (PyTypeObject *)state->Yield_type;
4451 : 2199 : result = PyType_GenericNew(tp, NULL, NULL);
4452 [ - + ]: 2199 : if (!result) goto failed;
4453 : 2199 : value = ast2obj_expr(state, o->v.Yield.value);
4454 [ - + ]: 2199 : if (!value) goto failed;
4455 [ - + ]: 2199 : if (PyObject_SetAttr(result, state->value, value) == -1)
4456 : 0 : goto failed;
4457 : 2199 : Py_DECREF(value);
4458 : 2199 : break;
4459 : 311 : case YieldFrom_kind:
4460 : 311 : tp = (PyTypeObject *)state->YieldFrom_type;
4461 : 311 : result = PyType_GenericNew(tp, NULL, NULL);
4462 [ - + ]: 311 : if (!result) goto failed;
4463 : 311 : value = ast2obj_expr(state, o->v.YieldFrom.value);
4464 [ - + ]: 311 : if (!value) goto failed;
4465 [ - + ]: 311 : if (PyObject_SetAttr(result, state->value, value) == -1)
4466 : 0 : goto failed;
4467 : 311 : Py_DECREF(value);
4468 : 311 : break;
4469 : 42605 : case Compare_kind:
4470 : 42605 : tp = (PyTypeObject *)state->Compare_type;
4471 : 42605 : result = PyType_GenericNew(tp, NULL, NULL);
4472 [ - + ]: 42605 : if (!result) goto failed;
4473 : 42605 : value = ast2obj_expr(state, o->v.Compare.left);
4474 [ - + ]: 42605 : if (!value) goto failed;
4475 [ - + ]: 42605 : if (PyObject_SetAttr(result, state->left, value) == -1)
4476 : 0 : goto failed;
4477 : 42605 : Py_DECREF(value);
4478 : : {
4479 [ + - ]: 42605 : Py_ssize_t i, n = asdl_seq_LEN(o->v.Compare.ops);
4480 : 42605 : value = PyList_New(n);
4481 [ - + ]: 42605 : if (!value) goto failed;
4482 [ + + ]: 85947 : for(i = 0; i < n; i++)
4483 : 43342 : PyList_SET_ITEM(value, i, ast2obj_cmpop(state, (cmpop_ty)asdl_seq_GET(o->v.Compare.ops, i)));
4484 : : }
4485 [ - + ]: 42605 : if (!value) goto failed;
4486 [ - + ]: 42605 : if (PyObject_SetAttr(result, state->ops, value) == -1)
4487 : 0 : goto failed;
4488 : 42605 : Py_DECREF(value);
4489 : 42605 : value = ast2obj_list(state, (asdl_seq*)o->v.Compare.comparators,
4490 : : ast2obj_expr);
4491 [ - + ]: 42605 : if (!value) goto failed;
4492 [ - + ]: 42605 : if (PyObject_SetAttr(result, state->comparators, value) == -1)
4493 : 0 : goto failed;
4494 : 42605 : Py_DECREF(value);
4495 : 42605 : break;
4496 : 501855 : case Call_kind:
4497 : 501855 : tp = (PyTypeObject *)state->Call_type;
4498 : 501855 : result = PyType_GenericNew(tp, NULL, NULL);
4499 [ - + ]: 501855 : if (!result) goto failed;
4500 : 501855 : value = ast2obj_expr(state, o->v.Call.func);
4501 [ - + ]: 501855 : if (!value) goto failed;
4502 [ - + ]: 501855 : if (PyObject_SetAttr(result, state->func, value) == -1)
4503 : 0 : goto failed;
4504 : 501855 : Py_DECREF(value);
4505 : 501855 : value = ast2obj_list(state, (asdl_seq*)o->v.Call.args, ast2obj_expr);
4506 [ - + ]: 501855 : if (!value) goto failed;
4507 [ - + ]: 501855 : if (PyObject_SetAttr(result, state->args, value) == -1)
4508 : 0 : goto failed;
4509 : 501855 : Py_DECREF(value);
4510 : 501855 : value = ast2obj_list(state, (asdl_seq*)o->v.Call.keywords,
4511 : : ast2obj_keyword);
4512 [ - + ]: 501855 : if (!value) goto failed;
4513 [ - + ]: 501855 : if (PyObject_SetAttr(result, state->keywords, value) == -1)
4514 : 0 : goto failed;
4515 : 501855 : Py_DECREF(value);
4516 : 501855 : break;
4517 : 4924 : case FormattedValue_kind:
4518 : 4924 : tp = (PyTypeObject *)state->FormattedValue_type;
4519 : 4924 : result = PyType_GenericNew(tp, NULL, NULL);
4520 [ - + ]: 4924 : if (!result) goto failed;
4521 : 4924 : value = ast2obj_expr(state, o->v.FormattedValue.value);
4522 [ - + ]: 4924 : if (!value) goto failed;
4523 [ - + ]: 4924 : if (PyObject_SetAttr(result, state->value, value) == -1)
4524 : 0 : goto failed;
4525 : 4924 : Py_DECREF(value);
4526 : 4924 : value = ast2obj_int(state, o->v.FormattedValue.conversion);
4527 [ - + ]: 4924 : if (!value) goto failed;
4528 [ - + ]: 4924 : if (PyObject_SetAttr(result, state->conversion, value) == -1)
4529 : 0 : goto failed;
4530 : 4924 : Py_DECREF(value);
4531 : 4924 : value = ast2obj_expr(state, o->v.FormattedValue.format_spec);
4532 [ - + ]: 4924 : if (!value) goto failed;
4533 [ - + ]: 4924 : if (PyObject_SetAttr(result, state->format_spec, value) == -1)
4534 : 0 : goto failed;
4535 : 4924 : Py_DECREF(value);
4536 : 4924 : break;
4537 : 4022 : case JoinedStr_kind:
4538 : 4022 : tp = (PyTypeObject *)state->JoinedStr_type;
4539 : 4022 : result = PyType_GenericNew(tp, NULL, NULL);
4540 [ - + ]: 4022 : if (!result) goto failed;
4541 : 4022 : value = ast2obj_list(state, (asdl_seq*)o->v.JoinedStr.values,
4542 : : ast2obj_expr);
4543 [ - + ]: 4022 : if (!value) goto failed;
4544 [ - + ]: 4022 : if (PyObject_SetAttr(result, state->values, value) == -1)
4545 : 0 : goto failed;
4546 : 4022 : Py_DECREF(value);
4547 : 4022 : break;
4548 : 1052450 : case Constant_kind:
4549 : 1052450 : tp = (PyTypeObject *)state->Constant_type;
4550 : 1052450 : result = PyType_GenericNew(tp, NULL, NULL);
4551 [ - + ]: 1052450 : if (!result) goto failed;
4552 : 1052450 : value = ast2obj_constant(state, o->v.Constant.value);
4553 [ - + ]: 1052450 : if (!value) goto failed;
4554 [ - + ]: 1052450 : if (PyObject_SetAttr(result, state->value, value) == -1)
4555 : 0 : goto failed;
4556 : 1052450 : Py_DECREF(value);
4557 : 1052450 : value = ast2obj_string(state, o->v.Constant.kind);
4558 [ - + ]: 1052450 : if (!value) goto failed;
4559 [ - + ]: 1052450 : if (PyObject_SetAttr(result, state->kind, value) == -1)
4560 : 0 : goto failed;
4561 : 1052450 : Py_DECREF(value);
4562 : 1052450 : break;
4563 : 534308 : case Attribute_kind:
4564 : 534308 : tp = (PyTypeObject *)state->Attribute_type;
4565 : 534308 : result = PyType_GenericNew(tp, NULL, NULL);
4566 [ - + ]: 534308 : if (!result) goto failed;
4567 : 534308 : value = ast2obj_expr(state, o->v.Attribute.value);
4568 [ - + ]: 534308 : if (!value) goto failed;
4569 [ - + ]: 534308 : if (PyObject_SetAttr(result, state->value, value) == -1)
4570 : 0 : goto failed;
4571 : 534308 : Py_DECREF(value);
4572 : 534308 : value = ast2obj_identifier(state, o->v.Attribute.attr);
4573 [ - + ]: 534308 : if (!value) goto failed;
4574 [ - + ]: 534308 : if (PyObject_SetAttr(result, state->attr, value) == -1)
4575 : 0 : goto failed;
4576 : 534308 : Py_DECREF(value);
4577 : 534308 : value = ast2obj_expr_context(state, o->v.Attribute.ctx);
4578 [ - + ]: 534308 : if (!value) goto failed;
4579 [ - + ]: 534308 : if (PyObject_SetAttr(result, state->ctx, value) == -1)
4580 : 0 : goto failed;
4581 : 534308 : Py_DECREF(value);
4582 : 534308 : break;
4583 : 42909 : case Subscript_kind:
4584 : 42909 : tp = (PyTypeObject *)state->Subscript_type;
4585 : 42909 : result = PyType_GenericNew(tp, NULL, NULL);
4586 [ - + ]: 42909 : if (!result) goto failed;
4587 : 42909 : value = ast2obj_expr(state, o->v.Subscript.value);
4588 [ - + ]: 42909 : if (!value) goto failed;
4589 [ - + ]: 42909 : if (PyObject_SetAttr(result, state->value, value) == -1)
4590 : 0 : goto failed;
4591 : 42909 : Py_DECREF(value);
4592 : 42909 : value = ast2obj_expr(state, o->v.Subscript.slice);
4593 [ - + ]: 42909 : if (!value) goto failed;
4594 [ - + ]: 42909 : if (PyObject_SetAttr(result, state->slice, value) == -1)
4595 : 0 : goto failed;
4596 : 42909 : Py_DECREF(value);
4597 : 42909 : value = ast2obj_expr_context(state, o->v.Subscript.ctx);
4598 [ - + ]: 42909 : if (!value) goto failed;
4599 [ - + ]: 42909 : if (PyObject_SetAttr(result, state->ctx, value) == -1)
4600 : 0 : goto failed;
4601 : 42909 : Py_DECREF(value);
4602 : 42909 : break;
4603 : 3364 : case Starred_kind:
4604 : 3364 : tp = (PyTypeObject *)state->Starred_type;
4605 : 3364 : result = PyType_GenericNew(tp, NULL, NULL);
4606 [ - + ]: 3364 : if (!result) goto failed;
4607 : 3364 : value = ast2obj_expr(state, o->v.Starred.value);
4608 [ - + ]: 3364 : if (!value) goto failed;
4609 [ - + ]: 3364 : if (PyObject_SetAttr(result, state->value, value) == -1)
4610 : 0 : goto failed;
4611 : 3364 : Py_DECREF(value);
4612 : 3364 : value = ast2obj_expr_context(state, o->v.Starred.ctx);
4613 [ - + ]: 3364 : if (!value) goto failed;
4614 [ - + ]: 3364 : if (PyObject_SetAttr(result, state->ctx, value) == -1)
4615 : 0 : goto failed;
4616 : 3364 : Py_DECREF(value);
4617 : 3364 : break;
4618 : 1344329 : case Name_kind:
4619 : 1344329 : tp = (PyTypeObject *)state->Name_type;
4620 : 1344329 : result = PyType_GenericNew(tp, NULL, NULL);
4621 [ - + ]: 1344329 : if (!result) goto failed;
4622 : 1344329 : value = ast2obj_identifier(state, o->v.Name.id);
4623 [ - + ]: 1344329 : if (!value) goto failed;
4624 [ - + ]: 1344329 : if (PyObject_SetAttr(result, state->id, value) == -1)
4625 : 0 : goto failed;
4626 : 1344329 : Py_DECREF(value);
4627 : 1344329 : value = ast2obj_expr_context(state, o->v.Name.ctx);
4628 [ - + ]: 1344329 : if (!value) goto failed;
4629 [ - + ]: 1344329 : if (PyObject_SetAttr(result, state->ctx, value) == -1)
4630 : 0 : goto failed;
4631 : 1344329 : Py_DECREF(value);
4632 : 1344329 : break;
4633 : 34915 : case List_kind:
4634 : 34915 : tp = (PyTypeObject *)state->List_type;
4635 : 34915 : result = PyType_GenericNew(tp, NULL, NULL);
4636 [ - + ]: 34915 : if (!result) goto failed;
4637 : 34915 : value = ast2obj_list(state, (asdl_seq*)o->v.List.elts, ast2obj_expr);
4638 [ - + ]: 34915 : if (!value) goto failed;
4639 [ - + ]: 34915 : if (PyObject_SetAttr(result, state->elts, value) == -1)
4640 : 0 : goto failed;
4641 : 34915 : Py_DECREF(value);
4642 : 34915 : value = ast2obj_expr_context(state, o->v.List.ctx);
4643 [ - + ]: 34915 : if (!value) goto failed;
4644 [ - + ]: 34915 : if (PyObject_SetAttr(result, state->ctx, value) == -1)
4645 : 0 : goto failed;
4646 : 34915 : Py_DECREF(value);
4647 : 34915 : break;
4648 : 70250 : case Tuple_kind:
4649 : 70250 : tp = (PyTypeObject *)state->Tuple_type;
4650 : 70250 : result = PyType_GenericNew(tp, NULL, NULL);
4651 [ - + ]: 70250 : if (!result) goto failed;
4652 : 70250 : value = ast2obj_list(state, (asdl_seq*)o->v.Tuple.elts, ast2obj_expr);
4653 [ - + ]: 70250 : if (!value) goto failed;
4654 [ - + ]: 70250 : if (PyObject_SetAttr(result, state->elts, value) == -1)
4655 : 0 : goto failed;
4656 : 70250 : Py_DECREF(value);
4657 : 70250 : value = ast2obj_expr_context(state, o->v.Tuple.ctx);
4658 [ - + ]: 70250 : if (!value) goto failed;
4659 [ - + ]: 70250 : if (PyObject_SetAttr(result, state->ctx, value) == -1)
4660 : 0 : goto failed;
4661 : 70250 : Py_DECREF(value);
4662 : 70250 : break;
4663 : 8360 : case Slice_kind:
4664 : 8360 : tp = (PyTypeObject *)state->Slice_type;
4665 : 8360 : result = PyType_GenericNew(tp, NULL, NULL);
4666 [ - + ]: 8360 : if (!result) goto failed;
4667 : 8360 : value = ast2obj_expr(state, o->v.Slice.lower);
4668 [ - + ]: 8360 : if (!value) goto failed;
4669 [ - + ]: 8360 : if (PyObject_SetAttr(result, state->lower, value) == -1)
4670 : 0 : goto failed;
4671 : 8360 : Py_DECREF(value);
4672 : 8360 : value = ast2obj_expr(state, o->v.Slice.upper);
4673 [ - + ]: 8360 : if (!value) goto failed;
4674 [ - + ]: 8360 : if (PyObject_SetAttr(result, state->upper, value) == -1)
4675 : 0 : goto failed;
4676 : 8360 : Py_DECREF(value);
4677 : 8360 : value = ast2obj_expr(state, o->v.Slice.step);
4678 [ - + ]: 8360 : if (!value) goto failed;
4679 [ - + ]: 8360 : if (PyObject_SetAttr(result, state->step, value) == -1)
4680 : 0 : goto failed;
4681 : 8360 : Py_DECREF(value);
4682 : 8360 : break;
4683 : : }
4684 : 3760367 : value = ast2obj_int(state, o->lineno);
4685 [ - + ]: 3760367 : if (!value) goto failed;
4686 [ - + ]: 3760367 : if (PyObject_SetAttr(result, state->lineno, value) < 0)
4687 : 0 : goto failed;
4688 : 3760367 : Py_DECREF(value);
4689 : 3760367 : value = ast2obj_int(state, o->col_offset);
4690 [ - + ]: 3760367 : if (!value) goto failed;
4691 [ - + ]: 3760367 : if (PyObject_SetAttr(result, state->col_offset, value) < 0)
4692 : 0 : goto failed;
4693 : 3760367 : Py_DECREF(value);
4694 : 3760367 : value = ast2obj_int(state, o->end_lineno);
4695 [ - + ]: 3760367 : if (!value) goto failed;
4696 [ - + ]: 3760367 : if (PyObject_SetAttr(result, state->end_lineno, value) < 0)
4697 : 0 : goto failed;
4698 : 3760367 : Py_DECREF(value);
4699 : 3760367 : value = ast2obj_int(state, o->end_col_offset);
4700 [ - + ]: 3760367 : if (!value) goto failed;
4701 [ - + ]: 3760367 : if (PyObject_SetAttr(result, state->end_col_offset, value) < 0)
4702 : 0 : goto failed;
4703 : 3760367 : Py_DECREF(value);
4704 : 3760367 : return result;
4705 : 0 : failed:
4706 : 0 : Py_XDECREF(value);
4707 : 0 : Py_XDECREF(result);
4708 : 0 : return NULL;
4709 : : }
4710 : :
4711 : 2030075 : PyObject* ast2obj_expr_context(struct ast_state *state, expr_context_ty o)
4712 : : {
4713 [ + + + - ]: 2030075 : switch(o) {
4714 : 1765661 : case Load:
4715 : 1765661 : Py_INCREF(state->Load_singleton);
4716 : 1765661 : return state->Load_singleton;
4717 : 261248 : case Store:
4718 : 261248 : Py_INCREF(state->Store_singleton);
4719 : 261248 : return state->Store_singleton;
4720 : 3166 : case Del:
4721 : 3166 : Py_INCREF(state->Del_singleton);
4722 : 3166 : return state->Del_singleton;
4723 : : }
4724 : 0 : Py_UNREACHABLE();
4725 : : }
4726 : 9448 : PyObject* ast2obj_boolop(struct ast_state *state, boolop_ty o)
4727 : : {
4728 [ + + - ]: 9448 : switch(o) {
4729 : 5925 : case And:
4730 : 5925 : Py_INCREF(state->And_singleton);
4731 : 5925 : return state->And_singleton;
4732 : 3523 : case Or:
4733 : 3523 : Py_INCREF(state->Or_singleton);
4734 : 3523 : return state->Or_singleton;
4735 : : }
4736 : 0 : Py_UNREACHABLE();
4737 : : }
4738 : 64856 : PyObject* ast2obj_operator(struct ast_state *state, operator_ty o)
4739 : : {
4740 [ + + + + : 64856 : switch(o) {
+ + + + +
+ + + +
- ]
4741 : 25629 : case Add:
4742 : 25629 : Py_INCREF(state->Add_singleton);
4743 : 25629 : return state->Add_singleton;
4744 : 6582 : case Sub:
4745 : 6582 : Py_INCREF(state->Sub_singleton);
4746 : 6582 : return state->Sub_singleton;
4747 : 9250 : case Mult:
4748 : 9250 : Py_INCREF(state->Mult_singleton);
4749 : 9250 : return state->Mult_singleton;
4750 : 53 : case MatMult:
4751 : 53 : Py_INCREF(state->MatMult_singleton);
4752 : 53 : return state->MatMult_singleton;
4753 : 3521 : case Div:
4754 : 3521 : Py_INCREF(state->Div_singleton);
4755 : 3521 : return state->Div_singleton;
4756 : 9928 : case Mod:
4757 : 9928 : Py_INCREF(state->Mod_singleton);
4758 : 9928 : return state->Mod_singleton;
4759 : 2521 : case Pow:
4760 : 2521 : Py_INCREF(state->Pow_singleton);
4761 : 2521 : return state->Pow_singleton;
4762 : 1156 : case LShift:
4763 : 1156 : Py_INCREF(state->LShift_singleton);
4764 : 1156 : return state->LShift_singleton;
4765 : 389 : case RShift:
4766 : 389 : Py_INCREF(state->RShift_singleton);
4767 : 389 : return state->RShift_singleton;
4768 : 2692 : case BitOr:
4769 : 2692 : Py_INCREF(state->BitOr_singleton);
4770 : 2692 : return state->BitOr_singleton;
4771 : 449 : case BitXor:
4772 : 449 : Py_INCREF(state->BitXor_singleton);
4773 : 449 : return state->BitXor_singleton;
4774 : 1531 : case BitAnd:
4775 : 1531 : Py_INCREF(state->BitAnd_singleton);
4776 : 1531 : return state->BitAnd_singleton;
4777 : 1155 : case FloorDiv:
4778 : 1155 : Py_INCREF(state->FloorDiv_singleton);
4779 : 1155 : return state->FloorDiv_singleton;
4780 : : }
4781 : 0 : Py_UNREACHABLE();
4782 : : }
4783 : 23517 : PyObject* ast2obj_unaryop(struct ast_state *state, unaryop_ty o)
4784 : : {
4785 [ + + + + : 23517 : switch(o) {
- ]
4786 : 281 : case Invert:
4787 : 281 : Py_INCREF(state->Invert_singleton);
4788 : 281 : return state->Invert_singleton;
4789 : 8138 : case Not:
4790 : 8138 : Py_INCREF(state->Not_singleton);
4791 : 8138 : return state->Not_singleton;
4792 : 138 : case UAdd:
4793 : 138 : Py_INCREF(state->UAdd_singleton);
4794 : 138 : return state->UAdd_singleton;
4795 : 14960 : case USub:
4796 : 14960 : Py_INCREF(state->USub_singleton);
4797 : 14960 : return state->USub_singleton;
4798 : : }
4799 : 0 : Py_UNREACHABLE();
4800 : : }
4801 : 43342 : PyObject* ast2obj_cmpop(struct ast_state *state, cmpop_ty o)
4802 : : {
4803 [ + + + + : 43342 : switch(o) {
+ + + + +
+ - ]
4804 : 13440 : case Eq:
4805 : 13440 : Py_INCREF(state->Eq_singleton);
4806 : 13440 : return state->Eq_singleton;
4807 : 3457 : case NotEq:
4808 : 3457 : Py_INCREF(state->NotEq_singleton);
4809 : 3457 : return state->NotEq_singleton;
4810 : 3187 : case Lt:
4811 : 3187 : Py_INCREF(state->Lt_singleton);
4812 : 3187 : return state->Lt_singleton;
4813 : 1787 : case LtE:
4814 : 1787 : Py_INCREF(state->LtE_singleton);
4815 : 1787 : return state->LtE_singleton;
4816 : 2609 : case Gt:
4817 : 2609 : Py_INCREF(state->Gt_singleton);
4818 : 2609 : return state->Gt_singleton;
4819 : 1655 : case GtE:
4820 : 1655 : Py_INCREF(state->GtE_singleton);
4821 : 1655 : return state->GtE_singleton;
4822 : 6514 : case Is:
4823 : 6514 : Py_INCREF(state->Is_singleton);
4824 : 6514 : return state->Is_singleton;
4825 : 4090 : case IsNot:
4826 : 4090 : Py_INCREF(state->IsNot_singleton);
4827 : 4090 : return state->IsNot_singleton;
4828 : 5138 : case In:
4829 : 5138 : Py_INCREF(state->In_singleton);
4830 : 5138 : return state->In_singleton;
4831 : 1465 : case NotIn:
4832 : 1465 : Py_INCREF(state->NotIn_singleton);
4833 : 1465 : return state->NotIn_singleton;
4834 : : }
4835 : 0 : Py_UNREACHABLE();
4836 : : }
4837 : : PyObject*
4838 : 4943 : ast2obj_comprehension(struct ast_state *state, void* _o)
4839 : : {
4840 : 4943 : comprehension_ty o = (comprehension_ty)_o;
4841 : 4943 : PyObject *result = NULL, *value = NULL;
4842 : : PyTypeObject *tp;
4843 [ - + ]: 4943 : if (!o) {
4844 : 0 : Py_RETURN_NONE;
4845 : : }
4846 : 4943 : tp = (PyTypeObject *)state->comprehension_type;
4847 : 4943 : result = PyType_GenericNew(tp, NULL, NULL);
4848 [ - + ]: 4943 : if (!result) return NULL;
4849 : 4943 : value = ast2obj_expr(state, o->target);
4850 [ - + ]: 4943 : if (!value) goto failed;
4851 [ - + ]: 4943 : if (PyObject_SetAttr(result, state->target, value) == -1)
4852 : 0 : goto failed;
4853 : 4943 : Py_DECREF(value);
4854 : 4943 : value = ast2obj_expr(state, o->iter);
4855 [ - + ]: 4943 : if (!value) goto failed;
4856 [ - + ]: 4943 : if (PyObject_SetAttr(result, state->iter, value) == -1)
4857 : 0 : goto failed;
4858 : 4943 : Py_DECREF(value);
4859 : 4943 : value = ast2obj_list(state, (asdl_seq*)o->ifs, ast2obj_expr);
4860 [ - + ]: 4943 : if (!value) goto failed;
4861 [ - + ]: 4943 : if (PyObject_SetAttr(result, state->ifs, value) == -1)
4862 : 0 : goto failed;
4863 : 4943 : Py_DECREF(value);
4864 : 4943 : value = ast2obj_int(state, o->is_async);
4865 [ - + ]: 4943 : if (!value) goto failed;
4866 [ - + ]: 4943 : if (PyObject_SetAttr(result, state->is_async, value) == -1)
4867 : 0 : goto failed;
4868 : 4943 : Py_DECREF(value);
4869 : 4943 : return result;
4870 : 0 : failed:
4871 : 0 : Py_XDECREF(value);
4872 : 0 : Py_XDECREF(result);
4873 : 0 : return NULL;
4874 : : }
4875 : :
4876 : : PyObject*
4877 : 9179 : ast2obj_excepthandler(struct ast_state *state, void* _o)
4878 : : {
4879 : 9179 : excepthandler_ty o = (excepthandler_ty)_o;
4880 : 9179 : PyObject *result = NULL, *value = NULL;
4881 : : PyTypeObject *tp;
4882 [ - + ]: 9179 : if (!o) {
4883 : 0 : Py_RETURN_NONE;
4884 : : }
4885 [ + - ]: 9179 : switch (o->kind) {
4886 : 9179 : case ExceptHandler_kind:
4887 : 9179 : tp = (PyTypeObject *)state->ExceptHandler_type;
4888 : 9179 : result = PyType_GenericNew(tp, NULL, NULL);
4889 [ - + ]: 9179 : if (!result) goto failed;
4890 : 9179 : value = ast2obj_expr(state, o->v.ExceptHandler.type);
4891 [ - + ]: 9179 : if (!value) goto failed;
4892 [ - + ]: 9179 : if (PyObject_SetAttr(result, state->type, value) == -1)
4893 : 0 : goto failed;
4894 : 9179 : Py_DECREF(value);
4895 : 9179 : value = ast2obj_identifier(state, o->v.ExceptHandler.name);
4896 [ - + ]: 9179 : if (!value) goto failed;
4897 [ - + ]: 9179 : if (PyObject_SetAttr(result, state->name, value) == -1)
4898 : 0 : goto failed;
4899 : 9179 : Py_DECREF(value);
4900 : 9179 : value = ast2obj_list(state, (asdl_seq*)o->v.ExceptHandler.body,
4901 : : ast2obj_stmt);
4902 [ - + ]: 9179 : if (!value) goto failed;
4903 [ - + ]: 9179 : if (PyObject_SetAttr(result, state->body, value) == -1)
4904 : 0 : goto failed;
4905 : 9179 : Py_DECREF(value);
4906 : 9179 : break;
4907 : : }
4908 : 9179 : value = ast2obj_int(state, o->lineno);
4909 [ - + ]: 9179 : if (!value) goto failed;
4910 [ - + ]: 9179 : if (PyObject_SetAttr(result, state->lineno, value) < 0)
4911 : 0 : goto failed;
4912 : 9179 : Py_DECREF(value);
4913 : 9179 : value = ast2obj_int(state, o->col_offset);
4914 [ - + ]: 9179 : if (!value) goto failed;
4915 [ - + ]: 9179 : if (PyObject_SetAttr(result, state->col_offset, value) < 0)
4916 : 0 : goto failed;
4917 : 9179 : Py_DECREF(value);
4918 : 9179 : value = ast2obj_int(state, o->end_lineno);
4919 [ - + ]: 9179 : if (!value) goto failed;
4920 [ - + ]: 9179 : if (PyObject_SetAttr(result, state->end_lineno, value) < 0)
4921 : 0 : goto failed;
4922 : 9179 : Py_DECREF(value);
4923 : 9179 : value = ast2obj_int(state, o->end_col_offset);
4924 [ - + ]: 9179 : if (!value) goto failed;
4925 [ - + ]: 9179 : if (PyObject_SetAttr(result, state->end_col_offset, value) < 0)
4926 : 0 : goto failed;
4927 : 9179 : Py_DECREF(value);
4928 : 9179 : return result;
4929 : 0 : failed:
4930 : 0 : Py_XDECREF(value);
4931 : 0 : Py_XDECREF(result);
4932 : 0 : return NULL;
4933 : : }
4934 : :
4935 : : PyObject*
4936 : 91523 : ast2obj_arguments(struct ast_state *state, void* _o)
4937 : : {
4938 : 91523 : arguments_ty o = (arguments_ty)_o;
4939 : 91523 : PyObject *result = NULL, *value = NULL;
4940 : : PyTypeObject *tp;
4941 [ - + ]: 91523 : if (!o) {
4942 : 0 : Py_RETURN_NONE;
4943 : : }
4944 : 91523 : tp = (PyTypeObject *)state->arguments_type;
4945 : 91523 : result = PyType_GenericNew(tp, NULL, NULL);
4946 [ - + ]: 91523 : if (!result) return NULL;
4947 : 91523 : value = ast2obj_list(state, (asdl_seq*)o->posonlyargs, ast2obj_arg);
4948 [ - + ]: 91523 : if (!value) goto failed;
4949 [ - + ]: 91523 : if (PyObject_SetAttr(result, state->posonlyargs, value) == -1)
4950 : 0 : goto failed;
4951 : 91523 : Py_DECREF(value);
4952 : 91523 : value = ast2obj_list(state, (asdl_seq*)o->args, ast2obj_arg);
4953 [ - + ]: 91523 : if (!value) goto failed;
4954 [ - + ]: 91523 : if (PyObject_SetAttr(result, state->args, value) == -1)
4955 : 0 : goto failed;
4956 : 91523 : Py_DECREF(value);
4957 : 91523 : value = ast2obj_arg(state, o->vararg);
4958 [ - + ]: 91523 : if (!value) goto failed;
4959 [ - + ]: 91523 : if (PyObject_SetAttr(result, state->vararg, value) == -1)
4960 : 0 : goto failed;
4961 : 91523 : Py_DECREF(value);
4962 : 91523 : value = ast2obj_list(state, (asdl_seq*)o->kwonlyargs, ast2obj_arg);
4963 [ - + ]: 91523 : if (!value) goto failed;
4964 [ - + ]: 91523 : if (PyObject_SetAttr(result, state->kwonlyargs, value) == -1)
4965 : 0 : goto failed;
4966 : 91523 : Py_DECREF(value);
4967 : 91523 : value = ast2obj_list(state, (asdl_seq*)o->kw_defaults, ast2obj_expr);
4968 [ - + ]: 91523 : if (!value) goto failed;
4969 [ - + ]: 91523 : if (PyObject_SetAttr(result, state->kw_defaults, value) == -1)
4970 : 0 : goto failed;
4971 : 91523 : Py_DECREF(value);
4972 : 91523 : value = ast2obj_arg(state, o->kwarg);
4973 [ - + ]: 91523 : if (!value) goto failed;
4974 [ - + ]: 91523 : if (PyObject_SetAttr(result, state->kwarg, value) == -1)
4975 : 0 : goto failed;
4976 : 91523 : Py_DECREF(value);
4977 : 91523 : value = ast2obj_list(state, (asdl_seq*)o->defaults, ast2obj_expr);
4978 [ - + ]: 91523 : if (!value) goto failed;
4979 [ - + ]: 91523 : if (PyObject_SetAttr(result, state->defaults, value) == -1)
4980 : 0 : goto failed;
4981 : 91523 : Py_DECREF(value);
4982 : 91523 : return result;
4983 : 0 : failed:
4984 : 0 : Py_XDECREF(value);
4985 : 0 : Py_XDECREF(result);
4986 : 0 : return NULL;
4987 : : }
4988 : :
4989 : : PyObject*
4990 : 310419 : ast2obj_arg(struct ast_state *state, void* _o)
4991 : : {
4992 : 310419 : arg_ty o = (arg_ty)_o;
4993 : 310419 : PyObject *result = NULL, *value = NULL;
4994 : : PyTypeObject *tp;
4995 [ + + ]: 310419 : if (!o) {
4996 : 177155 : Py_RETURN_NONE;
4997 : : }
4998 : 133264 : tp = (PyTypeObject *)state->arg_type;
4999 : 133264 : result = PyType_GenericNew(tp, NULL, NULL);
5000 [ - + ]: 133264 : if (!result) return NULL;
5001 : 133264 : value = ast2obj_identifier(state, o->arg);
5002 [ - + ]: 133264 : if (!value) goto failed;
5003 [ - + ]: 133264 : if (PyObject_SetAttr(result, state->arg, value) == -1)
5004 : 0 : goto failed;
5005 : 133264 : Py_DECREF(value);
5006 : 133264 : value = ast2obj_expr(state, o->annotation);
5007 [ - + ]: 133264 : if (!value) goto failed;
5008 [ - + ]: 133264 : if (PyObject_SetAttr(result, state->annotation, value) == -1)
5009 : 0 : goto failed;
5010 : 133264 : Py_DECREF(value);
5011 : 133264 : value = ast2obj_string(state, o->type_comment);
5012 [ - + ]: 133264 : if (!value) goto failed;
5013 [ - + ]: 133264 : if (PyObject_SetAttr(result, state->type_comment, value) == -1)
5014 : 0 : goto failed;
5015 : 133264 : Py_DECREF(value);
5016 : 133264 : value = ast2obj_int(state, o->lineno);
5017 [ - + ]: 133264 : if (!value) goto failed;
5018 [ - + ]: 133264 : if (PyObject_SetAttr(result, state->lineno, value) < 0)
5019 : 0 : goto failed;
5020 : 133264 : Py_DECREF(value);
5021 : 133264 : value = ast2obj_int(state, o->col_offset);
5022 [ - + ]: 133264 : if (!value) goto failed;
5023 [ - + ]: 133264 : if (PyObject_SetAttr(result, state->col_offset, value) < 0)
5024 : 0 : goto failed;
5025 : 133264 : Py_DECREF(value);
5026 : 133264 : value = ast2obj_int(state, o->end_lineno);
5027 [ - + ]: 133264 : if (!value) goto failed;
5028 [ - + ]: 133264 : if (PyObject_SetAttr(result, state->end_lineno, value) < 0)
5029 : 0 : goto failed;
5030 : 133264 : Py_DECREF(value);
5031 : 133264 : value = ast2obj_int(state, o->end_col_offset);
5032 [ - + ]: 133264 : if (!value) goto failed;
5033 [ - + ]: 133264 : if (PyObject_SetAttr(result, state->end_col_offset, value) < 0)
5034 : 0 : goto failed;
5035 : 133264 : Py_DECREF(value);
5036 : 133264 : return result;
5037 : 0 : failed:
5038 : 0 : Py_XDECREF(value);
5039 : 0 : Py_XDECREF(result);
5040 : 0 : return NULL;
5041 : : }
5042 : :
5043 : : PyObject*
5044 : 52206 : ast2obj_keyword(struct ast_state *state, void* _o)
5045 : : {
5046 : 52206 : keyword_ty o = (keyword_ty)_o;
5047 : 52206 : PyObject *result = NULL, *value = NULL;
5048 : : PyTypeObject *tp;
5049 [ - + ]: 52206 : if (!o) {
5050 : 0 : Py_RETURN_NONE;
5051 : : }
5052 : 52206 : tp = (PyTypeObject *)state->keyword_type;
5053 : 52206 : result = PyType_GenericNew(tp, NULL, NULL);
5054 [ - + ]: 52206 : if (!result) return NULL;
5055 : 52206 : value = ast2obj_identifier(state, o->arg);
5056 [ - + ]: 52206 : if (!value) goto failed;
5057 [ - + ]: 52206 : if (PyObject_SetAttr(result, state->arg, value) == -1)
5058 : 0 : goto failed;
5059 : 52206 : Py_DECREF(value);
5060 : 52206 : value = ast2obj_expr(state, o->value);
5061 [ - + ]: 52206 : if (!value) goto failed;
5062 [ - + ]: 52206 : if (PyObject_SetAttr(result, state->value, value) == -1)
5063 : 0 : goto failed;
5064 : 52206 : Py_DECREF(value);
5065 : 52206 : value = ast2obj_int(state, o->lineno);
5066 [ - + ]: 52206 : if (!value) goto failed;
5067 [ - + ]: 52206 : if (PyObject_SetAttr(result, state->lineno, value) < 0)
5068 : 0 : goto failed;
5069 : 52206 : Py_DECREF(value);
5070 : 52206 : value = ast2obj_int(state, o->col_offset);
5071 [ - + ]: 52206 : if (!value) goto failed;
5072 [ - + ]: 52206 : if (PyObject_SetAttr(result, state->col_offset, value) < 0)
5073 : 0 : goto failed;
5074 : 52206 : Py_DECREF(value);
5075 : 52206 : value = ast2obj_int(state, o->end_lineno);
5076 [ - + ]: 52206 : if (!value) goto failed;
5077 [ - + ]: 52206 : if (PyObject_SetAttr(result, state->end_lineno, value) < 0)
5078 : 0 : goto failed;
5079 : 52206 : Py_DECREF(value);
5080 : 52206 : value = ast2obj_int(state, o->end_col_offset);
5081 [ - + ]: 52206 : if (!value) goto failed;
5082 [ - + ]: 52206 : if (PyObject_SetAttr(result, state->end_col_offset, value) < 0)
5083 : 0 : goto failed;
5084 : 52206 : Py_DECREF(value);
5085 : 52206 : return result;
5086 : 0 : failed:
5087 : 0 : Py_XDECREF(value);
5088 : 0 : Py_XDECREF(result);
5089 : 0 : return NULL;
5090 : : }
5091 : :
5092 : : PyObject*
5093 : 17283 : ast2obj_alias(struct ast_state *state, void* _o)
5094 : : {
5095 : 17283 : alias_ty o = (alias_ty)_o;
5096 : 17283 : PyObject *result = NULL, *value = NULL;
5097 : : PyTypeObject *tp;
5098 [ - + ]: 17283 : if (!o) {
5099 : 0 : Py_RETURN_NONE;
5100 : : }
5101 : 17283 : tp = (PyTypeObject *)state->alias_type;
5102 : 17283 : result = PyType_GenericNew(tp, NULL, NULL);
5103 [ - + ]: 17283 : if (!result) return NULL;
5104 : 17283 : value = ast2obj_identifier(state, o->name);
5105 [ - + ]: 17283 : if (!value) goto failed;
5106 [ - + ]: 17283 : if (PyObject_SetAttr(result, state->name, value) == -1)
5107 : 0 : goto failed;
5108 : 17283 : Py_DECREF(value);
5109 : 17283 : value = ast2obj_identifier(state, o->asname);
5110 [ - + ]: 17283 : if (!value) goto failed;
5111 [ - + ]: 17283 : if (PyObject_SetAttr(result, state->asname, value) == -1)
5112 : 0 : goto failed;
5113 : 17283 : Py_DECREF(value);
5114 : 17283 : value = ast2obj_int(state, o->lineno);
5115 [ - + ]: 17283 : if (!value) goto failed;
5116 [ - + ]: 17283 : if (PyObject_SetAttr(result, state->lineno, value) < 0)
5117 : 0 : goto failed;
5118 : 17283 : Py_DECREF(value);
5119 : 17283 : value = ast2obj_int(state, o->col_offset);
5120 [ - + ]: 17283 : if (!value) goto failed;
5121 [ - + ]: 17283 : if (PyObject_SetAttr(result, state->col_offset, value) < 0)
5122 : 0 : goto failed;
5123 : 17283 : Py_DECREF(value);
5124 : 17283 : value = ast2obj_int(state, o->end_lineno);
5125 [ - + ]: 17283 : if (!value) goto failed;
5126 [ - + ]: 17283 : if (PyObject_SetAttr(result, state->end_lineno, value) < 0)
5127 : 0 : goto failed;
5128 : 17283 : Py_DECREF(value);
5129 : 17283 : value = ast2obj_int(state, o->end_col_offset);
5130 [ - + ]: 17283 : if (!value) goto failed;
5131 [ - + ]: 17283 : if (PyObject_SetAttr(result, state->end_col_offset, value) < 0)
5132 : 0 : goto failed;
5133 : 17283 : Py_DECREF(value);
5134 : 17283 : return result;
5135 : 0 : failed:
5136 : 0 : Py_XDECREF(value);
5137 : 0 : Py_XDECREF(result);
5138 : 0 : return NULL;
5139 : : }
5140 : :
5141 : : PyObject*
5142 : 18953 : ast2obj_withitem(struct ast_state *state, void* _o)
5143 : : {
5144 : 18953 : withitem_ty o = (withitem_ty)_o;
5145 : 18953 : PyObject *result = NULL, *value = NULL;
5146 : : PyTypeObject *tp;
5147 [ - + ]: 18953 : if (!o) {
5148 : 0 : Py_RETURN_NONE;
5149 : : }
5150 : 18953 : tp = (PyTypeObject *)state->withitem_type;
5151 : 18953 : result = PyType_GenericNew(tp, NULL, NULL);
5152 [ - + ]: 18953 : if (!result) return NULL;
5153 : 18953 : value = ast2obj_expr(state, o->context_expr);
5154 [ - + ]: 18953 : if (!value) goto failed;
5155 [ - + ]: 18953 : if (PyObject_SetAttr(result, state->context_expr, value) == -1)
5156 : 0 : goto failed;
5157 : 18953 : Py_DECREF(value);
5158 : 18953 : value = ast2obj_expr(state, o->optional_vars);
5159 [ - + ]: 18953 : if (!value) goto failed;
5160 [ - + ]: 18953 : if (PyObject_SetAttr(result, state->optional_vars, value) == -1)
5161 : 0 : goto failed;
5162 : 18953 : Py_DECREF(value);
5163 : 18953 : return result;
5164 : 0 : failed:
5165 : 0 : Py_XDECREF(value);
5166 : 0 : Py_XDECREF(result);
5167 : 0 : return NULL;
5168 : : }
5169 : :
5170 : : PyObject*
5171 : 798 : ast2obj_match_case(struct ast_state *state, void* _o)
5172 : : {
5173 : 798 : match_case_ty o = (match_case_ty)_o;
5174 : 798 : PyObject *result = NULL, *value = NULL;
5175 : : PyTypeObject *tp;
5176 [ - + ]: 798 : if (!o) {
5177 : 0 : Py_RETURN_NONE;
5178 : : }
5179 : 798 : tp = (PyTypeObject *)state->match_case_type;
5180 : 798 : result = PyType_GenericNew(tp, NULL, NULL);
5181 [ - + ]: 798 : if (!result) return NULL;
5182 : 798 : value = ast2obj_pattern(state, o->pattern);
5183 [ - + ]: 798 : if (!value) goto failed;
5184 [ - + ]: 798 : if (PyObject_SetAttr(result, state->pattern, value) == -1)
5185 : 0 : goto failed;
5186 : 798 : Py_DECREF(value);
5187 : 798 : value = ast2obj_expr(state, o->guard);
5188 [ - + ]: 798 : if (!value) goto failed;
5189 [ - + ]: 798 : if (PyObject_SetAttr(result, state->guard, value) == -1)
5190 : 0 : goto failed;
5191 : 798 : Py_DECREF(value);
5192 : 798 : value = ast2obj_list(state, (asdl_seq*)o->body, ast2obj_stmt);
5193 [ - + ]: 798 : if (!value) goto failed;
5194 [ - + ]: 798 : if (PyObject_SetAttr(result, state->body, value) == -1)
5195 : 0 : goto failed;
5196 : 798 : Py_DECREF(value);
5197 : 798 : return result;
5198 : 0 : failed:
5199 : 0 : Py_XDECREF(value);
5200 : 0 : Py_XDECREF(result);
5201 : 0 : return NULL;
5202 : : }
5203 : :
5204 : : PyObject*
5205 : 2560 : ast2obj_pattern(struct ast_state *state, void* _o)
5206 : : {
5207 : 2560 : pattern_ty o = (pattern_ty)_o;
5208 : 2560 : PyObject *result = NULL, *value = NULL;
5209 : : PyTypeObject *tp;
5210 [ + + ]: 2560 : if (!o) {
5211 : 474 : Py_RETURN_NONE;
5212 : : }
5213 [ + + + + : 2086 : switch (o->kind) {
+ + + +
- ]
5214 : 760 : case MatchValue_kind:
5215 : 760 : tp = (PyTypeObject *)state->MatchValue_type;
5216 : 760 : result = PyType_GenericNew(tp, NULL, NULL);
5217 [ - + ]: 760 : if (!result) goto failed;
5218 : 760 : value = ast2obj_expr(state, o->v.MatchValue.value);
5219 [ - + ]: 760 : if (!value) goto failed;
5220 [ - + ]: 760 : if (PyObject_SetAttr(result, state->value, value) == -1)
5221 : 0 : goto failed;
5222 : 760 : Py_DECREF(value);
5223 : 760 : break;
5224 : 24 : case MatchSingleton_kind:
5225 : 24 : tp = (PyTypeObject *)state->MatchSingleton_type;
5226 : 24 : result = PyType_GenericNew(tp, NULL, NULL);
5227 [ - + ]: 24 : if (!result) goto failed;
5228 : 24 : value = ast2obj_constant(state, o->v.MatchSingleton.value);
5229 [ - + ]: 24 : if (!value) goto failed;
5230 [ - + ]: 24 : if (PyObject_SetAttr(result, state->value, value) == -1)
5231 : 0 : goto failed;
5232 : 24 : Py_DECREF(value);
5233 : 24 : break;
5234 : 302 : case MatchSequence_kind:
5235 : 302 : tp = (PyTypeObject *)state->MatchSequence_type;
5236 : 302 : result = PyType_GenericNew(tp, NULL, NULL);
5237 [ - + ]: 302 : if (!result) goto failed;
5238 : 302 : value = ast2obj_list(state, (asdl_seq*)o->v.MatchSequence.patterns,
5239 : : ast2obj_pattern);
5240 [ - + ]: 302 : if (!value) goto failed;
5241 [ - + ]: 302 : if (PyObject_SetAttr(result, state->patterns, value) == -1)
5242 : 0 : goto failed;
5243 : 302 : Py_DECREF(value);
5244 : 302 : break;
5245 : 156 : case MatchMapping_kind:
5246 : 156 : tp = (PyTypeObject *)state->MatchMapping_type;
5247 : 156 : result = PyType_GenericNew(tp, NULL, NULL);
5248 [ - + ]: 156 : if (!result) goto failed;
5249 : 156 : value = ast2obj_list(state, (asdl_seq*)o->v.MatchMapping.keys,
5250 : : ast2obj_expr);
5251 [ - + ]: 156 : if (!value) goto failed;
5252 [ - + ]: 156 : if (PyObject_SetAttr(result, state->keys, value) == -1)
5253 : 0 : goto failed;
5254 : 156 : Py_DECREF(value);
5255 : 156 : value = ast2obj_list(state, (asdl_seq*)o->v.MatchMapping.patterns,
5256 : : ast2obj_pattern);
5257 [ - + ]: 156 : if (!value) goto failed;
5258 [ - + ]: 156 : if (PyObject_SetAttr(result, state->patterns, value) == -1)
5259 : 0 : goto failed;
5260 : 156 : Py_DECREF(value);
5261 : 156 : value = ast2obj_identifier(state, o->v.MatchMapping.rest);
5262 [ - + ]: 156 : if (!value) goto failed;
5263 [ - + ]: 156 : if (PyObject_SetAttr(result, state->rest, value) == -1)
5264 : 0 : goto failed;
5265 : 156 : Py_DECREF(value);
5266 : 156 : break;
5267 : 108 : case MatchClass_kind:
5268 : 108 : tp = (PyTypeObject *)state->MatchClass_type;
5269 : 108 : result = PyType_GenericNew(tp, NULL, NULL);
5270 [ - + ]: 108 : if (!result) goto failed;
5271 : 108 : value = ast2obj_expr(state, o->v.MatchClass.cls);
5272 [ - + ]: 108 : if (!value) goto failed;
5273 [ - + ]: 108 : if (PyObject_SetAttr(result, state->cls, value) == -1)
5274 : 0 : goto failed;
5275 : 108 : Py_DECREF(value);
5276 : 108 : value = ast2obj_list(state, (asdl_seq*)o->v.MatchClass.patterns,
5277 : : ast2obj_pattern);
5278 [ - + ]: 108 : if (!value) goto failed;
5279 [ - + ]: 108 : if (PyObject_SetAttr(result, state->patterns, value) == -1)
5280 : 0 : goto failed;
5281 : 108 : Py_DECREF(value);
5282 : 108 : value = ast2obj_list(state, (asdl_seq*)o->v.MatchClass.kwd_attrs,
5283 : : ast2obj_identifier);
5284 [ - + ]: 108 : if (!value) goto failed;
5285 [ - + ]: 108 : if (PyObject_SetAttr(result, state->kwd_attrs, value) == -1)
5286 : 0 : goto failed;
5287 : 108 : Py_DECREF(value);
5288 : 108 : value = ast2obj_list(state, (asdl_seq*)o->v.MatchClass.kwd_patterns,
5289 : : ast2obj_pattern);
5290 [ - + ]: 108 : if (!value) goto failed;
5291 [ - + ]: 108 : if (PyObject_SetAttr(result, state->kwd_patterns, value) == -1)
5292 : 0 : goto failed;
5293 : 108 : Py_DECREF(value);
5294 : 108 : break;
5295 : 72 : case MatchStar_kind:
5296 : 72 : tp = (PyTypeObject *)state->MatchStar_type;
5297 : 72 : result = PyType_GenericNew(tp, NULL, NULL);
5298 [ - + ]: 72 : if (!result) goto failed;
5299 : 72 : value = ast2obj_identifier(state, o->v.MatchStar.name);
5300 [ - + ]: 72 : if (!value) goto failed;
5301 [ - + ]: 72 : if (PyObject_SetAttr(result, state->name, value) == -1)
5302 : 0 : goto failed;
5303 : 72 : Py_DECREF(value);
5304 : 72 : break;
5305 : 564 : case MatchAs_kind:
5306 : 564 : tp = (PyTypeObject *)state->MatchAs_type;
5307 : 564 : result = PyType_GenericNew(tp, NULL, NULL);
5308 [ - + ]: 564 : if (!result) goto failed;
5309 : 564 : value = ast2obj_pattern(state, o->v.MatchAs.pattern);
5310 [ - + ]: 564 : if (!value) goto failed;
5311 [ - + ]: 564 : if (PyObject_SetAttr(result, state->pattern, value) == -1)
5312 : 0 : goto failed;
5313 : 564 : Py_DECREF(value);
5314 : 564 : value = ast2obj_identifier(state, o->v.MatchAs.name);
5315 [ - + ]: 564 : if (!value) goto failed;
5316 [ - + ]: 564 : if (PyObject_SetAttr(result, state->name, value) == -1)
5317 : 0 : goto failed;
5318 : 564 : Py_DECREF(value);
5319 : 564 : break;
5320 : 100 : case MatchOr_kind:
5321 : 100 : tp = (PyTypeObject *)state->MatchOr_type;
5322 : 100 : result = PyType_GenericNew(tp, NULL, NULL);
5323 [ - + ]: 100 : if (!result) goto failed;
5324 : 100 : value = ast2obj_list(state, (asdl_seq*)o->v.MatchOr.patterns,
5325 : : ast2obj_pattern);
5326 [ - + ]: 100 : if (!value) goto failed;
5327 [ - + ]: 100 : if (PyObject_SetAttr(result, state->patterns, value) == -1)
5328 : 0 : goto failed;
5329 : 100 : Py_DECREF(value);
5330 : 100 : break;
5331 : : }
5332 : 2086 : value = ast2obj_int(state, o->lineno);
5333 [ - + ]: 2086 : if (!value) goto failed;
5334 [ - + ]: 2086 : if (PyObject_SetAttr(result, state->lineno, value) < 0)
5335 : 0 : goto failed;
5336 : 2086 : Py_DECREF(value);
5337 : 2086 : value = ast2obj_int(state, o->col_offset);
5338 [ - + ]: 2086 : if (!value) goto failed;
5339 [ - + ]: 2086 : if (PyObject_SetAttr(result, state->col_offset, value) < 0)
5340 : 0 : goto failed;
5341 : 2086 : Py_DECREF(value);
5342 : 2086 : value = ast2obj_int(state, o->end_lineno);
5343 [ - + ]: 2086 : if (!value) goto failed;
5344 [ - + ]: 2086 : if (PyObject_SetAttr(result, state->end_lineno, value) < 0)
5345 : 0 : goto failed;
5346 : 2086 : Py_DECREF(value);
5347 : 2086 : value = ast2obj_int(state, o->end_col_offset);
5348 [ - + ]: 2086 : if (!value) goto failed;
5349 [ - + ]: 2086 : if (PyObject_SetAttr(result, state->end_col_offset, value) < 0)
5350 : 0 : goto failed;
5351 : 2086 : Py_DECREF(value);
5352 : 2086 : return result;
5353 : 0 : failed:
5354 : 0 : Py_XDECREF(value);
5355 : 0 : Py_XDECREF(result);
5356 : 0 : return NULL;
5357 : : }
5358 : :
5359 : : PyObject*
5360 : 74 : ast2obj_type_ignore(struct ast_state *state, void* _o)
5361 : : {
5362 : 74 : type_ignore_ty o = (type_ignore_ty)_o;
5363 : 74 : PyObject *result = NULL, *value = NULL;
5364 : : PyTypeObject *tp;
5365 [ - + ]: 74 : if (!o) {
5366 : 0 : Py_RETURN_NONE;
5367 : : }
5368 [ + - ]: 74 : switch (o->kind) {
5369 : 74 : case TypeIgnore_kind:
5370 : 74 : tp = (PyTypeObject *)state->TypeIgnore_type;
5371 : 74 : result = PyType_GenericNew(tp, NULL, NULL);
5372 [ - + ]: 74 : if (!result) goto failed;
5373 : 74 : value = ast2obj_int(state, o->v.TypeIgnore.lineno);
5374 [ - + ]: 74 : if (!value) goto failed;
5375 [ - + ]: 74 : if (PyObject_SetAttr(result, state->lineno, value) == -1)
5376 : 0 : goto failed;
5377 : 74 : Py_DECREF(value);
5378 : 74 : value = ast2obj_string(state, o->v.TypeIgnore.tag);
5379 [ - + ]: 74 : if (!value) goto failed;
5380 [ - + ]: 74 : if (PyObject_SetAttr(result, state->tag, value) == -1)
5381 : 0 : goto failed;
5382 : 74 : Py_DECREF(value);
5383 : 74 : break;
5384 : : }
5385 : 74 : return result;
5386 : 0 : failed:
5387 : 0 : Py_XDECREF(value);
5388 : 0 : Py_XDECREF(result);
5389 : 0 : return NULL;
5390 : : }
5391 : :
5392 : :
5393 : : int
5394 : 686 : obj2ast_mod(struct ast_state *state, PyObject* obj, mod_ty* out, PyArena* arena)
5395 : : {
5396 : : int isinstance;
5397 : :
5398 : 686 : PyObject *tmp = NULL;
5399 : : PyObject *tp;
5400 : :
5401 [ - + ]: 686 : if (obj == Py_None) {
5402 : 0 : *out = NULL;
5403 : 0 : return 0;
5404 : : }
5405 : 686 : tp = state->Module_type;
5406 : 686 : isinstance = PyObject_IsInstance(obj, tp);
5407 [ - + ]: 686 : if (isinstance == -1) {
5408 : 0 : return 1;
5409 : : }
5410 [ + + ]: 686 : if (isinstance) {
5411 : : asdl_stmt_seq* body;
5412 : : asdl_type_ignore_seq* type_ignores;
5413 : :
5414 [ - + ]: 573 : if (_PyObject_LookupAttr(obj, state->body, &tmp) < 0) {
5415 : 0 : return 1;
5416 : : }
5417 [ - + ]: 573 : if (tmp == NULL) {
5418 : 0 : PyErr_SetString(PyExc_TypeError, "required field \"body\" missing from Module");
5419 : 0 : return 1;
5420 : : }
5421 : : else {
5422 : : int res;
5423 : : Py_ssize_t len;
5424 : : Py_ssize_t i;
5425 [ - + ]: 573 : if (!PyList_Check(tmp)) {
5426 : 0 : PyErr_Format(PyExc_TypeError, "Module field \"body\" must be a list, not a %.200s", _PyType_Name(Py_TYPE(tmp)));
5427 : 0 : goto failed;
5428 : : }
5429 : 573 : len = PyList_GET_SIZE(tmp);
5430 : 573 : body = _Py_asdl_stmt_seq_new(len, arena);
5431 [ - + ]: 573 : if (body == NULL) goto failed;
5432 [ + + ]: 6673 : for (i = 0; i < len; i++) {
5433 : : stmt_ty val;
5434 : 6105 : PyObject *tmp2 = PyList_GET_ITEM(tmp, i);
5435 : 6105 : Py_INCREF(tmp2);
5436 [ - + ]: 6105 : if (_Py_EnterRecursiveCall(" while traversing 'Module' node")) {
5437 : 5 : goto failed;
5438 : : }
5439 : 6105 : res = obj2ast_stmt(state, tmp2, &val, arena);
5440 : 6105 : _Py_LeaveRecursiveCall();
5441 : 6105 : Py_DECREF(tmp2);
5442 [ + + ]: 6105 : if (res != 0) goto failed;
5443 [ - + ]: 6100 : if (len != PyList_GET_SIZE(tmp)) {
5444 : 0 : PyErr_SetString(PyExc_RuntimeError, "Module field \"body\" changed size during iteration");
5445 : 0 : goto failed;
5446 : : }
5447 : 6100 : asdl_seq_SET(body, i, val);
5448 : : }
5449 [ + - ]: 568 : Py_CLEAR(tmp);
5450 : : }
5451 [ - + ]: 568 : if (_PyObject_LookupAttr(obj, state->type_ignores, &tmp) < 0) {
5452 : 0 : return 1;
5453 : : }
5454 [ - + ]: 568 : if (tmp == NULL) {
5455 : 0 : PyErr_SetString(PyExc_TypeError, "required field \"type_ignores\" missing from Module");
5456 : 0 : return 1;
5457 : : }
5458 : : else {
5459 : : int res;
5460 : : Py_ssize_t len;
5461 : : Py_ssize_t i;
5462 [ - + ]: 568 : if (!PyList_Check(tmp)) {
5463 : 0 : PyErr_Format(PyExc_TypeError, "Module field \"type_ignores\" must be a list, not a %.200s", _PyType_Name(Py_TYPE(tmp)));
5464 : 0 : goto failed;
5465 : : }
5466 : 568 : len = PyList_GET_SIZE(tmp);
5467 : 568 : type_ignores = _Py_asdl_type_ignore_seq_new(len, arena);
5468 [ - + ]: 568 : if (type_ignores == NULL) goto failed;
5469 [ - + ]: 568 : for (i = 0; i < len; i++) {
5470 : : type_ignore_ty val;
5471 : 0 : PyObject *tmp2 = PyList_GET_ITEM(tmp, i);
5472 : 0 : Py_INCREF(tmp2);
5473 [ # # ]: 0 : if (_Py_EnterRecursiveCall(" while traversing 'Module' node")) {
5474 : 0 : goto failed;
5475 : : }
5476 : 0 : res = obj2ast_type_ignore(state, tmp2, &val, arena);
5477 : 0 : _Py_LeaveRecursiveCall();
5478 : 0 : Py_DECREF(tmp2);
5479 [ # # ]: 0 : if (res != 0) goto failed;
5480 [ # # ]: 0 : if (len != PyList_GET_SIZE(tmp)) {
5481 : 0 : PyErr_SetString(PyExc_RuntimeError, "Module field \"type_ignores\" changed size during iteration");
5482 : 0 : goto failed;
5483 : : }
5484 : 0 : asdl_seq_SET(type_ignores, i, val);
5485 : : }
5486 [ + - ]: 568 : Py_CLEAR(tmp);
5487 : : }
5488 : 568 : *out = _PyAST_Module(body, type_ignores, arena);
5489 [ - + ]: 568 : if (*out == NULL) goto failed;
5490 : 568 : return 0;
5491 : : }
5492 : 113 : tp = state->Interactive_type;
5493 : 113 : isinstance = PyObject_IsInstance(obj, tp);
5494 [ - + ]: 113 : if (isinstance == -1) {
5495 : 0 : return 1;
5496 : : }
5497 [ + + ]: 113 : if (isinstance) {
5498 : : asdl_stmt_seq* body;
5499 : :
5500 [ - + ]: 2 : if (_PyObject_LookupAttr(obj, state->body, &tmp) < 0) {
5501 : 0 : return 1;
5502 : : }
5503 [ - + ]: 2 : if (tmp == NULL) {
5504 : 0 : PyErr_SetString(PyExc_TypeError, "required field \"body\" missing from Interactive");
5505 : 0 : return 1;
5506 : : }
5507 : : else {
5508 : : int res;
5509 : : Py_ssize_t len;
5510 : : Py_ssize_t i;
5511 [ - + ]: 2 : if (!PyList_Check(tmp)) {
5512 : 0 : PyErr_Format(PyExc_TypeError, "Interactive field \"body\" must be a list, not a %.200s", _PyType_Name(Py_TYPE(tmp)));
5513 : 0 : goto failed;
5514 : : }
5515 : 2 : len = PyList_GET_SIZE(tmp);
5516 : 2 : body = _Py_asdl_stmt_seq_new(len, arena);
5517 [ - + ]: 2 : if (body == NULL) goto failed;
5518 [ + + ]: 4 : for (i = 0; i < len; i++) {
5519 : : stmt_ty val;
5520 : 2 : PyObject *tmp2 = PyList_GET_ITEM(tmp, i);
5521 : 2 : Py_INCREF(tmp2);
5522 [ - + ]: 2 : if (_Py_EnterRecursiveCall(" while traversing 'Interactive' node")) {
5523 : 0 : goto failed;
5524 : : }
5525 : 2 : res = obj2ast_stmt(state, tmp2, &val, arena);
5526 : 2 : _Py_LeaveRecursiveCall();
5527 : 2 : Py_DECREF(tmp2);
5528 [ - + ]: 2 : if (res != 0) goto failed;
5529 [ - + ]: 2 : if (len != PyList_GET_SIZE(tmp)) {
5530 : 0 : PyErr_SetString(PyExc_RuntimeError, "Interactive field \"body\" changed size during iteration");
5531 : 0 : goto failed;
5532 : : }
5533 : 2 : asdl_seq_SET(body, i, val);
5534 : : }
5535 [ + - ]: 2 : Py_CLEAR(tmp);
5536 : : }
5537 : 2 : *out = _PyAST_Interactive(body, arena);
5538 [ - + ]: 2 : if (*out == NULL) goto failed;
5539 : 2 : return 0;
5540 : : }
5541 : 111 : tp = state->Expression_type;
5542 : 111 : isinstance = PyObject_IsInstance(obj, tp);
5543 [ - + ]: 111 : if (isinstance == -1) {
5544 : 0 : return 1;
5545 : : }
5546 [ + - ]: 111 : if (isinstance) {
5547 : : expr_ty body;
5548 : :
5549 [ - + ]: 111 : if (_PyObject_LookupAttr(obj, state->body, &tmp) < 0) {
5550 : 109 : return 1;
5551 : : }
5552 [ - + ]: 111 : if (tmp == NULL) {
5553 : 0 : PyErr_SetString(PyExc_TypeError, "required field \"body\" missing from Expression");
5554 : 0 : return 1;
5555 : : }
5556 : : else {
5557 : : int res;
5558 [ - + ]: 111 : if (_Py_EnterRecursiveCall(" while traversing 'Expression' node")) {
5559 : 2 : goto failed;
5560 : : }
5561 : 111 : res = obj2ast_expr(state, tmp, &body, arena);
5562 : 111 : _Py_LeaveRecursiveCall();
5563 [ + + ]: 111 : if (res != 0) goto failed;
5564 [ + - ]: 109 : Py_CLEAR(tmp);
5565 : : }
5566 : 109 : *out = _PyAST_Expression(body, arena);
5567 [ - + ]: 109 : if (*out == NULL) goto failed;
5568 : 109 : return 0;
5569 : : }
5570 : 0 : tp = state->FunctionType_type;
5571 : 0 : isinstance = PyObject_IsInstance(obj, tp);
5572 [ # # ]: 0 : if (isinstance == -1) {
5573 : 0 : return 1;
5574 : : }
5575 [ # # ]: 0 : if (isinstance) {
5576 : : asdl_expr_seq* argtypes;
5577 : : expr_ty returns;
5578 : :
5579 [ # # ]: 0 : if (_PyObject_LookupAttr(obj, state->argtypes, &tmp) < 0) {
5580 : 0 : return 1;
5581 : : }
5582 [ # # ]: 0 : if (tmp == NULL) {
5583 : 0 : PyErr_SetString(PyExc_TypeError, "required field \"argtypes\" missing from FunctionType");
5584 : 0 : return 1;
5585 : : }
5586 : : else {
5587 : : int res;
5588 : : Py_ssize_t len;
5589 : : Py_ssize_t i;
5590 [ # # ]: 0 : if (!PyList_Check(tmp)) {
5591 : 0 : PyErr_Format(PyExc_TypeError, "FunctionType field \"argtypes\" must be a list, not a %.200s", _PyType_Name(Py_TYPE(tmp)));
5592 : 0 : goto failed;
5593 : : }
5594 : 0 : len = PyList_GET_SIZE(tmp);
5595 : 0 : argtypes = _Py_asdl_expr_seq_new(len, arena);
5596 [ # # ]: 0 : if (argtypes == NULL) goto failed;
5597 [ # # ]: 0 : for (i = 0; i < len; i++) {
5598 : : expr_ty val;
5599 : 0 : PyObject *tmp2 = PyList_GET_ITEM(tmp, i);
5600 : 0 : Py_INCREF(tmp2);
5601 [ # # ]: 0 : if (_Py_EnterRecursiveCall(" while traversing 'FunctionType' node")) {
5602 : 0 : goto failed;
5603 : : }
5604 : 0 : res = obj2ast_expr(state, tmp2, &val, arena);
5605 : 0 : _Py_LeaveRecursiveCall();
5606 : 0 : Py_DECREF(tmp2);
5607 [ # # ]: 0 : if (res != 0) goto failed;
5608 [ # # ]: 0 : if (len != PyList_GET_SIZE(tmp)) {
5609 : 0 : PyErr_SetString(PyExc_RuntimeError, "FunctionType field \"argtypes\" changed size during iteration");
5610 : 0 : goto failed;
5611 : : }
5612 : 0 : asdl_seq_SET(argtypes, i, val);
5613 : : }
5614 [ # # ]: 0 : Py_CLEAR(tmp);
5615 : : }
5616 [ # # ]: 0 : if (_PyObject_LookupAttr(obj, state->returns, &tmp) < 0) {
5617 : 0 : return 1;
5618 : : }
5619 [ # # ]: 0 : if (tmp == NULL) {
5620 : 0 : PyErr_SetString(PyExc_TypeError, "required field \"returns\" missing from FunctionType");
5621 : 0 : return 1;
5622 : : }
5623 : : else {
5624 : : int res;
5625 [ # # ]: 0 : if (_Py_EnterRecursiveCall(" while traversing 'FunctionType' node")) {
5626 : 0 : goto failed;
5627 : : }
5628 : 0 : res = obj2ast_expr(state, tmp, &returns, arena);
5629 : 0 : _Py_LeaveRecursiveCall();
5630 [ # # ]: 0 : if (res != 0) goto failed;
5631 [ # # ]: 0 : Py_CLEAR(tmp);
5632 : : }
5633 : 0 : *out = _PyAST_FunctionType(argtypes, returns, arena);
5634 [ # # ]: 0 : if (*out == NULL) goto failed;
5635 : 0 : return 0;
5636 : : }
5637 : :
5638 : 0 : PyErr_Format(PyExc_TypeError, "expected some sort of mod, but got %R", obj);
5639 : 7 : failed:
5640 : 7 : Py_XDECREF(tmp);
5641 : 7 : return 1;
5642 : : }
5643 : :
5644 : : int
5645 : 70005 : obj2ast_stmt(struct ast_state *state, PyObject* obj, stmt_ty* out, PyArena*
5646 : : arena)
5647 : : {
5648 : : int isinstance;
5649 : :
5650 : 70005 : PyObject *tmp = NULL;
5651 : : PyObject *tp;
5652 : : int lineno;
5653 : : int col_offset;
5654 : : int end_lineno;
5655 : : int end_col_offset;
5656 : :
5657 [ + + ]: 70005 : if (obj == Py_None) {
5658 : 1 : *out = NULL;
5659 : 1 : return 0;
5660 : : }
5661 [ - + ]: 70004 : if (_PyObject_LookupAttr(obj, state->lineno, &tmp) < 0) {
5662 : 0 : return 1;
5663 : : }
5664 [ + + ]: 70004 : if (tmp == NULL) {
5665 : 1 : PyErr_SetString(PyExc_TypeError, "required field \"lineno\" missing from stmt");
5666 : 1 : return 1;
5667 : : }
5668 : : else {
5669 : : int res;
5670 [ - + ]: 70003 : if (_Py_EnterRecursiveCall(" while traversing 'stmt' node")) {
5671 : 0 : goto failed;
5672 : : }
5673 : 70003 : res = obj2ast_int(state, tmp, &lineno, arena);
5674 : 70003 : _Py_LeaveRecursiveCall();
5675 [ + + ]: 70003 : if (res != 0) goto failed;
5676 [ + - ]: 70002 : Py_CLEAR(tmp);
5677 : : }
5678 [ - + ]: 70002 : if (_PyObject_LookupAttr(obj, state->col_offset, &tmp) < 0) {
5679 : 0 : return 1;
5680 : : }
5681 [ - + ]: 70002 : if (tmp == NULL) {
5682 : 0 : PyErr_SetString(PyExc_TypeError, "required field \"col_offset\" missing from stmt");
5683 : 0 : return 1;
5684 : : }
5685 : : else {
5686 : : int res;
5687 [ - + ]: 70002 : if (_Py_EnterRecursiveCall(" while traversing 'stmt' node")) {
5688 : 0 : goto failed;
5689 : : }
5690 : 70002 : res = obj2ast_int(state, tmp, &col_offset, arena);
5691 : 70002 : _Py_LeaveRecursiveCall();
5692 [ - + ]: 70002 : if (res != 0) goto failed;
5693 [ + - ]: 70002 : Py_CLEAR(tmp);
5694 : : }
5695 [ - + ]: 70002 : if (_PyObject_LookupAttr(obj, state->end_lineno, &tmp) < 0) {
5696 : 0 : return 1;
5697 : : }
5698 [ + - + + ]: 70002 : if (tmp == NULL || tmp == Py_None) {
5699 [ + - ]: 4 : Py_CLEAR(tmp);
5700 : 4 : end_lineno = lineno;
5701 : : }
5702 : : else {
5703 : : int res;
5704 [ - + ]: 69998 : if (_Py_EnterRecursiveCall(" while traversing 'stmt' node")) {
5705 : 0 : goto failed;
5706 : : }
5707 : 69998 : res = obj2ast_int(state, tmp, &end_lineno, arena);
5708 : 69998 : _Py_LeaveRecursiveCall();
5709 [ - + ]: 69998 : if (res != 0) goto failed;
5710 [ + - ]: 69998 : Py_CLEAR(tmp);
5711 : : }
5712 [ - + ]: 70002 : if (_PyObject_LookupAttr(obj, state->end_col_offset, &tmp) < 0) {
5713 : 0 : return 1;
5714 : : }
5715 [ + - + + ]: 70002 : if (tmp == NULL || tmp == Py_None) {
5716 [ + - ]: 4 : Py_CLEAR(tmp);
5717 : 4 : end_col_offset = col_offset;
5718 : : }
5719 : : else {
5720 : : int res;
5721 [ - + ]: 69998 : if (_Py_EnterRecursiveCall(" while traversing 'stmt' node")) {
5722 : 0 : goto failed;
5723 : : }
5724 : 69998 : res = obj2ast_int(state, tmp, &end_col_offset, arena);
5725 : 69998 : _Py_LeaveRecursiveCall();
5726 [ - + ]: 69998 : if (res != 0) goto failed;
5727 [ + - ]: 69998 : Py_CLEAR(tmp);
5728 : : }
5729 : 70002 : tp = state->FunctionDef_type;
5730 : 70002 : isinstance = PyObject_IsInstance(obj, tp);
5731 [ - + ]: 70002 : if (isinstance == -1) {
5732 : 0 : return 1;
5733 : : }
5734 [ + + ]: 70002 : if (isinstance) {
5735 : : identifier name;
5736 : : arguments_ty args;
5737 : : asdl_stmt_seq* body;
5738 : : asdl_expr_seq* decorator_list;
5739 : : expr_ty returns;
5740 : : string type_comment;
5741 : :
5742 [ - + ]: 7393 : if (_PyObject_LookupAttr(obj, state->name, &tmp) < 0) {
5743 : 7392 : return 1;
5744 : : }
5745 [ - + ]: 7393 : if (tmp == NULL) {
5746 : 0 : PyErr_SetString(PyExc_TypeError, "required field \"name\" missing from FunctionDef");
5747 : 0 : return 1;
5748 : : }
5749 : : else {
5750 : : int res;
5751 [ - + ]: 7393 : if (_Py_EnterRecursiveCall(" while traversing 'FunctionDef' node")) {
5752 : 1 : goto failed;
5753 : : }
5754 : 7393 : res = obj2ast_identifier(state, tmp, &name, arena);
5755 : 7393 : _Py_LeaveRecursiveCall();
5756 [ - + ]: 7393 : if (res != 0) goto failed;
5757 [ + - ]: 7393 : Py_CLEAR(tmp);
5758 : : }
5759 [ - + ]: 7393 : if (_PyObject_LookupAttr(obj, state->args, &tmp) < 0) {
5760 : 0 : return 1;
5761 : : }
5762 [ - + ]: 7393 : if (tmp == NULL) {
5763 : 0 : PyErr_SetString(PyExc_TypeError, "required field \"args\" missing from FunctionDef");
5764 : 0 : return 1;
5765 : : }
5766 : : else {
5767 : : int res;
5768 [ - + ]: 7393 : if (_Py_EnterRecursiveCall(" while traversing 'FunctionDef' node")) {
5769 : 0 : goto failed;
5770 : : }
5771 : 7393 : res = obj2ast_arguments(state, tmp, &args, arena);
5772 : 7393 : _Py_LeaveRecursiveCall();
5773 [ - + ]: 7393 : if (res != 0) goto failed;
5774 [ + - ]: 7393 : Py_CLEAR(tmp);
5775 : : }
5776 [ - + ]: 7393 : if (_PyObject_LookupAttr(obj, state->body, &tmp) < 0) {
5777 : 0 : return 1;
5778 : : }
5779 [ - + ]: 7393 : if (tmp == NULL) {
5780 : 0 : PyErr_SetString(PyExc_TypeError, "required field \"body\" missing from FunctionDef");
5781 : 0 : return 1;
5782 : : }
5783 : : else {
5784 : : int res;
5785 : : Py_ssize_t len;
5786 : : Py_ssize_t i;
5787 [ - + ]: 7393 : if (!PyList_Check(tmp)) {
5788 : 0 : PyErr_Format(PyExc_TypeError, "FunctionDef field \"body\" must be a list, not a %.200s", _PyType_Name(Py_TYPE(tmp)));
5789 : 0 : goto failed;
5790 : : }
5791 : 7393 : len = PyList_GET_SIZE(tmp);
5792 : 7393 : body = _Py_asdl_stmt_seq_new(len, arena);
5793 [ - + ]: 7393 : if (body == NULL) goto failed;
5794 [ + + ]: 34416 : for (i = 0; i < len; i++) {
5795 : : stmt_ty val;
5796 : 27024 : PyObject *tmp2 = PyList_GET_ITEM(tmp, i);
5797 : 27024 : Py_INCREF(tmp2);
5798 [ - + ]: 27024 : if (_Py_EnterRecursiveCall(" while traversing 'FunctionDef' node")) {
5799 : 1 : goto failed;
5800 : : }
5801 : 27024 : res = obj2ast_stmt(state, tmp2, &val, arena);
5802 : 27024 : _Py_LeaveRecursiveCall();
5803 : 27024 : Py_DECREF(tmp2);
5804 [ + + ]: 27024 : if (res != 0) goto failed;
5805 [ - + ]: 27023 : if (len != PyList_GET_SIZE(tmp)) {
5806 : 0 : PyErr_SetString(PyExc_RuntimeError, "FunctionDef field \"body\" changed size during iteration");
5807 : 0 : goto failed;
5808 : : }
5809 : 27023 : asdl_seq_SET(body, i, val);
5810 : : }
5811 [ + - ]: 7392 : Py_CLEAR(tmp);
5812 : : }
5813 [ - + ]: 7392 : if (_PyObject_LookupAttr(obj, state->decorator_list, &tmp) < 0) {
5814 : 0 : return 1;
5815 : : }
5816 [ - + ]: 7392 : if (tmp == NULL) {
5817 : 0 : PyErr_SetString(PyExc_TypeError, "required field \"decorator_list\" missing from FunctionDef");
5818 : 0 : return 1;
5819 : : }
5820 : : else {
5821 : : int res;
5822 : : Py_ssize_t len;
5823 : : Py_ssize_t i;
5824 [ - + ]: 7392 : if (!PyList_Check(tmp)) {
5825 : 0 : PyErr_Format(PyExc_TypeError, "FunctionDef field \"decorator_list\" must be a list, not a %.200s", _PyType_Name(Py_TYPE(tmp)));
5826 : 0 : goto failed;
5827 : : }
5828 : 7392 : len = PyList_GET_SIZE(tmp);
5829 : 7392 : decorator_list = _Py_asdl_expr_seq_new(len, arena);
5830 [ - + ]: 7392 : if (decorator_list == NULL) goto failed;
5831 [ + + ]: 8012 : for (i = 0; i < len; i++) {
5832 : : expr_ty val;
5833 : 620 : PyObject *tmp2 = PyList_GET_ITEM(tmp, i);
5834 : 620 : Py_INCREF(tmp2);
5835 [ - + ]: 620 : if (_Py_EnterRecursiveCall(" while traversing 'FunctionDef' node")) {
5836 : 0 : goto failed;
5837 : : }
5838 : 620 : res = obj2ast_expr(state, tmp2, &val, arena);
5839 : 620 : _Py_LeaveRecursiveCall();
5840 : 620 : Py_DECREF(tmp2);
5841 [ - + ]: 620 : if (res != 0) goto failed;
5842 [ - + ]: 620 : if (len != PyList_GET_SIZE(tmp)) {
5843 : 0 : PyErr_SetString(PyExc_RuntimeError, "FunctionDef field \"decorator_list\" changed size during iteration");
5844 : 0 : goto failed;
5845 : : }
5846 : 620 : asdl_seq_SET(decorator_list, i, val);
5847 : : }
5848 [ + - ]: 7392 : Py_CLEAR(tmp);
5849 : : }
5850 [ - + ]: 7392 : if (_PyObject_LookupAttr(obj, state->returns, &tmp) < 0) {
5851 : 0 : return 1;
5852 : : }
5853 [ + - + + ]: 7392 : if (tmp == NULL || tmp == Py_None) {
5854 [ + - ]: 7336 : Py_CLEAR(tmp);
5855 : 7336 : returns = NULL;
5856 : : }
5857 : : else {
5858 : : int res;
5859 [ - + ]: 56 : if (_Py_EnterRecursiveCall(" while traversing 'FunctionDef' node")) {
5860 : 0 : goto failed;
5861 : : }
5862 : 56 : res = obj2ast_expr(state, tmp, &returns, arena);
5863 : 56 : _Py_LeaveRecursiveCall();
5864 [ - + ]: 56 : if (res != 0) goto failed;
5865 [ + - ]: 56 : Py_CLEAR(tmp);
5866 : : }
5867 [ - + ]: 7392 : if (_PyObject_LookupAttr(obj, state->type_comment, &tmp) < 0) {
5868 : 0 : return 1;
5869 : : }
5870 [ + - + - ]: 7392 : if (tmp == NULL || tmp == Py_None) {
5871 [ + - ]: 7392 : Py_CLEAR(tmp);
5872 : 7392 : type_comment = NULL;
5873 : : }
5874 : : else {
5875 : : int res;
5876 [ # # ]: 0 : if (_Py_EnterRecursiveCall(" while traversing 'FunctionDef' node")) {
5877 : 0 : goto failed;
5878 : : }
5879 : 0 : res = obj2ast_string(state, tmp, &type_comment, arena);
5880 : 0 : _Py_LeaveRecursiveCall();
5881 [ # # ]: 0 : if (res != 0) goto failed;
5882 [ # # ]: 0 : Py_CLEAR(tmp);
5883 : : }
5884 : 7392 : *out = _PyAST_FunctionDef(name, args, body, decorator_list, returns,
5885 : : type_comment, lineno, col_offset, end_lineno,
5886 : : end_col_offset, arena);
5887 [ - + ]: 7392 : if (*out == NULL) goto failed;
5888 : 7392 : return 0;
5889 : : }
5890 : 62609 : tp = state->AsyncFunctionDef_type;
5891 : 62609 : isinstance = PyObject_IsInstance(obj, tp);
5892 [ - + ]: 62609 : if (isinstance == -1) {
5893 : 0 : return 1;
5894 : : }
5895 [ + + ]: 62609 : if (isinstance) {
5896 : : identifier name;
5897 : : arguments_ty args;
5898 : : asdl_stmt_seq* body;
5899 : : asdl_expr_seq* decorator_list;
5900 : : expr_ty returns;
5901 : : string type_comment;
5902 : :
5903 [ - + ]: 41 : if (_PyObject_LookupAttr(obj, state->name, &tmp) < 0) {
5904 : 41 : return 1;
5905 : : }
5906 [ - + ]: 41 : if (tmp == NULL) {
5907 : 0 : PyErr_SetString(PyExc_TypeError, "required field \"name\" missing from AsyncFunctionDef");
5908 : 0 : return 1;
5909 : : }
5910 : : else {
5911 : : int res;
5912 [ - + ]: 41 : if (_Py_EnterRecursiveCall(" while traversing 'AsyncFunctionDef' node")) {
5913 : 0 : goto failed;
5914 : : }
5915 : 41 : res = obj2ast_identifier(state, tmp, &name, arena);
5916 : 41 : _Py_LeaveRecursiveCall();
5917 [ - + ]: 41 : if (res != 0) goto failed;
5918 [ + - ]: 41 : Py_CLEAR(tmp);
5919 : : }
5920 [ - + ]: 41 : if (_PyObject_LookupAttr(obj, state->args, &tmp) < 0) {
5921 : 0 : return 1;
5922 : : }
5923 [ - + ]: 41 : if (tmp == NULL) {
5924 : 0 : PyErr_SetString(PyExc_TypeError, "required field \"args\" missing from AsyncFunctionDef");
5925 : 0 : return 1;
5926 : : }
5927 : : else {
5928 : : int res;
5929 [ - + ]: 41 : if (_Py_EnterRecursiveCall(" while traversing 'AsyncFunctionDef' node")) {
5930 : 0 : goto failed;
5931 : : }
5932 : 41 : res = obj2ast_arguments(state, tmp, &args, arena);
5933 : 41 : _Py_LeaveRecursiveCall();
5934 [ - + ]: 41 : if (res != 0) goto failed;
5935 [ + - ]: 41 : Py_CLEAR(tmp);
5936 : : }
5937 [ - + ]: 41 : if (_PyObject_LookupAttr(obj, state->body, &tmp) < 0) {
5938 : 0 : return 1;
5939 : : }
5940 [ - + ]: 41 : if (tmp == NULL) {
5941 : 0 : PyErr_SetString(PyExc_TypeError, "required field \"body\" missing from AsyncFunctionDef");
5942 : 0 : return 1;
5943 : : }
5944 : : else {
5945 : : int res;
5946 : : Py_ssize_t len;
5947 : : Py_ssize_t i;
5948 [ - + ]: 41 : if (!PyList_Check(tmp)) {
5949 : 0 : PyErr_Format(PyExc_TypeError, "AsyncFunctionDef field \"body\" must be a list, not a %.200s", _PyType_Name(Py_TYPE(tmp)));
5950 : 0 : goto failed;
5951 : : }
5952 : 41 : len = PyList_GET_SIZE(tmp);
5953 : 41 : body = _Py_asdl_stmt_seq_new(len, arena);
5954 [ - + ]: 41 : if (body == NULL) goto failed;
5955 [ + + ]: 117 : for (i = 0; i < len; i++) {
5956 : : stmt_ty val;
5957 : 76 : PyObject *tmp2 = PyList_GET_ITEM(tmp, i);
5958 : 76 : Py_INCREF(tmp2);
5959 [ - + ]: 76 : if (_Py_EnterRecursiveCall(" while traversing 'AsyncFunctionDef' node")) {
5960 : 0 : goto failed;
5961 : : }
5962 : 76 : res = obj2ast_stmt(state, tmp2, &val, arena);
5963 : 76 : _Py_LeaveRecursiveCall();
5964 : 76 : Py_DECREF(tmp2);
5965 [ - + ]: 76 : if (res != 0) goto failed;
5966 [ - + ]: 76 : if (len != PyList_GET_SIZE(tmp)) {
5967 : 0 : PyErr_SetString(PyExc_RuntimeError, "AsyncFunctionDef field \"body\" changed size during iteration");
5968 : 0 : goto failed;
5969 : : }
5970 : 76 : asdl_seq_SET(body, i, val);
5971 : : }
5972 [ + - ]: 41 : Py_CLEAR(tmp);
5973 : : }
5974 [ - + ]: 41 : if (_PyObject_LookupAttr(obj, state->decorator_list, &tmp) < 0) {
5975 : 0 : return 1;
5976 : : }
5977 [ - + ]: 41 : if (tmp == NULL) {
5978 : 0 : PyErr_SetString(PyExc_TypeError, "required field \"decorator_list\" missing from AsyncFunctionDef");
5979 : 0 : return 1;
5980 : : }
5981 : : else {
5982 : : int res;
5983 : : Py_ssize_t len;
5984 : : Py_ssize_t i;
5985 [ - + ]: 41 : if (!PyList_Check(tmp)) {
5986 : 0 : PyErr_Format(PyExc_TypeError, "AsyncFunctionDef field \"decorator_list\" must be a list, not a %.200s", _PyType_Name(Py_TYPE(tmp)));
5987 : 0 : goto failed;
5988 : : }
5989 : 41 : len = PyList_GET_SIZE(tmp);
5990 : 41 : decorator_list = _Py_asdl_expr_seq_new(len, arena);
5991 [ - + ]: 41 : if (decorator_list == NULL) goto failed;
5992 [ + + ]: 53 : for (i = 0; i < len; i++) {
5993 : : expr_ty val;
5994 : 12 : PyObject *tmp2 = PyList_GET_ITEM(tmp, i);
5995 : 12 : Py_INCREF(tmp2);
5996 [ - + ]: 12 : if (_Py_EnterRecursiveCall(" while traversing 'AsyncFunctionDef' node")) {
5997 : 0 : goto failed;
5998 : : }
5999 : 12 : res = obj2ast_expr(state, tmp2, &val, arena);
6000 : 12 : _Py_LeaveRecursiveCall();
6001 : 12 : Py_DECREF(tmp2);
6002 [ - + ]: 12 : if (res != 0) goto failed;
6003 [ - + ]: 12 : if (len != PyList_GET_SIZE(tmp)) {
6004 : 0 : PyErr_SetString(PyExc_RuntimeError, "AsyncFunctionDef field \"decorator_list\" changed size during iteration");
6005 : 0 : goto failed;
6006 : : }
6007 : 12 : asdl_seq_SET(decorator_list, i, val);
6008 : : }
6009 [ + - ]: 41 : Py_CLEAR(tmp);
6010 : : }
6011 [ - + ]: 41 : if (_PyObject_LookupAttr(obj, state->returns, &tmp) < 0) {
6012 : 0 : return 1;
6013 : : }
6014 [ + - + - ]: 41 : if (tmp == NULL || tmp == Py_None) {
6015 [ + - ]: 41 : Py_CLEAR(tmp);
6016 : 41 : returns = NULL;
6017 : : }
6018 : : else {
6019 : : int res;
6020 [ # # ]: 0 : if (_Py_EnterRecursiveCall(" while traversing 'AsyncFunctionDef' node")) {
6021 : 0 : goto failed;
6022 : : }
6023 : 0 : res = obj2ast_expr(state, tmp, &returns, arena);
6024 : 0 : _Py_LeaveRecursiveCall();
6025 [ # # ]: 0 : if (res != 0) goto failed;
6026 [ # # ]: 0 : Py_CLEAR(tmp);
6027 : : }
6028 [ - + ]: 41 : if (_PyObject_LookupAttr(obj, state->type_comment, &tmp) < 0) {
6029 : 0 : return 1;
6030 : : }
6031 [ + - + - ]: 41 : if (tmp == NULL || tmp == Py_None) {
6032 [ + - ]: 41 : Py_CLEAR(tmp);
6033 : 41 : type_comment = NULL;
6034 : : }
6035 : : else {
6036 : : int res;
6037 [ # # ]: 0 : if (_Py_EnterRecursiveCall(" while traversing 'AsyncFunctionDef' node")) {
6038 : 0 : goto failed;
6039 : : }
6040 : 0 : res = obj2ast_string(state, tmp, &type_comment, arena);
6041 : 0 : _Py_LeaveRecursiveCall();
6042 [ # # ]: 0 : if (res != 0) goto failed;
6043 [ # # ]: 0 : Py_CLEAR(tmp);
6044 : : }
6045 : 41 : *out = _PyAST_AsyncFunctionDef(name, args, body, decorator_list,
6046 : : returns, type_comment, lineno,
6047 : : col_offset, end_lineno, end_col_offset,
6048 : : arena);
6049 [ - + ]: 41 : if (*out == NULL) goto failed;
6050 : 41 : return 0;
6051 : : }
6052 : 62568 : tp = state->ClassDef_type;
6053 : 62568 : isinstance = PyObject_IsInstance(obj, tp);
6054 [ - + ]: 62568 : if (isinstance == -1) {
6055 : 0 : return 1;
6056 : : }
6057 [ + + ]: 62568 : if (isinstance) {
6058 : : identifier name;
6059 : : asdl_expr_seq* bases;
6060 : : asdl_keyword_seq* keywords;
6061 : : asdl_stmt_seq* body;
6062 : : asdl_expr_seq* decorator_list;
6063 : :
6064 [ - + ]: 829 : if (_PyObject_LookupAttr(obj, state->name, &tmp) < 0) {
6065 : 829 : return 1;
6066 : : }
6067 [ - + ]: 829 : if (tmp == NULL) {
6068 : 0 : PyErr_SetString(PyExc_TypeError, "required field \"name\" missing from ClassDef");
6069 : 0 : return 1;
6070 : : }
6071 : : else {
6072 : : int res;
6073 [ - + ]: 829 : if (_Py_EnterRecursiveCall(" while traversing 'ClassDef' node")) {
6074 : 0 : goto failed;
6075 : : }
6076 : 829 : res = obj2ast_identifier(state, tmp, &name, arena);
6077 : 829 : _Py_LeaveRecursiveCall();
6078 [ - + ]: 829 : if (res != 0) goto failed;
6079 [ + - ]: 829 : Py_CLEAR(tmp);
6080 : : }
6081 [ - + ]: 829 : if (_PyObject_LookupAttr(obj, state->bases, &tmp) < 0) {
6082 : 0 : return 1;
6083 : : }
6084 [ - + ]: 829 : if (tmp == NULL) {
6085 : 0 : PyErr_SetString(PyExc_TypeError, "required field \"bases\" missing from ClassDef");
6086 : 0 : return 1;
6087 : : }
6088 : : else {
6089 : : int res;
6090 : : Py_ssize_t len;
6091 : : Py_ssize_t i;
6092 [ - + ]: 829 : if (!PyList_Check(tmp)) {
6093 : 0 : PyErr_Format(PyExc_TypeError, "ClassDef field \"bases\" must be a list, not a %.200s", _PyType_Name(Py_TYPE(tmp)));
6094 : 0 : goto failed;
6095 : : }
6096 : 829 : len = PyList_GET_SIZE(tmp);
6097 : 829 : bases = _Py_asdl_expr_seq_new(len, arena);
6098 [ - + ]: 829 : if (bases == NULL) goto failed;
6099 [ + + ]: 1444 : for (i = 0; i < len; i++) {
6100 : : expr_ty val;
6101 : 615 : PyObject *tmp2 = PyList_GET_ITEM(tmp, i);
6102 : 615 : Py_INCREF(tmp2);
6103 [ - + ]: 615 : if (_Py_EnterRecursiveCall(" while traversing 'ClassDef' node")) {
6104 : 0 : goto failed;
6105 : : }
6106 : 615 : res = obj2ast_expr(state, tmp2, &val, arena);
6107 : 615 : _Py_LeaveRecursiveCall();
6108 : 615 : Py_DECREF(tmp2);
6109 [ - + ]: 615 : if (res != 0) goto failed;
6110 [ - + ]: 615 : if (len != PyList_GET_SIZE(tmp)) {
6111 : 0 : PyErr_SetString(PyExc_RuntimeError, "ClassDef field \"bases\" changed size during iteration");
6112 : 0 : goto failed;
6113 : : }
6114 : 615 : asdl_seq_SET(bases, i, val);
6115 : : }
6116 [ + - ]: 829 : Py_CLEAR(tmp);
6117 : : }
6118 [ - + ]: 829 : if (_PyObject_LookupAttr(obj, state->keywords, &tmp) < 0) {
6119 : 0 : return 1;
6120 : : }
6121 [ - + ]: 829 : if (tmp == NULL) {
6122 : 0 : PyErr_SetString(PyExc_TypeError, "required field \"keywords\" missing from ClassDef");
6123 : 0 : return 1;
6124 : : }
6125 : : else {
6126 : : int res;
6127 : : Py_ssize_t len;
6128 : : Py_ssize_t i;
6129 [ - + ]: 829 : if (!PyList_Check(tmp)) {
6130 : 0 : PyErr_Format(PyExc_TypeError, "ClassDef field \"keywords\" must be a list, not a %.200s", _PyType_Name(Py_TYPE(tmp)));
6131 : 0 : goto failed;
6132 : : }
6133 : 829 : len = PyList_GET_SIZE(tmp);
6134 : 829 : keywords = _Py_asdl_keyword_seq_new(len, arena);
6135 [ - + ]: 829 : if (keywords == NULL) goto failed;
6136 [ + + ]: 874 : for (i = 0; i < len; i++) {
6137 : : keyword_ty val;
6138 : 45 : PyObject *tmp2 = PyList_GET_ITEM(tmp, i);
6139 : 45 : Py_INCREF(tmp2);
6140 [ - + ]: 45 : if (_Py_EnterRecursiveCall(" while traversing 'ClassDef' node")) {
6141 : 0 : goto failed;
6142 : : }
6143 : 45 : res = obj2ast_keyword(state, tmp2, &val, arena);
6144 : 45 : _Py_LeaveRecursiveCall();
6145 : 45 : Py_DECREF(tmp2);
6146 [ - + ]: 45 : if (res != 0) goto failed;
6147 [ - + ]: 45 : if (len != PyList_GET_SIZE(tmp)) {
6148 : 0 : PyErr_SetString(PyExc_RuntimeError, "ClassDef field \"keywords\" changed size during iteration");
6149 : 0 : goto failed;
6150 : : }
6151 : 45 : asdl_seq_SET(keywords, i, val);
6152 : : }
6153 [ + - ]: 829 : Py_CLEAR(tmp);
6154 : : }
6155 [ - + ]: 829 : if (_PyObject_LookupAttr(obj, state->body, &tmp) < 0) {
6156 : 0 : return 1;
6157 : : }
6158 [ - + ]: 829 : if (tmp == NULL) {
6159 : 0 : PyErr_SetString(PyExc_TypeError, "required field \"body\" missing from ClassDef");
6160 : 0 : return 1;
6161 : : }
6162 : : else {
6163 : : int res;
6164 : : Py_ssize_t len;
6165 : : Py_ssize_t i;
6166 [ - + ]: 829 : if (!PyList_Check(tmp)) {
6167 : 0 : PyErr_Format(PyExc_TypeError, "ClassDef field \"body\" must be a list, not a %.200s", _PyType_Name(Py_TYPE(tmp)));
6168 : 0 : goto failed;
6169 : : }
6170 : 829 : len = PyList_GET_SIZE(tmp);
6171 : 829 : body = _Py_asdl_stmt_seq_new(len, arena);
6172 [ - + ]: 829 : if (body == NULL) goto failed;
6173 [ + + ]: 7703 : for (i = 0; i < len; i++) {
6174 : : stmt_ty val;
6175 : 6874 : PyObject *tmp2 = PyList_GET_ITEM(tmp, i);
6176 : 6874 : Py_INCREF(tmp2);
6177 [ - + ]: 6874 : if (_Py_EnterRecursiveCall(" while traversing 'ClassDef' node")) {
6178 : 0 : goto failed;
6179 : : }
6180 : 6874 : res = obj2ast_stmt(state, tmp2, &val, arena);
6181 : 6874 : _Py_LeaveRecursiveCall();
6182 : 6874 : Py_DECREF(tmp2);
6183 [ - + ]: 6874 : if (res != 0) goto failed;
6184 [ - + ]: 6874 : if (len != PyList_GET_SIZE(tmp)) {
6185 : 0 : PyErr_SetString(PyExc_RuntimeError, "ClassDef field \"body\" changed size during iteration");
6186 : 0 : goto failed;
6187 : : }
6188 : 6874 : asdl_seq_SET(body, i, val);
6189 : : }
6190 [ + - ]: 829 : Py_CLEAR(tmp);
6191 : : }
6192 [ - + ]: 829 : if (_PyObject_LookupAttr(obj, state->decorator_list, &tmp) < 0) {
6193 : 0 : return 1;
6194 : : }
6195 [ - + ]: 829 : if (tmp == NULL) {
6196 : 0 : PyErr_SetString(PyExc_TypeError, "required field \"decorator_list\" missing from ClassDef");
6197 : 0 : return 1;
6198 : : }
6199 : : else {
6200 : : int res;
6201 : : Py_ssize_t len;
6202 : : Py_ssize_t i;
6203 [ - + ]: 829 : if (!PyList_Check(tmp)) {
6204 : 0 : PyErr_Format(PyExc_TypeError, "ClassDef field \"decorator_list\" must be a list, not a %.200s", _PyType_Name(Py_TYPE(tmp)));
6205 : 0 : goto failed;
6206 : : }
6207 : 829 : len = PyList_GET_SIZE(tmp);
6208 : 829 : decorator_list = _Py_asdl_expr_seq_new(len, arena);
6209 [ - + ]: 829 : if (decorator_list == NULL) goto failed;
6210 [ + + ]: 865 : for (i = 0; i < len; i++) {
6211 : : expr_ty val;
6212 : 36 : PyObject *tmp2 = PyList_GET_ITEM(tmp, i);
6213 : 36 : Py_INCREF(tmp2);
6214 [ - + ]: 36 : if (_Py_EnterRecursiveCall(" while traversing 'ClassDef' node")) {
6215 : 0 : goto failed;
6216 : : }
6217 : 36 : res = obj2ast_expr(state, tmp2, &val, arena);
6218 : 36 : _Py_LeaveRecursiveCall();
6219 : 36 : Py_DECREF(tmp2);
6220 [ - + ]: 36 : if (res != 0) goto failed;
6221 [ - + ]: 36 : if (len != PyList_GET_SIZE(tmp)) {
6222 : 0 : PyErr_SetString(PyExc_RuntimeError, "ClassDef field \"decorator_list\" changed size during iteration");
6223 : 0 : goto failed;
6224 : : }
6225 : 36 : asdl_seq_SET(decorator_list, i, val);
6226 : : }
6227 [ + - ]: 829 : Py_CLEAR(tmp);
6228 : : }
6229 : 829 : *out = _PyAST_ClassDef(name, bases, keywords, body, decorator_list,
6230 : : lineno, col_offset, end_lineno, end_col_offset,
6231 : : arena);
6232 [ - + ]: 829 : if (*out == NULL) goto failed;
6233 : 829 : return 0;
6234 : : }
6235 : 61739 : tp = state->Return_type;
6236 : 61739 : isinstance = PyObject_IsInstance(obj, tp);
6237 [ - + ]: 61739 : if (isinstance == -1) {
6238 : 0 : return 1;
6239 : : }
6240 [ + + ]: 61739 : if (isinstance) {
6241 : : expr_ty value;
6242 : :
6243 [ - + ]: 7068 : if (_PyObject_LookupAttr(obj, state->value, &tmp) < 0) {
6244 : 7068 : return 1;
6245 : : }
6246 [ + - + + ]: 7068 : if (tmp == NULL || tmp == Py_None) {
6247 [ + - ]: 340 : Py_CLEAR(tmp);
6248 : 340 : value = NULL;
6249 : : }
6250 : : else {
6251 : : int res;
6252 [ - + ]: 6728 : if (_Py_EnterRecursiveCall(" while traversing 'Return' node")) {
6253 : 0 : goto failed;
6254 : : }
6255 : 6728 : res = obj2ast_expr(state, tmp, &value, arena);
6256 : 6728 : _Py_LeaveRecursiveCall();
6257 [ - + ]: 6728 : if (res != 0) goto failed;
6258 [ + - ]: 6728 : Py_CLEAR(tmp);
6259 : : }
6260 : 7068 : *out = _PyAST_Return(value, lineno, col_offset, end_lineno,
6261 : : end_col_offset, arena);
6262 [ - + ]: 7068 : if (*out == NULL) goto failed;
6263 : 7068 : return 0;
6264 : : }
6265 : 54671 : tp = state->Delete_type;
6266 : 54671 : isinstance = PyObject_IsInstance(obj, tp);
6267 [ - + ]: 54671 : if (isinstance == -1) {
6268 : 0 : return 1;
6269 : : }
6270 [ + + ]: 54671 : if (isinstance) {
6271 : : asdl_expr_seq* targets;
6272 : :
6273 [ - + ]: 223 : if (_PyObject_LookupAttr(obj, state->targets, &tmp) < 0) {
6274 : 0 : return 1;
6275 : : }
6276 [ - + ]: 223 : if (tmp == NULL) {
6277 : 0 : PyErr_SetString(PyExc_TypeError, "required field \"targets\" missing from Delete");
6278 : 0 : return 1;
6279 : : }
6280 : : else {
6281 : : int res;
6282 : : Py_ssize_t len;
6283 : : Py_ssize_t i;
6284 [ - + ]: 223 : if (!PyList_Check(tmp)) {
6285 : 0 : PyErr_Format(PyExc_TypeError, "Delete field \"targets\" must be a list, not a %.200s", _PyType_Name(Py_TYPE(tmp)));
6286 : 0 : goto failed;
6287 : : }
6288 : 223 : len = PyList_GET_SIZE(tmp);
6289 : 223 : targets = _Py_asdl_expr_seq_new(len, arena);
6290 [ - + ]: 223 : if (targets == NULL) goto failed;
6291 [ + + ]: 489 : for (i = 0; i < len; i++) {
6292 : : expr_ty val;
6293 : 266 : PyObject *tmp2 = PyList_GET_ITEM(tmp, i);
6294 : 266 : Py_INCREF(tmp2);
6295 [ - + ]: 266 : if (_Py_EnterRecursiveCall(" while traversing 'Delete' node")) {
6296 : 0 : goto failed;
6297 : : }
6298 : 266 : res = obj2ast_expr(state, tmp2, &val, arena);
6299 : 266 : _Py_LeaveRecursiveCall();
6300 : 266 : Py_DECREF(tmp2);
6301 [ - + ]: 266 : if (res != 0) goto failed;
6302 [ - + ]: 266 : if (len != PyList_GET_SIZE(tmp)) {
6303 : 0 : PyErr_SetString(PyExc_RuntimeError, "Delete field \"targets\" changed size during iteration");
6304 : 0 : goto failed;
6305 : : }
6306 : 266 : asdl_seq_SET(targets, i, val);
6307 : : }
6308 [ + - ]: 223 : Py_CLEAR(tmp);
6309 : : }
6310 : 223 : *out = _PyAST_Delete(targets, lineno, col_offset, end_lineno,
6311 : : end_col_offset, arena);
6312 [ - + ]: 223 : if (*out == NULL) goto failed;
6313 : 223 : return 0;
6314 : : }
6315 : 54448 : tp = state->Assign_type;
6316 : 54448 : isinstance = PyObject_IsInstance(obj, tp);
6317 [ - + ]: 54448 : if (isinstance == -1) {
6318 : 0 : return 1;
6319 : : }
6320 [ + + ]: 54448 : if (isinstance) {
6321 : : asdl_expr_seq* targets;
6322 : : expr_ty value;
6323 : : string type_comment;
6324 : :
6325 [ - + ]: 20863 : if (_PyObject_LookupAttr(obj, state->targets, &tmp) < 0) {
6326 : 20863 : return 1;
6327 : : }
6328 [ - + ]: 20863 : if (tmp == NULL) {
6329 : 0 : PyErr_SetString(PyExc_TypeError, "required field \"targets\" missing from Assign");
6330 : 0 : return 1;
6331 : : }
6332 : : else {
6333 : : int res;
6334 : : Py_ssize_t len;
6335 : : Py_ssize_t i;
6336 [ - + ]: 20863 : if (!PyList_Check(tmp)) {
6337 : 0 : PyErr_Format(PyExc_TypeError, "Assign field \"targets\" must be a list, not a %.200s", _PyType_Name(Py_TYPE(tmp)));
6338 : 0 : goto failed;
6339 : : }
6340 : 20863 : len = PyList_GET_SIZE(tmp);
6341 : 20863 : targets = _Py_asdl_expr_seq_new(len, arena);
6342 [ - + ]: 20863 : if (targets == NULL) goto failed;
6343 [ + + ]: 41927 : for (i = 0; i < len; i++) {
6344 : : expr_ty val;
6345 : 21064 : PyObject *tmp2 = PyList_GET_ITEM(tmp, i);
6346 : 21064 : Py_INCREF(tmp2);
6347 [ - + ]: 21064 : if (_Py_EnterRecursiveCall(" while traversing 'Assign' node")) {
6348 : 0 : goto failed;
6349 : : }
6350 : 21064 : res = obj2ast_expr(state, tmp2, &val, arena);
6351 : 21064 : _Py_LeaveRecursiveCall();
6352 : 21064 : Py_DECREF(tmp2);
6353 [ - + ]: 21064 : if (res != 0) goto failed;
6354 [ - + ]: 21064 : if (len != PyList_GET_SIZE(tmp)) {
6355 : 0 : PyErr_SetString(PyExc_RuntimeError, "Assign field \"targets\" changed size during iteration");
6356 : 0 : goto failed;
6357 : : }
6358 : 21064 : asdl_seq_SET(targets, i, val);
6359 : : }
6360 [ + - ]: 20863 : Py_CLEAR(tmp);
6361 : : }
6362 [ - + ]: 20863 : if (_PyObject_LookupAttr(obj, state->value, &tmp) < 0) {
6363 : 0 : return 1;
6364 : : }
6365 [ - + ]: 20863 : if (tmp == NULL) {
6366 : 0 : PyErr_SetString(PyExc_TypeError, "required field \"value\" missing from Assign");
6367 : 0 : return 1;
6368 : : }
6369 : : else {
6370 : : int res;
6371 [ - + ]: 20863 : if (_Py_EnterRecursiveCall(" while traversing 'Assign' node")) {
6372 : 0 : goto failed;
6373 : : }
6374 : 20863 : res = obj2ast_expr(state, tmp, &value, arena);
6375 : 20863 : _Py_LeaveRecursiveCall();
6376 [ - + ]: 20863 : if (res != 0) goto failed;
6377 [ + - ]: 20863 : Py_CLEAR(tmp);
6378 : : }
6379 [ - + ]: 20863 : if (_PyObject_LookupAttr(obj, state->type_comment, &tmp) < 0) {
6380 : 0 : return 1;
6381 : : }
6382 [ + - + - ]: 20863 : if (tmp == NULL || tmp == Py_None) {
6383 [ + - ]: 20863 : Py_CLEAR(tmp);
6384 : 20863 : type_comment = NULL;
6385 : : }
6386 : : else {
6387 : : int res;
6388 [ # # ]: 0 : if (_Py_EnterRecursiveCall(" while traversing 'Assign' node")) {
6389 : 0 : goto failed;
6390 : : }
6391 : 0 : res = obj2ast_string(state, tmp, &type_comment, arena);
6392 : 0 : _Py_LeaveRecursiveCall();
6393 [ # # ]: 0 : if (res != 0) goto failed;
6394 [ # # ]: 0 : Py_CLEAR(tmp);
6395 : : }
6396 : 20863 : *out = _PyAST_Assign(targets, value, type_comment, lineno, col_offset,
6397 : : end_lineno, end_col_offset, arena);
6398 [ - + ]: 20863 : if (*out == NULL) goto failed;
6399 : 20863 : return 0;
6400 : : }
6401 : 33585 : tp = state->AugAssign_type;
6402 : 33585 : isinstance = PyObject_IsInstance(obj, tp);
6403 [ - + ]: 33585 : if (isinstance == -1) {
6404 : 0 : return 1;
6405 : : }
6406 [ + + ]: 33585 : if (isinstance) {
6407 : : expr_ty target;
6408 : : operator_ty op;
6409 : : expr_ty value;
6410 : :
6411 [ - + ]: 860 : if (_PyObject_LookupAttr(obj, state->target, &tmp) < 0) {
6412 : 860 : return 1;
6413 : : }
6414 [ - + ]: 860 : if (tmp == NULL) {
6415 : 0 : PyErr_SetString(PyExc_TypeError, "required field \"target\" missing from AugAssign");
6416 : 0 : return 1;
6417 : : }
6418 : : else {
6419 : : int res;
6420 [ - + ]: 860 : if (_Py_EnterRecursiveCall(" while traversing 'AugAssign' node")) {
6421 : 0 : goto failed;
6422 : : }
6423 : 860 : res = obj2ast_expr(state, tmp, &target, arena);
6424 : 860 : _Py_LeaveRecursiveCall();
6425 [ - + ]: 860 : if (res != 0) goto failed;
6426 [ + - ]: 860 : Py_CLEAR(tmp);
6427 : : }
6428 [ - + ]: 860 : if (_PyObject_LookupAttr(obj, state->op, &tmp) < 0) {
6429 : 0 : return 1;
6430 : : }
6431 [ - + ]: 860 : if (tmp == NULL) {
6432 : 0 : PyErr_SetString(PyExc_TypeError, "required field \"op\" missing from AugAssign");
6433 : 0 : return 1;
6434 : : }
6435 : : else {
6436 : : int res;
6437 [ - + ]: 860 : if (_Py_EnterRecursiveCall(" while traversing 'AugAssign' node")) {
6438 : 0 : goto failed;
6439 : : }
6440 : 860 : res = obj2ast_operator(state, tmp, &op, arena);
6441 : 860 : _Py_LeaveRecursiveCall();
6442 [ - + ]: 860 : if (res != 0) goto failed;
6443 [ + - ]: 860 : Py_CLEAR(tmp);
6444 : : }
6445 [ - + ]: 860 : if (_PyObject_LookupAttr(obj, state->value, &tmp) < 0) {
6446 : 0 : return 1;
6447 : : }
6448 [ - + ]: 860 : if (tmp == NULL) {
6449 : 0 : PyErr_SetString(PyExc_TypeError, "required field \"value\" missing from AugAssign");
6450 : 0 : return 1;
6451 : : }
6452 : : else {
6453 : : int res;
6454 [ - + ]: 860 : if (_Py_EnterRecursiveCall(" while traversing 'AugAssign' node")) {
6455 : 0 : goto failed;
6456 : : }
6457 : 860 : res = obj2ast_expr(state, tmp, &value, arena);
6458 : 860 : _Py_LeaveRecursiveCall();
6459 [ - + ]: 860 : if (res != 0) goto failed;
6460 [ + - ]: 860 : Py_CLEAR(tmp);
6461 : : }
6462 : 860 : *out = _PyAST_AugAssign(target, op, value, lineno, col_offset,
6463 : : end_lineno, end_col_offset, arena);
6464 [ - + ]: 860 : if (*out == NULL) goto failed;
6465 : 860 : return 0;
6466 : : }
6467 : 32725 : tp = state->AnnAssign_type;
6468 : 32725 : isinstance = PyObject_IsInstance(obj, tp);
6469 [ - + ]: 32725 : if (isinstance == -1) {
6470 : 0 : return 1;
6471 : : }
6472 [ + + ]: 32725 : if (isinstance) {
6473 : : expr_ty target;
6474 : : expr_ty annotation;
6475 : : expr_ty value;
6476 : : int simple;
6477 : :
6478 [ - + ]: 37 : if (_PyObject_LookupAttr(obj, state->target, &tmp) < 0) {
6479 : 37 : return 1;
6480 : : }
6481 [ - + ]: 37 : if (tmp == NULL) {
6482 : 0 : PyErr_SetString(PyExc_TypeError, "required field \"target\" missing from AnnAssign");
6483 : 0 : return 1;
6484 : : }
6485 : : else {
6486 : : int res;
6487 [ - + ]: 37 : if (_Py_EnterRecursiveCall(" while traversing 'AnnAssign' node")) {
6488 : 0 : goto failed;
6489 : : }
6490 : 37 : res = obj2ast_expr(state, tmp, &target, arena);
6491 : 37 : _Py_LeaveRecursiveCall();
6492 [ - + ]: 37 : if (res != 0) goto failed;
6493 [ + - ]: 37 : Py_CLEAR(tmp);
6494 : : }
6495 [ - + ]: 37 : if (_PyObject_LookupAttr(obj, state->annotation, &tmp) < 0) {
6496 : 0 : return 1;
6497 : : }
6498 [ - + ]: 37 : if (tmp == NULL) {
6499 : 0 : PyErr_SetString(PyExc_TypeError, "required field \"annotation\" missing from AnnAssign");
6500 : 0 : return 1;
6501 : : }
6502 : : else {
6503 : : int res;
6504 [ - + ]: 37 : if (_Py_EnterRecursiveCall(" while traversing 'AnnAssign' node")) {
6505 : 0 : goto failed;
6506 : : }
6507 : 37 : res = obj2ast_expr(state, tmp, &annotation, arena);
6508 : 37 : _Py_LeaveRecursiveCall();
6509 [ - + ]: 37 : if (res != 0) goto failed;
6510 [ + - ]: 37 : Py_CLEAR(tmp);
6511 : : }
6512 [ - + ]: 37 : if (_PyObject_LookupAttr(obj, state->value, &tmp) < 0) {
6513 : 0 : return 1;
6514 : : }
6515 [ + - + + ]: 37 : if (tmp == NULL || tmp == Py_None) {
6516 [ + - ]: 26 : Py_CLEAR(tmp);
6517 : 26 : value = NULL;
6518 : : }
6519 : : else {
6520 : : int res;
6521 [ - + ]: 11 : if (_Py_EnterRecursiveCall(" while traversing 'AnnAssign' node")) {
6522 : 0 : goto failed;
6523 : : }
6524 : 11 : res = obj2ast_expr(state, tmp, &value, arena);
6525 : 11 : _Py_LeaveRecursiveCall();
6526 [ - + ]: 11 : if (res != 0) goto failed;
6527 [ + - ]: 11 : Py_CLEAR(tmp);
6528 : : }
6529 [ - + ]: 37 : if (_PyObject_LookupAttr(obj, state->simple, &tmp) < 0) {
6530 : 0 : return 1;
6531 : : }
6532 [ - + ]: 37 : if (tmp == NULL) {
6533 : 0 : PyErr_SetString(PyExc_TypeError, "required field \"simple\" missing from AnnAssign");
6534 : 0 : return 1;
6535 : : }
6536 : : else {
6537 : : int res;
6538 [ - + ]: 37 : if (_Py_EnterRecursiveCall(" while traversing 'AnnAssign' node")) {
6539 : 0 : goto failed;
6540 : : }
6541 : 37 : res = obj2ast_int(state, tmp, &simple, arena);
6542 : 37 : _Py_LeaveRecursiveCall();
6543 [ - + ]: 37 : if (res != 0) goto failed;
6544 [ + - ]: 37 : Py_CLEAR(tmp);
6545 : : }
6546 : 37 : *out = _PyAST_AnnAssign(target, annotation, value, simple, lineno,
6547 : : col_offset, end_lineno, end_col_offset, arena);
6548 [ - + ]: 37 : if (*out == NULL) goto failed;
6549 : 37 : return 0;
6550 : : }
6551 : 32688 : tp = state->For_type;
6552 : 32688 : isinstance = PyObject_IsInstance(obj, tp);
6553 [ - + ]: 32688 : if (isinstance == -1) {
6554 : 0 : return 1;
6555 : : }
6556 [ + + ]: 32688 : if (isinstance) {
6557 : : expr_ty target;
6558 : : expr_ty iter;
6559 : : asdl_stmt_seq* body;
6560 : : asdl_stmt_seq* orelse;
6561 : : string type_comment;
6562 : :
6563 [ - + ]: 1394 : if (_PyObject_LookupAttr(obj, state->target, &tmp) < 0) {
6564 : 1394 : return 1;
6565 : : }
6566 [ - + ]: 1394 : if (tmp == NULL) {
6567 : 0 : PyErr_SetString(PyExc_TypeError, "required field \"target\" missing from For");
6568 : 0 : return 1;
6569 : : }
6570 : : else {
6571 : : int res;
6572 [ - + ]: 1394 : if (_Py_EnterRecursiveCall(" while traversing 'For' node")) {
6573 : 0 : goto failed;
6574 : : }
6575 : 1394 : res = obj2ast_expr(state, tmp, &target, arena);
6576 : 1394 : _Py_LeaveRecursiveCall();
6577 [ - + ]: 1394 : if (res != 0) goto failed;
6578 [ + - ]: 1394 : Py_CLEAR(tmp);
6579 : : }
6580 [ - + ]: 1394 : if (_PyObject_LookupAttr(obj, state->iter, &tmp) < 0) {
6581 : 0 : return 1;
6582 : : }
6583 [ - + ]: 1394 : if (tmp == NULL) {
6584 : 0 : PyErr_SetString(PyExc_TypeError, "required field \"iter\" missing from For");
6585 : 0 : return 1;
6586 : : }
6587 : : else {
6588 : : int res;
6589 [ - + ]: 1394 : if (_Py_EnterRecursiveCall(" while traversing 'For' node")) {
6590 : 0 : goto failed;
6591 : : }
6592 : 1394 : res = obj2ast_expr(state, tmp, &iter, arena);
6593 : 1394 : _Py_LeaveRecursiveCall();
6594 [ - + ]: 1394 : if (res != 0) goto failed;
6595 [ + - ]: 1394 : Py_CLEAR(tmp);
6596 : : }
6597 [ - + ]: 1394 : if (_PyObject_LookupAttr(obj, state->body, &tmp) < 0) {
6598 : 0 : return 1;
6599 : : }
6600 [ - + ]: 1394 : if (tmp == NULL) {
6601 : 0 : PyErr_SetString(PyExc_TypeError, "required field \"body\" missing from For");
6602 : 0 : return 1;
6603 : : }
6604 : : else {
6605 : : int res;
6606 : : Py_ssize_t len;
6607 : : Py_ssize_t i;
6608 [ - + ]: 1394 : if (!PyList_Check(tmp)) {
6609 : 0 : PyErr_Format(PyExc_TypeError, "For field \"body\" must be a list, not a %.200s", _PyType_Name(Py_TYPE(tmp)));
6610 : 0 : goto failed;
6611 : : }
6612 : 1394 : len = PyList_GET_SIZE(tmp);
6613 : 1394 : body = _Py_asdl_stmt_seq_new(len, arena);
6614 [ - + ]: 1394 : if (body == NULL) goto failed;
6615 [ + + ]: 4165 : for (i = 0; i < len; i++) {
6616 : : stmt_ty val;
6617 : 2771 : PyObject *tmp2 = PyList_GET_ITEM(tmp, i);
6618 : 2771 : Py_INCREF(tmp2);
6619 [ - + ]: 2771 : if (_Py_EnterRecursiveCall(" while traversing 'For' node")) {
6620 : 0 : goto failed;
6621 : : }
6622 : 2771 : res = obj2ast_stmt(state, tmp2, &val, arena);
6623 : 2771 : _Py_LeaveRecursiveCall();
6624 : 2771 : Py_DECREF(tmp2);
6625 [ - + ]: 2771 : if (res != 0) goto failed;
6626 [ - + ]: 2771 : if (len != PyList_GET_SIZE(tmp)) {
6627 : 0 : PyErr_SetString(PyExc_RuntimeError, "For field \"body\" changed size during iteration");
6628 : 0 : goto failed;
6629 : : }
6630 : 2771 : asdl_seq_SET(body, i, val);
6631 : : }
6632 [ + - ]: 1394 : Py_CLEAR(tmp);
6633 : : }
6634 [ - + ]: 1394 : if (_PyObject_LookupAttr(obj, state->orelse, &tmp) < 0) {
6635 : 0 : return 1;
6636 : : }
6637 [ - + ]: 1394 : if (tmp == NULL) {
6638 : 0 : PyErr_SetString(PyExc_TypeError, "required field \"orelse\" missing from For");
6639 : 0 : return 1;
6640 : : }
6641 : : else {
6642 : : int res;
6643 : : Py_ssize_t len;
6644 : : Py_ssize_t i;
6645 [ - + ]: 1394 : if (!PyList_Check(tmp)) {
6646 : 0 : PyErr_Format(PyExc_TypeError, "For field \"orelse\" must be a list, not a %.200s", _PyType_Name(Py_TYPE(tmp)));
6647 : 0 : goto failed;
6648 : : }
6649 : 1394 : len = PyList_GET_SIZE(tmp);
6650 : 1394 : orelse = _Py_asdl_stmt_seq_new(len, arena);
6651 [ - + ]: 1394 : if (orelse == NULL) goto failed;
6652 [ + + ]: 1446 : for (i = 0; i < len; i++) {
6653 : : stmt_ty val;
6654 : 52 : PyObject *tmp2 = PyList_GET_ITEM(tmp, i);
6655 : 52 : Py_INCREF(tmp2);
6656 [ - + ]: 52 : if (_Py_EnterRecursiveCall(" while traversing 'For' node")) {
6657 : 0 : goto failed;
6658 : : }
6659 : 52 : res = obj2ast_stmt(state, tmp2, &val, arena);
6660 : 52 : _Py_LeaveRecursiveCall();
6661 : 52 : Py_DECREF(tmp2);
6662 [ - + ]: 52 : if (res != 0) goto failed;
6663 [ - + ]: 52 : if (len != PyList_GET_SIZE(tmp)) {
6664 : 0 : PyErr_SetString(PyExc_RuntimeError, "For field \"orelse\" changed size during iteration");
6665 : 0 : goto failed;
6666 : : }
6667 : 52 : asdl_seq_SET(orelse, i, val);
6668 : : }
6669 [ + - ]: 1394 : Py_CLEAR(tmp);
6670 : : }
6671 [ - + ]: 1394 : if (_PyObject_LookupAttr(obj, state->type_comment, &tmp) < 0) {
6672 : 0 : return 1;
6673 : : }
6674 [ + - + - ]: 1394 : if (tmp == NULL || tmp == Py_None) {
6675 [ + - ]: 1394 : Py_CLEAR(tmp);
6676 : 1394 : type_comment = NULL;
6677 : : }
6678 : : else {
6679 : : int res;
6680 [ # # ]: 0 : if (_Py_EnterRecursiveCall(" while traversing 'For' node")) {
6681 : 0 : goto failed;
6682 : : }
6683 : 0 : res = obj2ast_string(state, tmp, &type_comment, arena);
6684 : 0 : _Py_LeaveRecursiveCall();
6685 [ # # ]: 0 : if (res != 0) goto failed;
6686 [ # # ]: 0 : Py_CLEAR(tmp);
6687 : : }
6688 : 1394 : *out = _PyAST_For(target, iter, body, orelse, type_comment, lineno,
6689 : : col_offset, end_lineno, end_col_offset, arena);
6690 [ - + ]: 1394 : if (*out == NULL) goto failed;
6691 : 1394 : return 0;
6692 : : }
6693 : 31294 : tp = state->AsyncFor_type;
6694 : 31294 : isinstance = PyObject_IsInstance(obj, tp);
6695 [ - + ]: 31294 : if (isinstance == -1) {
6696 : 0 : return 1;
6697 : : }
6698 [ + + ]: 31294 : if (isinstance) {
6699 : : expr_ty target;
6700 : : expr_ty iter;
6701 : : asdl_stmt_seq* body;
6702 : : asdl_stmt_seq* orelse;
6703 : : string type_comment;
6704 : :
6705 [ - + ]: 6 : if (_PyObject_LookupAttr(obj, state->target, &tmp) < 0) {
6706 : 6 : return 1;
6707 : : }
6708 [ - + ]: 6 : if (tmp == NULL) {
6709 : 0 : PyErr_SetString(PyExc_TypeError, "required field \"target\" missing from AsyncFor");
6710 : 0 : return 1;
6711 : : }
6712 : : else {
6713 : : int res;
6714 [ - + ]: 6 : if (_Py_EnterRecursiveCall(" while traversing 'AsyncFor' node")) {
6715 : 0 : goto failed;
6716 : : }
6717 : 6 : res = obj2ast_expr(state, tmp, &target, arena);
6718 : 6 : _Py_LeaveRecursiveCall();
6719 [ - + ]: 6 : if (res != 0) goto failed;
6720 [ + - ]: 6 : Py_CLEAR(tmp);
6721 : : }
6722 [ - + ]: 6 : if (_PyObject_LookupAttr(obj, state->iter, &tmp) < 0) {
6723 : 0 : return 1;
6724 : : }
6725 [ - + ]: 6 : if (tmp == NULL) {
6726 : 0 : PyErr_SetString(PyExc_TypeError, "required field \"iter\" missing from AsyncFor");
6727 : 0 : return 1;
6728 : : }
6729 : : else {
6730 : : int res;
6731 [ - + ]: 6 : if (_Py_EnterRecursiveCall(" while traversing 'AsyncFor' node")) {
6732 : 0 : goto failed;
6733 : : }
6734 : 6 : res = obj2ast_expr(state, tmp, &iter, arena);
6735 : 6 : _Py_LeaveRecursiveCall();
6736 [ - + ]: 6 : if (res != 0) goto failed;
6737 [ + - ]: 6 : Py_CLEAR(tmp);
6738 : : }
6739 [ - + ]: 6 : if (_PyObject_LookupAttr(obj, state->body, &tmp) < 0) {
6740 : 0 : return 1;
6741 : : }
6742 [ - + ]: 6 : if (tmp == NULL) {
6743 : 0 : PyErr_SetString(PyExc_TypeError, "required field \"body\" missing from AsyncFor");
6744 : 0 : return 1;
6745 : : }
6746 : : else {
6747 : : int res;
6748 : : Py_ssize_t len;
6749 : : Py_ssize_t i;
6750 [ - + ]: 6 : if (!PyList_Check(tmp)) {
6751 : 0 : PyErr_Format(PyExc_TypeError, "AsyncFor field \"body\" must be a list, not a %.200s", _PyType_Name(Py_TYPE(tmp)));
6752 : 0 : goto failed;
6753 : : }
6754 : 6 : len = PyList_GET_SIZE(tmp);
6755 : 6 : body = _Py_asdl_stmt_seq_new(len, arena);
6756 [ - + ]: 6 : if (body == NULL) goto failed;
6757 [ + + ]: 12 : for (i = 0; i < len; i++) {
6758 : : stmt_ty val;
6759 : 6 : PyObject *tmp2 = PyList_GET_ITEM(tmp, i);
6760 : 6 : Py_INCREF(tmp2);
6761 [ - + ]: 6 : if (_Py_EnterRecursiveCall(" while traversing 'AsyncFor' node")) {
6762 : 0 : goto failed;
6763 : : }
6764 : 6 : res = obj2ast_stmt(state, tmp2, &val, arena);
6765 : 6 : _Py_LeaveRecursiveCall();
6766 : 6 : Py_DECREF(tmp2);
6767 [ - + ]: 6 : if (res != 0) goto failed;
6768 [ - + ]: 6 : if (len != PyList_GET_SIZE(tmp)) {
6769 : 0 : PyErr_SetString(PyExc_RuntimeError, "AsyncFor field \"body\" changed size during iteration");
6770 : 0 : goto failed;
6771 : : }
6772 : 6 : asdl_seq_SET(body, i, val);
6773 : : }
6774 [ + - ]: 6 : Py_CLEAR(tmp);
6775 : : }
6776 [ - + ]: 6 : if (_PyObject_LookupAttr(obj, state->orelse, &tmp) < 0) {
6777 : 0 : return 1;
6778 : : }
6779 [ - + ]: 6 : if (tmp == NULL) {
6780 : 0 : PyErr_SetString(PyExc_TypeError, "required field \"orelse\" missing from AsyncFor");
6781 : 0 : return 1;
6782 : : }
6783 : : else {
6784 : : int res;
6785 : : Py_ssize_t len;
6786 : : Py_ssize_t i;
6787 [ - + ]: 6 : if (!PyList_Check(tmp)) {
6788 : 0 : PyErr_Format(PyExc_TypeError, "AsyncFor field \"orelse\" must be a list, not a %.200s", _PyType_Name(Py_TYPE(tmp)));
6789 : 0 : goto failed;
6790 : : }
6791 : 6 : len = PyList_GET_SIZE(tmp);
6792 : 6 : orelse = _Py_asdl_stmt_seq_new(len, arena);
6793 [ - + ]: 6 : if (orelse == NULL) goto failed;
6794 [ + + ]: 9 : for (i = 0; i < len; i++) {
6795 : : stmt_ty val;
6796 : 3 : PyObject *tmp2 = PyList_GET_ITEM(tmp, i);
6797 : 3 : Py_INCREF(tmp2);
6798 [ - + ]: 3 : if (_Py_EnterRecursiveCall(" while traversing 'AsyncFor' node")) {
6799 : 0 : goto failed;
6800 : : }
6801 : 3 : res = obj2ast_stmt(state, tmp2, &val, arena);
6802 : 3 : _Py_LeaveRecursiveCall();
6803 : 3 : Py_DECREF(tmp2);
6804 [ - + ]: 3 : if (res != 0) goto failed;
6805 [ - + ]: 3 : if (len != PyList_GET_SIZE(tmp)) {
6806 : 0 : PyErr_SetString(PyExc_RuntimeError, "AsyncFor field \"orelse\" changed size during iteration");
6807 : 0 : goto failed;
6808 : : }
6809 : 3 : asdl_seq_SET(orelse, i, val);
6810 : : }
6811 [ + - ]: 6 : Py_CLEAR(tmp);
6812 : : }
6813 [ - + ]: 6 : if (_PyObject_LookupAttr(obj, state->type_comment, &tmp) < 0) {
6814 : 0 : return 1;
6815 : : }
6816 [ + - + - ]: 6 : if (tmp == NULL || tmp == Py_None) {
6817 [ + - ]: 6 : Py_CLEAR(tmp);
6818 : 6 : type_comment = NULL;
6819 : : }
6820 : : else {
6821 : : int res;
6822 [ # # ]: 0 : if (_Py_EnterRecursiveCall(" while traversing 'AsyncFor' node")) {
6823 : 0 : goto failed;
6824 : : }
6825 : 0 : res = obj2ast_string(state, tmp, &type_comment, arena);
6826 : 0 : _Py_LeaveRecursiveCall();
6827 [ # # ]: 0 : if (res != 0) goto failed;
6828 [ # # ]: 0 : Py_CLEAR(tmp);
6829 : : }
6830 : 6 : *out = _PyAST_AsyncFor(target, iter, body, orelse, type_comment,
6831 : : lineno, col_offset, end_lineno, end_col_offset,
6832 : : arena);
6833 [ - + ]: 6 : if (*out == NULL) goto failed;
6834 : 6 : return 0;
6835 : : }
6836 : 31288 : tp = state->While_type;
6837 : 31288 : isinstance = PyObject_IsInstance(obj, tp);
6838 [ - + ]: 31288 : if (isinstance == -1) {
6839 : 0 : return 1;
6840 : : }
6841 [ + + ]: 31288 : if (isinstance) {
6842 : : expr_ty test;
6843 : : asdl_stmt_seq* body;
6844 : : asdl_stmt_seq* orelse;
6845 : :
6846 [ - + ]: 445 : if (_PyObject_LookupAttr(obj, state->test, &tmp) < 0) {
6847 : 445 : return 1;
6848 : : }
6849 [ - + ]: 445 : if (tmp == NULL) {
6850 : 0 : PyErr_SetString(PyExc_TypeError, "required field \"test\" missing from While");
6851 : 0 : return 1;
6852 : : }
6853 : : else {
6854 : : int res;
6855 [ - + ]: 445 : if (_Py_EnterRecursiveCall(" while traversing 'While' node")) {
6856 : 0 : goto failed;
6857 : : }
6858 : 445 : res = obj2ast_expr(state, tmp, &test, arena);
6859 : 445 : _Py_LeaveRecursiveCall();
6860 [ - + ]: 445 : if (res != 0) goto failed;
6861 [ + - ]: 445 : Py_CLEAR(tmp);
6862 : : }
6863 [ - + ]: 445 : if (_PyObject_LookupAttr(obj, state->body, &tmp) < 0) {
6864 : 0 : return 1;
6865 : : }
6866 [ - + ]: 445 : if (tmp == NULL) {
6867 : 0 : PyErr_SetString(PyExc_TypeError, "required field \"body\" missing from While");
6868 : 0 : return 1;
6869 : : }
6870 : : else {
6871 : : int res;
6872 : : Py_ssize_t len;
6873 : : Py_ssize_t i;
6874 [ - + ]: 445 : if (!PyList_Check(tmp)) {
6875 : 0 : PyErr_Format(PyExc_TypeError, "While field \"body\" must be a list, not a %.200s", _PyType_Name(Py_TYPE(tmp)));
6876 : 0 : goto failed;
6877 : : }
6878 : 445 : len = PyList_GET_SIZE(tmp);
6879 : 445 : body = _Py_asdl_stmt_seq_new(len, arena);
6880 [ - + ]: 445 : if (body == NULL) goto failed;
6881 [ + + ]: 1861 : for (i = 0; i < len; i++) {
6882 : : stmt_ty val;
6883 : 1416 : PyObject *tmp2 = PyList_GET_ITEM(tmp, i);
6884 : 1416 : Py_INCREF(tmp2);
6885 [ - + ]: 1416 : if (_Py_EnterRecursiveCall(" while traversing 'While' node")) {
6886 : 0 : goto failed;
6887 : : }
6888 : 1416 : res = obj2ast_stmt(state, tmp2, &val, arena);
6889 : 1416 : _Py_LeaveRecursiveCall();
6890 : 1416 : Py_DECREF(tmp2);
6891 [ - + ]: 1416 : if (res != 0) goto failed;
6892 [ - + ]: 1416 : if (len != PyList_GET_SIZE(tmp)) {
6893 : 0 : PyErr_SetString(PyExc_RuntimeError, "While field \"body\" changed size during iteration");
6894 : 0 : goto failed;
6895 : : }
6896 : 1416 : asdl_seq_SET(body, i, val);
6897 : : }
6898 [ + - ]: 445 : Py_CLEAR(tmp);
6899 : : }
6900 [ - + ]: 445 : if (_PyObject_LookupAttr(obj, state->orelse, &tmp) < 0) {
6901 : 0 : return 1;
6902 : : }
6903 [ - + ]: 445 : if (tmp == NULL) {
6904 : 0 : PyErr_SetString(PyExc_TypeError, "required field \"orelse\" missing from While");
6905 : 0 : return 1;
6906 : : }
6907 : : else {
6908 : : int res;
6909 : : Py_ssize_t len;
6910 : : Py_ssize_t i;
6911 [ - + ]: 445 : if (!PyList_Check(tmp)) {
6912 : 0 : PyErr_Format(PyExc_TypeError, "While field \"orelse\" must be a list, not a %.200s", _PyType_Name(Py_TYPE(tmp)));
6913 : 0 : goto failed;
6914 : : }
6915 : 445 : len = PyList_GET_SIZE(tmp);
6916 : 445 : orelse = _Py_asdl_stmt_seq_new(len, arena);
6917 [ - + ]: 445 : if (orelse == NULL) goto failed;
6918 [ + + ]: 456 : for (i = 0; i < len; i++) {
6919 : : stmt_ty val;
6920 : 11 : PyObject *tmp2 = PyList_GET_ITEM(tmp, i);
6921 : 11 : Py_INCREF(tmp2);
6922 [ - + ]: 11 : if (_Py_EnterRecursiveCall(" while traversing 'While' node")) {
6923 : 0 : goto failed;
6924 : : }
6925 : 11 : res = obj2ast_stmt(state, tmp2, &val, arena);
6926 : 11 : _Py_LeaveRecursiveCall();
6927 : 11 : Py_DECREF(tmp2);
6928 [ - + ]: 11 : if (res != 0) goto failed;
6929 [ - + ]: 11 : if (len != PyList_GET_SIZE(tmp)) {
6930 : 0 : PyErr_SetString(PyExc_RuntimeError, "While field \"orelse\" changed size during iteration");
6931 : 0 : goto failed;
6932 : : }
6933 : 11 : asdl_seq_SET(orelse, i, val);
6934 : : }
6935 [ + - ]: 445 : Py_CLEAR(tmp);
6936 : : }
6937 : 445 : *out = _PyAST_While(test, body, orelse, lineno, col_offset, end_lineno,
6938 : : end_col_offset, arena);
6939 [ - + ]: 445 : if (*out == NULL) goto failed;
6940 : 445 : return 0;
6941 : : }
6942 : 30843 : tp = state->If_type;
6943 : 30843 : isinstance = PyObject_IsInstance(obj, tp);
6944 [ - + ]: 30843 : if (isinstance == -1) {
6945 : 0 : return 1;
6946 : : }
6947 [ + + ]: 30843 : if (isinstance) {
6948 : : expr_ty test;
6949 : : asdl_stmt_seq* body;
6950 : : asdl_stmt_seq* orelse;
6951 : :
6952 [ - + ]: 11158 : if (_PyObject_LookupAttr(obj, state->test, &tmp) < 0) {
6953 : 11158 : return 1;
6954 : : }
6955 [ - + ]: 11158 : if (tmp == NULL) {
6956 : 0 : PyErr_SetString(PyExc_TypeError, "required field \"test\" missing from If");
6957 : 0 : return 1;
6958 : : }
6959 : : else {
6960 : : int res;
6961 [ - + ]: 11158 : if (_Py_EnterRecursiveCall(" while traversing 'If' node")) {
6962 : 0 : goto failed;
6963 : : }
6964 : 11158 : res = obj2ast_expr(state, tmp, &test, arena);
6965 : 11158 : _Py_LeaveRecursiveCall();
6966 [ - + ]: 11158 : if (res != 0) goto failed;
6967 [ + - ]: 11158 : Py_CLEAR(tmp);
6968 : : }
6969 [ - + ]: 11158 : if (_PyObject_LookupAttr(obj, state->body, &tmp) < 0) {
6970 : 0 : return 1;
6971 : : }
6972 [ - + ]: 11158 : if (tmp == NULL) {
6973 : 0 : PyErr_SetString(PyExc_TypeError, "required field \"body\" missing from If");
6974 : 0 : return 1;
6975 : : }
6976 : : else {
6977 : : int res;
6978 : : Py_ssize_t len;
6979 : : Py_ssize_t i;
6980 [ - + ]: 11158 : if (!PyList_Check(tmp)) {
6981 : 0 : PyErr_Format(PyExc_TypeError, "If field \"body\" must be a list, not a %.200s", _PyType_Name(Py_TYPE(tmp)));
6982 : 0 : goto failed;
6983 : : }
6984 : 11158 : len = PyList_GET_SIZE(tmp);
6985 : 11158 : body = _Py_asdl_stmt_seq_new(len, arena);
6986 [ - + ]: 11158 : if (body == NULL) goto failed;
6987 [ + + ]: 27437 : for (i = 0; i < len; i++) {
6988 : : stmt_ty val;
6989 : 16279 : PyObject *tmp2 = PyList_GET_ITEM(tmp, i);
6990 : 16279 : Py_INCREF(tmp2);
6991 [ - + ]: 16279 : if (_Py_EnterRecursiveCall(" while traversing 'If' node")) {
6992 : 0 : goto failed;
6993 : : }
6994 : 16279 : res = obj2ast_stmt(state, tmp2, &val, arena);
6995 : 16279 : _Py_LeaveRecursiveCall();
6996 : 16279 : Py_DECREF(tmp2);
6997 [ - + ]: 16279 : if (res != 0) goto failed;
6998 [ - + ]: 16279 : if (len != PyList_GET_SIZE(tmp)) {
6999 : 0 : PyErr_SetString(PyExc_RuntimeError, "If field \"body\" changed size during iteration");
7000 : 0 : goto failed;
7001 : : }
7002 : 16279 : asdl_seq_SET(body, i, val);
7003 : : }
7004 [ + - ]: 11158 : Py_CLEAR(tmp);
7005 : : }
7006 [ - + ]: 11158 : if (_PyObject_LookupAttr(obj, state->orelse, &tmp) < 0) {
7007 : 0 : return 1;
7008 : : }
7009 [ - + ]: 11158 : if (tmp == NULL) {
7010 : 0 : PyErr_SetString(PyExc_TypeError, "required field \"orelse\" missing from If");
7011 : 0 : return 1;
7012 : : }
7013 : : else {
7014 : : int res;
7015 : : Py_ssize_t len;
7016 : : Py_ssize_t i;
7017 [ - + ]: 11158 : if (!PyList_Check(tmp)) {
7018 : 0 : PyErr_Format(PyExc_TypeError, "If field \"orelse\" must be a list, not a %.200s", _PyType_Name(Py_TYPE(tmp)));
7019 : 0 : goto failed;
7020 : : }
7021 : 11158 : len = PyList_GET_SIZE(tmp);
7022 : 11158 : orelse = _Py_asdl_stmt_seq_new(len, arena);
7023 [ - + ]: 11158 : if (orelse == NULL) goto failed;
7024 [ + + ]: 15304 : for (i = 0; i < len; i++) {
7025 : : stmt_ty val;
7026 : 4146 : PyObject *tmp2 = PyList_GET_ITEM(tmp, i);
7027 : 4146 : Py_INCREF(tmp2);
7028 [ - + ]: 4146 : if (_Py_EnterRecursiveCall(" while traversing 'If' node")) {
7029 : 0 : goto failed;
7030 : : }
7031 : 4146 : res = obj2ast_stmt(state, tmp2, &val, arena);
7032 : 4146 : _Py_LeaveRecursiveCall();
7033 : 4146 : Py_DECREF(tmp2);
7034 [ - + ]: 4146 : if (res != 0) goto failed;
7035 [ - + ]: 4146 : if (len != PyList_GET_SIZE(tmp)) {
7036 : 0 : PyErr_SetString(PyExc_RuntimeError, "If field \"orelse\" changed size during iteration");
7037 : 0 : goto failed;
7038 : : }
7039 : 4146 : asdl_seq_SET(orelse, i, val);
7040 : : }
7041 [ + - ]: 11158 : Py_CLEAR(tmp);
7042 : : }
7043 : 11158 : *out = _PyAST_If(test, body, orelse, lineno, col_offset, end_lineno,
7044 : : end_col_offset, arena);
7045 [ - + ]: 11158 : if (*out == NULL) goto failed;
7046 : 11158 : return 0;
7047 : : }
7048 : 19685 : tp = state->With_type;
7049 : 19685 : isinstance = PyObject_IsInstance(obj, tp);
7050 [ - + ]: 19685 : if (isinstance == -1) {
7051 : 0 : return 1;
7052 : : }
7053 [ + + ]: 19685 : if (isinstance) {
7054 : : asdl_withitem_seq* items;
7055 : : asdl_stmt_seq* body;
7056 : : string type_comment;
7057 : :
7058 [ - + ]: 384 : if (_PyObject_LookupAttr(obj, state->items, &tmp) < 0) {
7059 : 384 : return 1;
7060 : : }
7061 [ - + ]: 384 : if (tmp == NULL) {
7062 : 0 : PyErr_SetString(PyExc_TypeError, "required field \"items\" missing from With");
7063 : 0 : return 1;
7064 : : }
7065 : : else {
7066 : : int res;
7067 : : Py_ssize_t len;
7068 : : Py_ssize_t i;
7069 [ - + ]: 384 : if (!PyList_Check(tmp)) {
7070 : 0 : PyErr_Format(PyExc_TypeError, "With field \"items\" must be a list, not a %.200s", _PyType_Name(Py_TYPE(tmp)));
7071 : 0 : goto failed;
7072 : : }
7073 : 384 : len = PyList_GET_SIZE(tmp);
7074 : 384 : items = _Py_asdl_withitem_seq_new(len, arena);
7075 [ - + ]: 384 : if (items == NULL) goto failed;
7076 [ + + ]: 789 : for (i = 0; i < len; i++) {
7077 : : withitem_ty val;
7078 : 405 : PyObject *tmp2 = PyList_GET_ITEM(tmp, i);
7079 : 405 : Py_INCREF(tmp2);
7080 [ - + ]: 405 : if (_Py_EnterRecursiveCall(" while traversing 'With' node")) {
7081 : 0 : goto failed;
7082 : : }
7083 : 405 : res = obj2ast_withitem(state, tmp2, &val, arena);
7084 : 405 : _Py_LeaveRecursiveCall();
7085 : 405 : Py_DECREF(tmp2);
7086 [ - + ]: 405 : if (res != 0) goto failed;
7087 [ - + ]: 405 : if (len != PyList_GET_SIZE(tmp)) {
7088 : 0 : PyErr_SetString(PyExc_RuntimeError, "With field \"items\" changed size during iteration");
7089 : 0 : goto failed;
7090 : : }
7091 : 405 : asdl_seq_SET(items, i, val);
7092 : : }
7093 [ + - ]: 384 : Py_CLEAR(tmp);
7094 : : }
7095 [ - + ]: 384 : if (_PyObject_LookupAttr(obj, state->body, &tmp) < 0) {
7096 : 0 : return 1;
7097 : : }
7098 [ - + ]: 384 : if (tmp == NULL) {
7099 : 0 : PyErr_SetString(PyExc_TypeError, "required field \"body\" missing from With");
7100 : 0 : return 1;
7101 : : }
7102 : : else {
7103 : : int res;
7104 : : Py_ssize_t len;
7105 : : Py_ssize_t i;
7106 [ - + ]: 384 : if (!PyList_Check(tmp)) {
7107 : 0 : PyErr_Format(PyExc_TypeError, "With field \"body\" must be a list, not a %.200s", _PyType_Name(Py_TYPE(tmp)));
7108 : 0 : goto failed;
7109 : : }
7110 : 384 : len = PyList_GET_SIZE(tmp);
7111 : 384 : body = _Py_asdl_stmt_seq_new(len, arena);
7112 [ - + ]: 384 : if (body == NULL) goto failed;
7113 [ + + ]: 1076 : for (i = 0; i < len; i++) {
7114 : : stmt_ty val;
7115 : 692 : PyObject *tmp2 = PyList_GET_ITEM(tmp, i);
7116 : 692 : Py_INCREF(tmp2);
7117 [ - + ]: 692 : if (_Py_EnterRecursiveCall(" while traversing 'With' node")) {
7118 : 0 : goto failed;
7119 : : }
7120 : 692 : res = obj2ast_stmt(state, tmp2, &val, arena);
7121 : 692 : _Py_LeaveRecursiveCall();
7122 : 692 : Py_DECREF(tmp2);
7123 [ - + ]: 692 : if (res != 0) goto failed;
7124 [ - + ]: 692 : if (len != PyList_GET_SIZE(tmp)) {
7125 : 0 : PyErr_SetString(PyExc_RuntimeError, "With field \"body\" changed size during iteration");
7126 : 0 : goto failed;
7127 : : }
7128 : 692 : asdl_seq_SET(body, i, val);
7129 : : }
7130 [ + - ]: 384 : Py_CLEAR(tmp);
7131 : : }
7132 [ - + ]: 384 : if (_PyObject_LookupAttr(obj, state->type_comment, &tmp) < 0) {
7133 : 0 : return 1;
7134 : : }
7135 [ + - + - ]: 384 : if (tmp == NULL || tmp == Py_None) {
7136 [ + - ]: 384 : Py_CLEAR(tmp);
7137 : 384 : type_comment = NULL;
7138 : : }
7139 : : else {
7140 : : int res;
7141 [ # # ]: 0 : if (_Py_EnterRecursiveCall(" while traversing 'With' node")) {
7142 : 0 : goto failed;
7143 : : }
7144 : 0 : res = obj2ast_string(state, tmp, &type_comment, arena);
7145 : 0 : _Py_LeaveRecursiveCall();
7146 [ # # ]: 0 : if (res != 0) goto failed;
7147 [ # # ]: 0 : Py_CLEAR(tmp);
7148 : : }
7149 : 384 : *out = _PyAST_With(items, body, type_comment, lineno, col_offset,
7150 : : end_lineno, end_col_offset, arena);
7151 [ - + ]: 384 : if (*out == NULL) goto failed;
7152 : 384 : return 0;
7153 : : }
7154 : 19301 : tp = state->AsyncWith_type;
7155 : 19301 : isinstance = PyObject_IsInstance(obj, tp);
7156 [ - + ]: 19301 : if (isinstance == -1) {
7157 : 0 : return 1;
7158 : : }
7159 [ + + ]: 19301 : if (isinstance) {
7160 : : asdl_withitem_seq* items;
7161 : : asdl_stmt_seq* body;
7162 : : string type_comment;
7163 : :
7164 [ - + ]: 9 : if (_PyObject_LookupAttr(obj, state->items, &tmp) < 0) {
7165 : 9 : return 1;
7166 : : }
7167 [ - + ]: 9 : if (tmp == NULL) {
7168 : 0 : PyErr_SetString(PyExc_TypeError, "required field \"items\" missing from AsyncWith");
7169 : 0 : return 1;
7170 : : }
7171 : : else {
7172 : : int res;
7173 : : Py_ssize_t len;
7174 : : Py_ssize_t i;
7175 [ - + ]: 9 : if (!PyList_Check(tmp)) {
7176 : 0 : PyErr_Format(PyExc_TypeError, "AsyncWith field \"items\" must be a list, not a %.200s", _PyType_Name(Py_TYPE(tmp)));
7177 : 0 : goto failed;
7178 : : }
7179 : 9 : len = PyList_GET_SIZE(tmp);
7180 : 9 : items = _Py_asdl_withitem_seq_new(len, arena);
7181 [ - + ]: 9 : if (items == NULL) goto failed;
7182 [ + + ]: 21 : for (i = 0; i < len; i++) {
7183 : : withitem_ty val;
7184 : 12 : PyObject *tmp2 = PyList_GET_ITEM(tmp, i);
7185 : 12 : Py_INCREF(tmp2);
7186 [ - + ]: 12 : if (_Py_EnterRecursiveCall(" while traversing 'AsyncWith' node")) {
7187 : 0 : goto failed;
7188 : : }
7189 : 12 : res = obj2ast_withitem(state, tmp2, &val, arena);
7190 : 12 : _Py_LeaveRecursiveCall();
7191 : 12 : Py_DECREF(tmp2);
7192 [ - + ]: 12 : if (res != 0) goto failed;
7193 [ - + ]: 12 : if (len != PyList_GET_SIZE(tmp)) {
7194 : 0 : PyErr_SetString(PyExc_RuntimeError, "AsyncWith field \"items\" changed size during iteration");
7195 : 0 : goto failed;
7196 : : }
7197 : 12 : asdl_seq_SET(items, i, val);
7198 : : }
7199 [ + - ]: 9 : Py_CLEAR(tmp);
7200 : : }
7201 [ - + ]: 9 : if (_PyObject_LookupAttr(obj, state->body, &tmp) < 0) {
7202 : 0 : return 1;
7203 : : }
7204 [ - + ]: 9 : if (tmp == NULL) {
7205 : 0 : PyErr_SetString(PyExc_TypeError, "required field \"body\" missing from AsyncWith");
7206 : 0 : return 1;
7207 : : }
7208 : : else {
7209 : : int res;
7210 : : Py_ssize_t len;
7211 : : Py_ssize_t i;
7212 [ - + ]: 9 : if (!PyList_Check(tmp)) {
7213 : 0 : PyErr_Format(PyExc_TypeError, "AsyncWith field \"body\" must be a list, not a %.200s", _PyType_Name(Py_TYPE(tmp)));
7214 : 0 : goto failed;
7215 : : }
7216 : 9 : len = PyList_GET_SIZE(tmp);
7217 : 9 : body = _Py_asdl_stmt_seq_new(len, arena);
7218 [ - + ]: 9 : if (body == NULL) goto failed;
7219 [ + + ]: 18 : for (i = 0; i < len; i++) {
7220 : : stmt_ty val;
7221 : 9 : PyObject *tmp2 = PyList_GET_ITEM(tmp, i);
7222 : 9 : Py_INCREF(tmp2);
7223 [ - + ]: 9 : if (_Py_EnterRecursiveCall(" while traversing 'AsyncWith' node")) {
7224 : 0 : goto failed;
7225 : : }
7226 : 9 : res = obj2ast_stmt(state, tmp2, &val, arena);
7227 : 9 : _Py_LeaveRecursiveCall();
7228 : 9 : Py_DECREF(tmp2);
7229 [ - + ]: 9 : if (res != 0) goto failed;
7230 [ - + ]: 9 : if (len != PyList_GET_SIZE(tmp)) {
7231 : 0 : PyErr_SetString(PyExc_RuntimeError, "AsyncWith field \"body\" changed size during iteration");
7232 : 0 : goto failed;
7233 : : }
7234 : 9 : asdl_seq_SET(body, i, val);
7235 : : }
7236 [ + - ]: 9 : Py_CLEAR(tmp);
7237 : : }
7238 [ - + ]: 9 : if (_PyObject_LookupAttr(obj, state->type_comment, &tmp) < 0) {
7239 : 0 : return 1;
7240 : : }
7241 [ + - + - ]: 9 : if (tmp == NULL || tmp == Py_None) {
7242 [ + - ]: 9 : Py_CLEAR(tmp);
7243 : 9 : type_comment = NULL;
7244 : : }
7245 : : else {
7246 : : int res;
7247 [ # # ]: 0 : if (_Py_EnterRecursiveCall(" while traversing 'AsyncWith' node")) {
7248 : 0 : goto failed;
7249 : : }
7250 : 0 : res = obj2ast_string(state, tmp, &type_comment, arena);
7251 : 0 : _Py_LeaveRecursiveCall();
7252 [ # # ]: 0 : if (res != 0) goto failed;
7253 [ # # ]: 0 : Py_CLEAR(tmp);
7254 : : }
7255 : 9 : *out = _PyAST_AsyncWith(items, body, type_comment, lineno, col_offset,
7256 : : end_lineno, end_col_offset, arena);
7257 [ - + ]: 9 : if (*out == NULL) goto failed;
7258 : 9 : return 0;
7259 : : }
7260 : 19292 : tp = state->Match_type;
7261 : 19292 : isinstance = PyObject_IsInstance(obj, tp);
7262 [ - + ]: 19292 : if (isinstance == -1) {
7263 : 0 : return 1;
7264 : : }
7265 [ + + ]: 19292 : if (isinstance) {
7266 : : expr_ty subject;
7267 : : asdl_match_case_seq* cases;
7268 : :
7269 [ - + ]: 29 : if (_PyObject_LookupAttr(obj, state->subject, &tmp) < 0) {
7270 : 29 : return 1;
7271 : : }
7272 [ - + ]: 29 : if (tmp == NULL) {
7273 : 0 : PyErr_SetString(PyExc_TypeError, "required field \"subject\" missing from Match");
7274 : 0 : return 1;
7275 : : }
7276 : : else {
7277 : : int res;
7278 [ - + ]: 29 : if (_Py_EnterRecursiveCall(" while traversing 'Match' node")) {
7279 : 0 : goto failed;
7280 : : }
7281 : 29 : res = obj2ast_expr(state, tmp, &subject, arena);
7282 : 29 : _Py_LeaveRecursiveCall();
7283 [ - + ]: 29 : if (res != 0) goto failed;
7284 [ + - ]: 29 : Py_CLEAR(tmp);
7285 : : }
7286 [ - + ]: 29 : if (_PyObject_LookupAttr(obj, state->cases, &tmp) < 0) {
7287 : 0 : return 1;
7288 : : }
7289 [ - + ]: 29 : if (tmp == NULL) {
7290 : 0 : PyErr_SetString(PyExc_TypeError, "required field \"cases\" missing from Match");
7291 : 0 : return 1;
7292 : : }
7293 : : else {
7294 : : int res;
7295 : : Py_ssize_t len;
7296 : : Py_ssize_t i;
7297 [ - + ]: 29 : if (!PyList_Check(tmp)) {
7298 : 0 : PyErr_Format(PyExc_TypeError, "Match field \"cases\" must be a list, not a %.200s", _PyType_Name(Py_TYPE(tmp)));
7299 : 0 : goto failed;
7300 : : }
7301 : 29 : len = PyList_GET_SIZE(tmp);
7302 : 29 : cases = _Py_asdl_match_case_seq_new(len, arena);
7303 [ - + ]: 29 : if (cases == NULL) goto failed;
7304 [ + + ]: 62 : for (i = 0; i < len; i++) {
7305 : : match_case_ty val;
7306 : 33 : PyObject *tmp2 = PyList_GET_ITEM(tmp, i);
7307 : 33 : Py_INCREF(tmp2);
7308 [ - + ]: 33 : if (_Py_EnterRecursiveCall(" while traversing 'Match' node")) {
7309 : 0 : goto failed;
7310 : : }
7311 : 33 : res = obj2ast_match_case(state, tmp2, &val, arena);
7312 : 33 : _Py_LeaveRecursiveCall();
7313 : 33 : Py_DECREF(tmp2);
7314 [ - + ]: 33 : if (res != 0) goto failed;
7315 [ - + ]: 33 : if (len != PyList_GET_SIZE(tmp)) {
7316 : 0 : PyErr_SetString(PyExc_RuntimeError, "Match field \"cases\" changed size during iteration");
7317 : 0 : goto failed;
7318 : : }
7319 : 33 : asdl_seq_SET(cases, i, val);
7320 : : }
7321 [ + - ]: 29 : Py_CLEAR(tmp);
7322 : : }
7323 : 29 : *out = _PyAST_Match(subject, cases, lineno, col_offset, end_lineno,
7324 : : end_col_offset, arena);
7325 [ - + ]: 29 : if (*out == NULL) goto failed;
7326 : 29 : return 0;
7327 : : }
7328 : 19263 : tp = state->Raise_type;
7329 : 19263 : isinstance = PyObject_IsInstance(obj, tp);
7330 [ - + ]: 19263 : if (isinstance == -1) {
7331 : 0 : return 1;
7332 : : }
7333 [ + + ]: 19263 : if (isinstance) {
7334 : : expr_ty exc;
7335 : : expr_ty cause;
7336 : :
7337 [ - + ]: 2311 : if (_PyObject_LookupAttr(obj, state->exc, &tmp) < 0) {
7338 : 2311 : return 1;
7339 : : }
7340 [ + - + + ]: 2311 : if (tmp == NULL || tmp == Py_None) {
7341 [ + - ]: 164 : Py_CLEAR(tmp);
7342 : 164 : exc = NULL;
7343 : : }
7344 : : else {
7345 : : int res;
7346 [ - + ]: 2147 : if (_Py_EnterRecursiveCall(" while traversing 'Raise' node")) {
7347 : 0 : goto failed;
7348 : : }
7349 : 2147 : res = obj2ast_expr(state, tmp, &exc, arena);
7350 : 2147 : _Py_LeaveRecursiveCall();
7351 [ - + ]: 2147 : if (res != 0) goto failed;
7352 [ + - ]: 2147 : Py_CLEAR(tmp);
7353 : : }
7354 [ - + ]: 2311 : if (_PyObject_LookupAttr(obj, state->cause, &tmp) < 0) {
7355 : 0 : return 1;
7356 : : }
7357 [ + - + + ]: 2311 : if (tmp == NULL || tmp == Py_None) {
7358 [ + - ]: 2178 : Py_CLEAR(tmp);
7359 : 2178 : cause = NULL;
7360 : : }
7361 : : else {
7362 : : int res;
7363 [ - + ]: 133 : if (_Py_EnterRecursiveCall(" while traversing 'Raise' node")) {
7364 : 0 : goto failed;
7365 : : }
7366 : 133 : res = obj2ast_expr(state, tmp, &cause, arena);
7367 : 133 : _Py_LeaveRecursiveCall();
7368 [ - + ]: 133 : if (res != 0) goto failed;
7369 [ + - ]: 133 : Py_CLEAR(tmp);
7370 : : }
7371 : 2311 : *out = _PyAST_Raise(exc, cause, lineno, col_offset, end_lineno,
7372 : : end_col_offset, arena);
7373 [ - + ]: 2311 : if (*out == NULL) goto failed;
7374 : 2311 : return 0;
7375 : : }
7376 : 16952 : tp = state->Try_type;
7377 : 16952 : isinstance = PyObject_IsInstance(obj, tp);
7378 [ - + ]: 16952 : if (isinstance == -1) {
7379 : 0 : return 1;
7380 : : }
7381 [ + + ]: 16952 : if (isinstance) {
7382 : : asdl_stmt_seq* body;
7383 : : asdl_excepthandler_seq* handlers;
7384 : : asdl_stmt_seq* orelse;
7385 : : asdl_stmt_seq* finalbody;
7386 : :
7387 [ - + ]: 1470 : if (_PyObject_LookupAttr(obj, state->body, &tmp) < 0) {
7388 : 0 : return 1;
7389 : : }
7390 [ - + ]: 1470 : if (tmp == NULL) {
7391 : 0 : PyErr_SetString(PyExc_TypeError, "required field \"body\" missing from Try");
7392 : 0 : return 1;
7393 : : }
7394 : : else {
7395 : : int res;
7396 : : Py_ssize_t len;
7397 : : Py_ssize_t i;
7398 [ - + ]: 1470 : if (!PyList_Check(tmp)) {
7399 : 0 : PyErr_Format(PyExc_TypeError, "Try field \"body\" must be a list, not a %.200s", _PyType_Name(Py_TYPE(tmp)));
7400 : 0 : goto failed;
7401 : : }
7402 : 1470 : len = PyList_GET_SIZE(tmp);
7403 : 1470 : body = _Py_asdl_stmt_seq_new(len, arena);
7404 [ - + ]: 1470 : if (body == NULL) goto failed;
7405 [ + + ]: 3577 : for (i = 0; i < len; i++) {
7406 : : stmt_ty val;
7407 : 2107 : PyObject *tmp2 = PyList_GET_ITEM(tmp, i);
7408 : 2107 : Py_INCREF(tmp2);
7409 [ - + ]: 2107 : if (_Py_EnterRecursiveCall(" while traversing 'Try' node")) {
7410 : 0 : goto failed;
7411 : : }
7412 : 2107 : res = obj2ast_stmt(state, tmp2, &val, arena);
7413 : 2107 : _Py_LeaveRecursiveCall();
7414 : 2107 : Py_DECREF(tmp2);
7415 [ - + ]: 2107 : if (res != 0) goto failed;
7416 [ - + ]: 2107 : if (len != PyList_GET_SIZE(tmp)) {
7417 : 0 : PyErr_SetString(PyExc_RuntimeError, "Try field \"body\" changed size during iteration");
7418 : 0 : goto failed;
7419 : : }
7420 : 2107 : asdl_seq_SET(body, i, val);
7421 : : }
7422 [ + - ]: 1470 : Py_CLEAR(tmp);
7423 : : }
7424 [ - + ]: 1470 : if (_PyObject_LookupAttr(obj, state->handlers, &tmp) < 0) {
7425 : 0 : return 1;
7426 : : }
7427 [ - + ]: 1470 : if (tmp == NULL) {
7428 : 0 : PyErr_SetString(PyExc_TypeError, "required field \"handlers\" missing from Try");
7429 : 0 : return 1;
7430 : : }
7431 : : else {
7432 : : int res;
7433 : : Py_ssize_t len;
7434 : : Py_ssize_t i;
7435 [ - + ]: 1470 : if (!PyList_Check(tmp)) {
7436 : 0 : PyErr_Format(PyExc_TypeError, "Try field \"handlers\" must be a list, not a %.200s", _PyType_Name(Py_TYPE(tmp)));
7437 : 0 : goto failed;
7438 : : }
7439 : 1470 : len = PyList_GET_SIZE(tmp);
7440 : 1470 : handlers = _Py_asdl_excepthandler_seq_new(len, arena);
7441 [ - + ]: 1470 : if (handlers == NULL) goto failed;
7442 [ + + ]: 2868 : for (i = 0; i < len; i++) {
7443 : : excepthandler_ty val;
7444 : 1398 : PyObject *tmp2 = PyList_GET_ITEM(tmp, i);
7445 : 1398 : Py_INCREF(tmp2);
7446 [ - + ]: 1398 : if (_Py_EnterRecursiveCall(" while traversing 'Try' node")) {
7447 : 0 : goto failed;
7448 : : }
7449 : 1398 : res = obj2ast_excepthandler(state, tmp2, &val, arena);
7450 : 1398 : _Py_LeaveRecursiveCall();
7451 : 1398 : Py_DECREF(tmp2);
7452 [ - + ]: 1398 : if (res != 0) goto failed;
7453 [ - + ]: 1398 : if (len != PyList_GET_SIZE(tmp)) {
7454 : 0 : PyErr_SetString(PyExc_RuntimeError, "Try field \"handlers\" changed size during iteration");
7455 : 0 : goto failed;
7456 : : }
7457 : 1398 : asdl_seq_SET(handlers, i, val);
7458 : : }
7459 [ + - ]: 1470 : Py_CLEAR(tmp);
7460 : : }
7461 [ - + ]: 1470 : if (_PyObject_LookupAttr(obj, state->orelse, &tmp) < 0) {
7462 : 0 : return 1;
7463 : : }
7464 [ - + ]: 1470 : if (tmp == NULL) {
7465 : 0 : PyErr_SetString(PyExc_TypeError, "required field \"orelse\" missing from Try");
7466 : 0 : return 1;
7467 : : }
7468 : : else {
7469 : : int res;
7470 : : Py_ssize_t len;
7471 : : Py_ssize_t i;
7472 [ - + ]: 1470 : if (!PyList_Check(tmp)) {
7473 : 0 : PyErr_Format(PyExc_TypeError, "Try field \"orelse\" must be a list, not a %.200s", _PyType_Name(Py_TYPE(tmp)));
7474 : 0 : goto failed;
7475 : : }
7476 : 1470 : len = PyList_GET_SIZE(tmp);
7477 : 1470 : orelse = _Py_asdl_stmt_seq_new(len, arena);
7478 [ - + ]: 1470 : if (orelse == NULL) goto failed;
7479 [ + + ]: 1750 : for (i = 0; i < len; i++) {
7480 : : stmt_ty val;
7481 : 280 : PyObject *tmp2 = PyList_GET_ITEM(tmp, i);
7482 : 280 : Py_INCREF(tmp2);
7483 [ - + ]: 280 : if (_Py_EnterRecursiveCall(" while traversing 'Try' node")) {
7484 : 0 : goto failed;
7485 : : }
7486 : 280 : res = obj2ast_stmt(state, tmp2, &val, arena);
7487 : 280 : _Py_LeaveRecursiveCall();
7488 : 280 : Py_DECREF(tmp2);
7489 [ - + ]: 280 : if (res != 0) goto failed;
7490 [ - + ]: 280 : if (len != PyList_GET_SIZE(tmp)) {
7491 : 0 : PyErr_SetString(PyExc_RuntimeError, "Try field \"orelse\" changed size during iteration");
7492 : 0 : goto failed;
7493 : : }
7494 : 280 : asdl_seq_SET(orelse, i, val);
7495 : : }
7496 [ + - ]: 1470 : Py_CLEAR(tmp);
7497 : : }
7498 [ - + ]: 1470 : if (_PyObject_LookupAttr(obj, state->finalbody, &tmp) < 0) {
7499 : 0 : return 1;
7500 : : }
7501 [ - + ]: 1470 : if (tmp == NULL) {
7502 : 0 : PyErr_SetString(PyExc_TypeError, "required field \"finalbody\" missing from Try");
7503 : 0 : return 1;
7504 : : }
7505 : : else {
7506 : : int res;
7507 : : Py_ssize_t len;
7508 : : Py_ssize_t i;
7509 [ - + ]: 1470 : if (!PyList_Check(tmp)) {
7510 : 0 : PyErr_Format(PyExc_TypeError, "Try field \"finalbody\" must be a list, not a %.200s", _PyType_Name(Py_TYPE(tmp)));
7511 : 0 : goto failed;
7512 : : }
7513 : 1470 : len = PyList_GET_SIZE(tmp);
7514 : 1470 : finalbody = _Py_asdl_stmt_seq_new(len, arena);
7515 [ - + ]: 1470 : if (finalbody == NULL) goto failed;
7516 [ + + ]: 1689 : for (i = 0; i < len; i++) {
7517 : : stmt_ty val;
7518 : 219 : PyObject *tmp2 = PyList_GET_ITEM(tmp, i);
7519 : 219 : Py_INCREF(tmp2);
7520 [ - + ]: 219 : if (_Py_EnterRecursiveCall(" while traversing 'Try' node")) {
7521 : 0 : goto failed;
7522 : : }
7523 : 219 : res = obj2ast_stmt(state, tmp2, &val, arena);
7524 : 219 : _Py_LeaveRecursiveCall();
7525 : 219 : Py_DECREF(tmp2);
7526 [ - + ]: 219 : if (res != 0) goto failed;
7527 [ - + ]: 219 : if (len != PyList_GET_SIZE(tmp)) {
7528 : 0 : PyErr_SetString(PyExc_RuntimeError, "Try field \"finalbody\" changed size during iteration");
7529 : 0 : goto failed;
7530 : : }
7531 : 219 : asdl_seq_SET(finalbody, i, val);
7532 : : }
7533 [ + - ]: 1470 : Py_CLEAR(tmp);
7534 : : }
7535 : 1470 : *out = _PyAST_Try(body, handlers, orelse, finalbody, lineno,
7536 : : col_offset, end_lineno, end_col_offset, arena);
7537 [ - + ]: 1470 : if (*out == NULL) goto failed;
7538 : 1470 : return 0;
7539 : : }
7540 : 15482 : tp = state->TryStar_type;
7541 : 15482 : isinstance = PyObject_IsInstance(obj, tp);
7542 [ - + ]: 15482 : if (isinstance == -1) {
7543 : 0 : return 1;
7544 : : }
7545 [ + + ]: 15482 : if (isinstance) {
7546 : : asdl_stmt_seq* body;
7547 : : asdl_excepthandler_seq* handlers;
7548 : : asdl_stmt_seq* orelse;
7549 : : asdl_stmt_seq* finalbody;
7550 : :
7551 [ - + ]: 14 : if (_PyObject_LookupAttr(obj, state->body, &tmp) < 0) {
7552 : 0 : return 1;
7553 : : }
7554 [ - + ]: 14 : if (tmp == NULL) {
7555 : 0 : PyErr_SetString(PyExc_TypeError, "required field \"body\" missing from TryStar");
7556 : 0 : return 1;
7557 : : }
7558 : : else {
7559 : : int res;
7560 : : Py_ssize_t len;
7561 : : Py_ssize_t i;
7562 [ - + ]: 14 : if (!PyList_Check(tmp)) {
7563 : 0 : PyErr_Format(PyExc_TypeError, "TryStar field \"body\" must be a list, not a %.200s", _PyType_Name(Py_TYPE(tmp)));
7564 : 0 : goto failed;
7565 : : }
7566 : 14 : len = PyList_GET_SIZE(tmp);
7567 : 14 : body = _Py_asdl_stmt_seq_new(len, arena);
7568 [ - + ]: 14 : if (body == NULL) goto failed;
7569 [ + + ]: 27 : for (i = 0; i < len; i++) {
7570 : : stmt_ty val;
7571 : 13 : PyObject *tmp2 = PyList_GET_ITEM(tmp, i);
7572 : 13 : Py_INCREF(tmp2);
7573 [ - + ]: 13 : if (_Py_EnterRecursiveCall(" while traversing 'TryStar' node")) {
7574 : 0 : goto failed;
7575 : : }
7576 : 13 : res = obj2ast_stmt(state, tmp2, &val, arena);
7577 : 13 : _Py_LeaveRecursiveCall();
7578 : 13 : Py_DECREF(tmp2);
7579 [ - + ]: 13 : if (res != 0) goto failed;
7580 [ - + ]: 13 : if (len != PyList_GET_SIZE(tmp)) {
7581 : 0 : PyErr_SetString(PyExc_RuntimeError, "TryStar field \"body\" changed size during iteration");
7582 : 0 : goto failed;
7583 : : }
7584 : 13 : asdl_seq_SET(body, i, val);
7585 : : }
7586 [ + - ]: 14 : Py_CLEAR(tmp);
7587 : : }
7588 [ - + ]: 14 : if (_PyObject_LookupAttr(obj, state->handlers, &tmp) < 0) {
7589 : 0 : return 1;
7590 : : }
7591 [ - + ]: 14 : if (tmp == NULL) {
7592 : 0 : PyErr_SetString(PyExc_TypeError, "required field \"handlers\" missing from TryStar");
7593 : 0 : return 1;
7594 : : }
7595 : : else {
7596 : : int res;
7597 : : Py_ssize_t len;
7598 : : Py_ssize_t i;
7599 [ - + ]: 14 : if (!PyList_Check(tmp)) {
7600 : 0 : PyErr_Format(PyExc_TypeError, "TryStar field \"handlers\" must be a list, not a %.200s", _PyType_Name(Py_TYPE(tmp)));
7601 : 0 : goto failed;
7602 : : }
7603 : 14 : len = PyList_GET_SIZE(tmp);
7604 : 14 : handlers = _Py_asdl_excepthandler_seq_new(len, arena);
7605 [ - + ]: 14 : if (handlers == NULL) goto failed;
7606 [ + + ]: 25 : for (i = 0; i < len; i++) {
7607 : : excepthandler_ty val;
7608 : 11 : PyObject *tmp2 = PyList_GET_ITEM(tmp, i);
7609 : 11 : Py_INCREF(tmp2);
7610 [ - + ]: 11 : if (_Py_EnterRecursiveCall(" while traversing 'TryStar' node")) {
7611 : 0 : goto failed;
7612 : : }
7613 : 11 : res = obj2ast_excepthandler(state, tmp2, &val, arena);
7614 : 11 : _Py_LeaveRecursiveCall();
7615 : 11 : Py_DECREF(tmp2);
7616 [ - + ]: 11 : if (res != 0) goto failed;
7617 [ - + ]: 11 : if (len != PyList_GET_SIZE(tmp)) {
7618 : 0 : PyErr_SetString(PyExc_RuntimeError, "TryStar field \"handlers\" changed size during iteration");
7619 : 0 : goto failed;
7620 : : }
7621 : 11 : asdl_seq_SET(handlers, i, val);
7622 : : }
7623 [ + - ]: 14 : Py_CLEAR(tmp);
7624 : : }
7625 [ - + ]: 14 : if (_PyObject_LookupAttr(obj, state->orelse, &tmp) < 0) {
7626 : 0 : return 1;
7627 : : }
7628 [ - + ]: 14 : if (tmp == NULL) {
7629 : 0 : PyErr_SetString(PyExc_TypeError, "required field \"orelse\" missing from TryStar");
7630 : 0 : return 1;
7631 : : }
7632 : : else {
7633 : : int res;
7634 : : Py_ssize_t len;
7635 : : Py_ssize_t i;
7636 [ - + ]: 14 : if (!PyList_Check(tmp)) {
7637 : 0 : PyErr_Format(PyExc_TypeError, "TryStar field \"orelse\" must be a list, not a %.200s", _PyType_Name(Py_TYPE(tmp)));
7638 : 0 : goto failed;
7639 : : }
7640 : 14 : len = PyList_GET_SIZE(tmp);
7641 : 14 : orelse = _Py_asdl_stmt_seq_new(len, arena);
7642 [ - + ]: 14 : if (orelse == NULL) goto failed;
7643 [ + + ]: 19 : for (i = 0; i < len; i++) {
7644 : : stmt_ty val;
7645 : 5 : PyObject *tmp2 = PyList_GET_ITEM(tmp, i);
7646 : 5 : Py_INCREF(tmp2);
7647 [ - + ]: 5 : if (_Py_EnterRecursiveCall(" while traversing 'TryStar' node")) {
7648 : 0 : goto failed;
7649 : : }
7650 : 5 : res = obj2ast_stmt(state, tmp2, &val, arena);
7651 : 5 : _Py_LeaveRecursiveCall();
7652 : 5 : Py_DECREF(tmp2);
7653 [ - + ]: 5 : if (res != 0) goto failed;
7654 [ - + ]: 5 : if (len != PyList_GET_SIZE(tmp)) {
7655 : 0 : PyErr_SetString(PyExc_RuntimeError, "TryStar field \"orelse\" changed size during iteration");
7656 : 0 : goto failed;
7657 : : }
7658 : 5 : asdl_seq_SET(orelse, i, val);
7659 : : }
7660 [ + - ]: 14 : Py_CLEAR(tmp);
7661 : : }
7662 [ - + ]: 14 : if (_PyObject_LookupAttr(obj, state->finalbody, &tmp) < 0) {
7663 : 0 : return 1;
7664 : : }
7665 [ - + ]: 14 : if (tmp == NULL) {
7666 : 0 : PyErr_SetString(PyExc_TypeError, "required field \"finalbody\" missing from TryStar");
7667 : 0 : return 1;
7668 : : }
7669 : : else {
7670 : : int res;
7671 : : Py_ssize_t len;
7672 : : Py_ssize_t i;
7673 [ - + ]: 14 : if (!PyList_Check(tmp)) {
7674 : 0 : PyErr_Format(PyExc_TypeError, "TryStar field \"finalbody\" must be a list, not a %.200s", _PyType_Name(Py_TYPE(tmp)));
7675 : 0 : goto failed;
7676 : : }
7677 : 14 : len = PyList_GET_SIZE(tmp);
7678 : 14 : finalbody = _Py_asdl_stmt_seq_new(len, arena);
7679 [ - + ]: 14 : if (finalbody == NULL) goto failed;
7680 [ + + ]: 19 : for (i = 0; i < len; i++) {
7681 : : stmt_ty val;
7682 : 5 : PyObject *tmp2 = PyList_GET_ITEM(tmp, i);
7683 : 5 : Py_INCREF(tmp2);
7684 [ - + ]: 5 : if (_Py_EnterRecursiveCall(" while traversing 'TryStar' node")) {
7685 : 0 : goto failed;
7686 : : }
7687 : 5 : res = obj2ast_stmt(state, tmp2, &val, arena);
7688 : 5 : _Py_LeaveRecursiveCall();
7689 : 5 : Py_DECREF(tmp2);
7690 [ - + ]: 5 : if (res != 0) goto failed;
7691 [ - + ]: 5 : if (len != PyList_GET_SIZE(tmp)) {
7692 : 0 : PyErr_SetString(PyExc_RuntimeError, "TryStar field \"finalbody\" changed size during iteration");
7693 : 0 : goto failed;
7694 : : }
7695 : 5 : asdl_seq_SET(finalbody, i, val);
7696 : : }
7697 [ + - ]: 14 : Py_CLEAR(tmp);
7698 : : }
7699 : 14 : *out = _PyAST_TryStar(body, handlers, orelse, finalbody, lineno,
7700 : : col_offset, end_lineno, end_col_offset, arena);
7701 [ - + ]: 14 : if (*out == NULL) goto failed;
7702 : 14 : return 0;
7703 : : }
7704 : 15468 : tp = state->Assert_type;
7705 : 15468 : isinstance = PyObject_IsInstance(obj, tp);
7706 [ - + ]: 15468 : if (isinstance == -1) {
7707 : 0 : return 1;
7708 : : }
7709 [ + + ]: 15468 : if (isinstance) {
7710 : : expr_ty test;
7711 : : expr_ty msg;
7712 : :
7713 [ - + ]: 224 : if (_PyObject_LookupAttr(obj, state->test, &tmp) < 0) {
7714 : 224 : return 1;
7715 : : }
7716 [ - + ]: 224 : if (tmp == NULL) {
7717 : 0 : PyErr_SetString(PyExc_TypeError, "required field \"test\" missing from Assert");
7718 : 0 : return 1;
7719 : : }
7720 : : else {
7721 : : int res;
7722 [ - + ]: 224 : if (_Py_EnterRecursiveCall(" while traversing 'Assert' node")) {
7723 : 0 : goto failed;
7724 : : }
7725 : 224 : res = obj2ast_expr(state, tmp, &test, arena);
7726 : 224 : _Py_LeaveRecursiveCall();
7727 [ - + ]: 224 : if (res != 0) goto failed;
7728 [ + - ]: 224 : Py_CLEAR(tmp);
7729 : : }
7730 [ - + ]: 224 : if (_PyObject_LookupAttr(obj, state->msg, &tmp) < 0) {
7731 : 0 : return 1;
7732 : : }
7733 [ + - + + ]: 224 : if (tmp == NULL || tmp == Py_None) {
7734 [ + - ]: 174 : Py_CLEAR(tmp);
7735 : 174 : msg = NULL;
7736 : : }
7737 : : else {
7738 : : int res;
7739 [ - + ]: 50 : if (_Py_EnterRecursiveCall(" while traversing 'Assert' node")) {
7740 : 0 : goto failed;
7741 : : }
7742 : 50 : res = obj2ast_expr(state, tmp, &msg, arena);
7743 : 50 : _Py_LeaveRecursiveCall();
7744 [ - + ]: 50 : if (res != 0) goto failed;
7745 [ + - ]: 50 : Py_CLEAR(tmp);
7746 : : }
7747 : 224 : *out = _PyAST_Assert(test, msg, lineno, col_offset, end_lineno,
7748 : : end_col_offset, arena);
7749 [ - + ]: 224 : if (*out == NULL) goto failed;
7750 : 224 : return 0;
7751 : : }
7752 : 15244 : tp = state->Import_type;
7753 : 15244 : isinstance = PyObject_IsInstance(obj, tp);
7754 [ - + ]: 15244 : if (isinstance == -1) {
7755 : 0 : return 1;
7756 : : }
7757 [ + + ]: 15244 : if (isinstance) {
7758 : : asdl_alias_seq* names;
7759 : :
7760 [ - + ]: 961 : if (_PyObject_LookupAttr(obj, state->names, &tmp) < 0) {
7761 : 0 : return 1;
7762 : : }
7763 [ - + ]: 961 : if (tmp == NULL) {
7764 : 0 : PyErr_SetString(PyExc_TypeError, "required field \"names\" missing from Import");
7765 : 0 : return 1;
7766 : : }
7767 : : else {
7768 : : int res;
7769 : : Py_ssize_t len;
7770 : : Py_ssize_t i;
7771 [ - + ]: 961 : if (!PyList_Check(tmp)) {
7772 : 0 : PyErr_Format(PyExc_TypeError, "Import field \"names\" must be a list, not a %.200s", _PyType_Name(Py_TYPE(tmp)));
7773 : 0 : goto failed;
7774 : : }
7775 : 961 : len = PyList_GET_SIZE(tmp);
7776 : 961 : names = _Py_asdl_alias_seq_new(len, arena);
7777 [ - + ]: 961 : if (names == NULL) goto failed;
7778 [ + + ]: 1956 : for (i = 0; i < len; i++) {
7779 : : alias_ty val;
7780 : 995 : PyObject *tmp2 = PyList_GET_ITEM(tmp, i);
7781 : 995 : Py_INCREF(tmp2);
7782 [ - + ]: 995 : if (_Py_EnterRecursiveCall(" while traversing 'Import' node")) {
7783 : 0 : goto failed;
7784 : : }
7785 : 995 : res = obj2ast_alias(state, tmp2, &val, arena);
7786 : 995 : _Py_LeaveRecursiveCall();
7787 : 995 : Py_DECREF(tmp2);
7788 [ - + ]: 995 : if (res != 0) goto failed;
7789 [ - + ]: 995 : if (len != PyList_GET_SIZE(tmp)) {
7790 : 0 : PyErr_SetString(PyExc_RuntimeError, "Import field \"names\" changed size during iteration");
7791 : 0 : goto failed;
7792 : : }
7793 : 995 : asdl_seq_SET(names, i, val);
7794 : : }
7795 [ + - ]: 961 : Py_CLEAR(tmp);
7796 : : }
7797 : 961 : *out = _PyAST_Import(names, lineno, col_offset, end_lineno,
7798 : : end_col_offset, arena);
7799 [ - + ]: 961 : if (*out == NULL) goto failed;
7800 : 961 : return 0;
7801 : : }
7802 : 14283 : tp = state->ImportFrom_type;
7803 : 14283 : isinstance = PyObject_IsInstance(obj, tp);
7804 [ - + ]: 14283 : if (isinstance == -1) {
7805 : 0 : return 1;
7806 : : }
7807 [ + + ]: 14283 : if (isinstance) {
7808 : : identifier module;
7809 : : asdl_alias_seq* names;
7810 : : int level;
7811 : :
7812 [ - + ]: 371 : if (_PyObject_LookupAttr(obj, state->module, &tmp) < 0) {
7813 : 371 : return 1;
7814 : : }
7815 [ + - + + ]: 371 : if (tmp == NULL || tmp == Py_None) {
7816 [ + - ]: 2 : Py_CLEAR(tmp);
7817 : 2 : module = NULL;
7818 : : }
7819 : : else {
7820 : : int res;
7821 [ - + ]: 369 : if (_Py_EnterRecursiveCall(" while traversing 'ImportFrom' node")) {
7822 : 0 : goto failed;
7823 : : }
7824 : 369 : res = obj2ast_identifier(state, tmp, &module, arena);
7825 : 369 : _Py_LeaveRecursiveCall();
7826 [ - + ]: 369 : if (res != 0) goto failed;
7827 [ + - ]: 369 : Py_CLEAR(tmp);
7828 : : }
7829 [ - + ]: 371 : if (_PyObject_LookupAttr(obj, state->names, &tmp) < 0) {
7830 : 0 : return 1;
7831 : : }
7832 [ - + ]: 371 : if (tmp == NULL) {
7833 : 0 : PyErr_SetString(PyExc_TypeError, "required field \"names\" missing from ImportFrom");
7834 : 0 : return 1;
7835 : : }
7836 : : else {
7837 : : int res;
7838 : : Py_ssize_t len;
7839 : : Py_ssize_t i;
7840 [ - + ]: 371 : if (!PyList_Check(tmp)) {
7841 : 0 : PyErr_Format(PyExc_TypeError, "ImportFrom field \"names\" must be a list, not a %.200s", _PyType_Name(Py_TYPE(tmp)));
7842 : 0 : goto failed;
7843 : : }
7844 : 371 : len = PyList_GET_SIZE(tmp);
7845 : 371 : names = _Py_asdl_alias_seq_new(len, arena);
7846 [ - + ]: 371 : if (names == NULL) goto failed;
7847 [ + + ]: 996 : for (i = 0; i < len; i++) {
7848 : : alias_ty val;
7849 : 625 : PyObject *tmp2 = PyList_GET_ITEM(tmp, i);
7850 : 625 : Py_INCREF(tmp2);
7851 [ - + ]: 625 : if (_Py_EnterRecursiveCall(" while traversing 'ImportFrom' node")) {
7852 : 0 : goto failed;
7853 : : }
7854 : 625 : res = obj2ast_alias(state, tmp2, &val, arena);
7855 : 625 : _Py_LeaveRecursiveCall();
7856 : 625 : Py_DECREF(tmp2);
7857 [ - + ]: 625 : if (res != 0) goto failed;
7858 [ - + ]: 625 : if (len != PyList_GET_SIZE(tmp)) {
7859 : 0 : PyErr_SetString(PyExc_RuntimeError, "ImportFrom field \"names\" changed size during iteration");
7860 : 0 : goto failed;
7861 : : }
7862 : 625 : asdl_seq_SET(names, i, val);
7863 : : }
7864 [ + - ]: 371 : Py_CLEAR(tmp);
7865 : : }
7866 [ - + ]: 371 : if (_PyObject_LookupAttr(obj, state->level, &tmp) < 0) {
7867 : 0 : return 1;
7868 : : }
7869 [ + - + + ]: 371 : if (tmp == NULL || tmp == Py_None) {
7870 [ + - ]: 1 : Py_CLEAR(tmp);
7871 : 1 : level = 0;
7872 : : }
7873 : : else {
7874 : : int res;
7875 [ - + ]: 370 : if (_Py_EnterRecursiveCall(" while traversing 'ImportFrom' node")) {
7876 : 0 : goto failed;
7877 : : }
7878 : 370 : res = obj2ast_int(state, tmp, &level, arena);
7879 : 370 : _Py_LeaveRecursiveCall();
7880 [ - + ]: 370 : if (res != 0) goto failed;
7881 [ + - ]: 370 : Py_CLEAR(tmp);
7882 : : }
7883 : 371 : *out = _PyAST_ImportFrom(module, names, level, lineno, col_offset,
7884 : : end_lineno, end_col_offset, arena);
7885 [ - + ]: 371 : if (*out == NULL) goto failed;
7886 : 371 : return 0;
7887 : : }
7888 : 13912 : tp = state->Global_type;
7889 : 13912 : isinstance = PyObject_IsInstance(obj, tp);
7890 [ - + ]: 13912 : if (isinstance == -1) {
7891 : 0 : return 1;
7892 : : }
7893 [ + + ]: 13912 : if (isinstance) {
7894 : : asdl_identifier_seq* names;
7895 : :
7896 [ - + ]: 66 : if (_PyObject_LookupAttr(obj, state->names, &tmp) < 0) {
7897 : 0 : return 1;
7898 : : }
7899 [ - + ]: 66 : if (tmp == NULL) {
7900 : 0 : PyErr_SetString(PyExc_TypeError, "required field \"names\" missing from Global");
7901 : 0 : return 1;
7902 : : }
7903 : : else {
7904 : : int res;
7905 : : Py_ssize_t len;
7906 : : Py_ssize_t i;
7907 [ - + ]: 66 : if (!PyList_Check(tmp)) {
7908 : 0 : PyErr_Format(PyExc_TypeError, "Global field \"names\" must be a list, not a %.200s", _PyType_Name(Py_TYPE(tmp)));
7909 : 0 : goto failed;
7910 : : }
7911 : 66 : len = PyList_GET_SIZE(tmp);
7912 : 66 : names = _Py_asdl_identifier_seq_new(len, arena);
7913 [ - + ]: 66 : if (names == NULL) goto failed;
7914 [ + + ]: 162 : for (i = 0; i < len; i++) {
7915 : : identifier val;
7916 : 96 : PyObject *tmp2 = PyList_GET_ITEM(tmp, i);
7917 : 96 : Py_INCREF(tmp2);
7918 [ - + ]: 96 : if (_Py_EnterRecursiveCall(" while traversing 'Global' node")) {
7919 : 0 : goto failed;
7920 : : }
7921 : 96 : res = obj2ast_identifier(state, tmp2, &val, arena);
7922 : 96 : _Py_LeaveRecursiveCall();
7923 : 96 : Py_DECREF(tmp2);
7924 [ - + ]: 96 : if (res != 0) goto failed;
7925 [ - + ]: 96 : if (len != PyList_GET_SIZE(tmp)) {
7926 : 0 : PyErr_SetString(PyExc_RuntimeError, "Global field \"names\" changed size during iteration");
7927 : 0 : goto failed;
7928 : : }
7929 : 96 : asdl_seq_SET(names, i, val);
7930 : : }
7931 [ + - ]: 66 : Py_CLEAR(tmp);
7932 : : }
7933 : 66 : *out = _PyAST_Global(names, lineno, col_offset, end_lineno,
7934 : : end_col_offset, arena);
7935 [ - + ]: 66 : if (*out == NULL) goto failed;
7936 : 66 : return 0;
7937 : : }
7938 : 13846 : tp = state->Nonlocal_type;
7939 : 13846 : isinstance = PyObject_IsInstance(obj, tp);
7940 [ - + ]: 13846 : if (isinstance == -1) {
7941 : 0 : return 1;
7942 : : }
7943 [ + + ]: 13846 : if (isinstance) {
7944 : : asdl_identifier_seq* names;
7945 : :
7946 [ - + ]: 21 : if (_PyObject_LookupAttr(obj, state->names, &tmp) < 0) {
7947 : 0 : return 1;
7948 : : }
7949 [ - + ]: 21 : if (tmp == NULL) {
7950 : 0 : PyErr_SetString(PyExc_TypeError, "required field \"names\" missing from Nonlocal");
7951 : 0 : return 1;
7952 : : }
7953 : : else {
7954 : : int res;
7955 : : Py_ssize_t len;
7956 : : Py_ssize_t i;
7957 [ - + ]: 21 : if (!PyList_Check(tmp)) {
7958 : 0 : PyErr_Format(PyExc_TypeError, "Nonlocal field \"names\" must be a list, not a %.200s", _PyType_Name(Py_TYPE(tmp)));
7959 : 0 : goto failed;
7960 : : }
7961 : 21 : len = PyList_GET_SIZE(tmp);
7962 : 21 : names = _Py_asdl_identifier_seq_new(len, arena);
7963 [ - + ]: 21 : if (names == NULL) goto failed;
7964 [ + + ]: 50 : for (i = 0; i < len; i++) {
7965 : : identifier val;
7966 : 29 : PyObject *tmp2 = PyList_GET_ITEM(tmp, i);
7967 : 29 : Py_INCREF(tmp2);
7968 [ - + ]: 29 : if (_Py_EnterRecursiveCall(" while traversing 'Nonlocal' node")) {
7969 : 0 : goto failed;
7970 : : }
7971 : 29 : res = obj2ast_identifier(state, tmp2, &val, arena);
7972 : 29 : _Py_LeaveRecursiveCall();
7973 : 29 : Py_DECREF(tmp2);
7974 [ - + ]: 29 : if (res != 0) goto failed;
7975 [ - + ]: 29 : if (len != PyList_GET_SIZE(tmp)) {
7976 : 0 : PyErr_SetString(PyExc_RuntimeError, "Nonlocal field \"names\" changed size during iteration");
7977 : 0 : goto failed;
7978 : : }
7979 : 29 : asdl_seq_SET(names, i, val);
7980 : : }
7981 [ + - ]: 21 : Py_CLEAR(tmp);
7982 : : }
7983 : 21 : *out = _PyAST_Nonlocal(names, lineno, col_offset, end_lineno,
7984 : : end_col_offset, arena);
7985 [ - + ]: 21 : if (*out == NULL) goto failed;
7986 : 21 : return 0;
7987 : : }
7988 : 13825 : tp = state->Expr_type;
7989 : 13825 : isinstance = PyObject_IsInstance(obj, tp);
7990 [ - + ]: 13825 : if (isinstance == -1) {
7991 : 0 : return 1;
7992 : : }
7993 [ + + ]: 13825 : if (isinstance) {
7994 : : expr_ty value;
7995 : :
7996 [ - + ]: 12379 : if (_PyObject_LookupAttr(obj, state->value, &tmp) < 0) {
7997 : 12376 : return 1;
7998 : : }
7999 [ - + ]: 12379 : if (tmp == NULL) {
8000 : 0 : PyErr_SetString(PyExc_TypeError, "required field \"value\" missing from Expr");
8001 : 0 : return 1;
8002 : : }
8003 : : else {
8004 : : int res;
8005 [ - + ]: 12379 : if (_Py_EnterRecursiveCall(" while traversing 'Expr' node")) {
8006 : 3 : goto failed;
8007 : : }
8008 : 12379 : res = obj2ast_expr(state, tmp, &value, arena);
8009 : 12379 : _Py_LeaveRecursiveCall();
8010 [ + + ]: 12379 : if (res != 0) goto failed;
8011 [ + - ]: 12376 : Py_CLEAR(tmp);
8012 : : }
8013 : 12376 : *out = _PyAST_Expr(value, lineno, col_offset, end_lineno,
8014 : : end_col_offset, arena);
8015 [ - + ]: 12376 : if (*out == NULL) goto failed;
8016 : 12376 : return 0;
8017 : : }
8018 : 1446 : tp = state->Pass_type;
8019 : 1446 : isinstance = PyObject_IsInstance(obj, tp);
8020 [ - + ]: 1446 : if (isinstance == -1) {
8021 : 0 : return 1;
8022 : : }
8023 [ + + ]: 1446 : if (isinstance) {
8024 : :
8025 : 820 : *out = _PyAST_Pass(lineno, col_offset, end_lineno, end_col_offset,
8026 : : arena);
8027 [ - + ]: 820 : if (*out == NULL) goto failed;
8028 : 820 : return 0;
8029 : : }
8030 : 626 : tp = state->Break_type;
8031 : 626 : isinstance = PyObject_IsInstance(obj, tp);
8032 [ - + ]: 626 : if (isinstance == -1) {
8033 : 0 : return 1;
8034 : : }
8035 [ + + ]: 626 : if (isinstance) {
8036 : :
8037 : 358 : *out = _PyAST_Break(lineno, col_offset, end_lineno, end_col_offset,
8038 : : arena);
8039 [ - + ]: 358 : if (*out == NULL) goto failed;
8040 : 358 : return 0;
8041 : : }
8042 : 268 : tp = state->Continue_type;
8043 : 268 : isinstance = PyObject_IsInstance(obj, tp);
8044 [ - + ]: 268 : if (isinstance == -1) {
8045 : 0 : return 1;
8046 : : }
8047 [ + - ]: 268 : if (isinstance) {
8048 : :
8049 : 268 : *out = _PyAST_Continue(lineno, col_offset, end_lineno, end_col_offset,
8050 : : arena);
8051 [ - + ]: 268 : if (*out == NULL) goto failed;
8052 : 268 : return 0;
8053 : : }
8054 : :
8055 : 0 : PyErr_Format(PyExc_TypeError, "expected some sort of stmt, but got %R", obj);
8056 : 5 : failed:
8057 : 5 : Py_XDECREF(tmp);
8058 : 5 : return 1;
8059 : : }
8060 : :
8061 : : int
8062 : 267755 : obj2ast_expr(struct ast_state *state, PyObject* obj, expr_ty* out, PyArena*
8063 : : arena)
8064 : : {
8065 : : int isinstance;
8066 : :
8067 : 267755 : PyObject *tmp = NULL;
8068 : : PyObject *tp;
8069 : : int lineno;
8070 : : int col_offset;
8071 : : int end_lineno;
8072 : : int end_col_offset;
8073 : :
8074 [ + + ]: 267755 : if (obj == Py_None) {
8075 : 66 : *out = NULL;
8076 : 66 : return 0;
8077 : : }
8078 [ - + ]: 267689 : if (_PyObject_LookupAttr(obj, state->lineno, &tmp) < 0) {
8079 : 0 : return 1;
8080 : : }
8081 [ - + ]: 267689 : if (tmp == NULL) {
8082 : 0 : PyErr_SetString(PyExc_TypeError, "required field \"lineno\" missing from expr");
8083 : 0 : return 1;
8084 : : }
8085 : : else {
8086 : : int res;
8087 [ + + ]: 267689 : if (_Py_EnterRecursiveCall(" while traversing 'expr' node")) {
8088 : 2 : goto failed;
8089 : : }
8090 : 267687 : res = obj2ast_int(state, tmp, &lineno, arena);
8091 : 267687 : _Py_LeaveRecursiveCall();
8092 [ - + ]: 267687 : if (res != 0) goto failed;
8093 [ + - ]: 267687 : Py_CLEAR(tmp);
8094 : : }
8095 [ - + ]: 267687 : if (_PyObject_LookupAttr(obj, state->col_offset, &tmp) < 0) {
8096 : 0 : return 1;
8097 : : }
8098 [ - + ]: 267687 : if (tmp == NULL) {
8099 : 0 : PyErr_SetString(PyExc_TypeError, "required field \"col_offset\" missing from expr");
8100 : 0 : return 1;
8101 : : }
8102 : : else {
8103 : : int res;
8104 [ - + ]: 267687 : if (_Py_EnterRecursiveCall(" while traversing 'expr' node")) {
8105 : 0 : goto failed;
8106 : : }
8107 : 267687 : res = obj2ast_int(state, tmp, &col_offset, arena);
8108 : 267687 : _Py_LeaveRecursiveCall();
8109 [ - + ]: 267687 : if (res != 0) goto failed;
8110 [ + - ]: 267687 : Py_CLEAR(tmp);
8111 : : }
8112 [ - + ]: 267687 : if (_PyObject_LookupAttr(obj, state->end_lineno, &tmp) < 0) {
8113 : 0 : return 1;
8114 : : }
8115 [ + - + + ]: 267687 : if (tmp == NULL || tmp == Py_None) {
8116 [ + - ]: 85 : Py_CLEAR(tmp);
8117 : 85 : end_lineno = lineno;
8118 : : }
8119 : : else {
8120 : : int res;
8121 [ - + ]: 267602 : if (_Py_EnterRecursiveCall(" while traversing 'expr' node")) {
8122 : 0 : goto failed;
8123 : : }
8124 : 267602 : res = obj2ast_int(state, tmp, &end_lineno, arena);
8125 : 267602 : _Py_LeaveRecursiveCall();
8126 [ - + ]: 267602 : if (res != 0) goto failed;
8127 [ + - ]: 267602 : Py_CLEAR(tmp);
8128 : : }
8129 [ - + ]: 267687 : if (_PyObject_LookupAttr(obj, state->end_col_offset, &tmp) < 0) {
8130 : 0 : return 1;
8131 : : }
8132 [ + - + + ]: 267687 : if (tmp == NULL || tmp == Py_None) {
8133 [ + - ]: 85 : Py_CLEAR(tmp);
8134 : 85 : end_col_offset = col_offset;
8135 : : }
8136 : : else {
8137 : : int res;
8138 [ - + ]: 267602 : if (_Py_EnterRecursiveCall(" while traversing 'expr' node")) {
8139 : 0 : goto failed;
8140 : : }
8141 : 267602 : res = obj2ast_int(state, tmp, &end_col_offset, arena);
8142 : 267602 : _Py_LeaveRecursiveCall();
8143 [ - + ]: 267602 : if (res != 0) goto failed;
8144 [ + - ]: 267602 : Py_CLEAR(tmp);
8145 : : }
8146 : 267687 : tp = state->BoolOp_type;
8147 : 267687 : isinstance = PyObject_IsInstance(obj, tp);
8148 [ - + ]: 267687 : if (isinstance == -1) {
8149 : 0 : return 1;
8150 : : }
8151 [ + + ]: 267687 : if (isinstance) {
8152 : : boolop_ty op;
8153 : : asdl_expr_seq* values;
8154 : :
8155 [ - + ]: 2070 : if (_PyObject_LookupAttr(obj, state->op, &tmp) < 0) {
8156 : 2070 : return 1;
8157 : : }
8158 [ - + ]: 2070 : if (tmp == NULL) {
8159 : 0 : PyErr_SetString(PyExc_TypeError, "required field \"op\" missing from BoolOp");
8160 : 0 : return 1;
8161 : : }
8162 : : else {
8163 : : int res;
8164 [ - + ]: 2070 : if (_Py_EnterRecursiveCall(" while traversing 'BoolOp' node")) {
8165 : 0 : goto failed;
8166 : : }
8167 : 2070 : res = obj2ast_boolop(state, tmp, &op, arena);
8168 : 2070 : _Py_LeaveRecursiveCall();
8169 [ - + ]: 2070 : if (res != 0) goto failed;
8170 [ + - ]: 2070 : Py_CLEAR(tmp);
8171 : : }
8172 [ - + ]: 2070 : if (_PyObject_LookupAttr(obj, state->values, &tmp) < 0) {
8173 : 0 : return 1;
8174 : : }
8175 [ - + ]: 2070 : if (tmp == NULL) {
8176 : 0 : PyErr_SetString(PyExc_TypeError, "required field \"values\" missing from BoolOp");
8177 : 0 : return 1;
8178 : : }
8179 : : else {
8180 : : int res;
8181 : : Py_ssize_t len;
8182 : : Py_ssize_t i;
8183 [ - + ]: 2070 : if (!PyList_Check(tmp)) {
8184 : 0 : PyErr_Format(PyExc_TypeError, "BoolOp field \"values\" must be a list, not a %.200s", _PyType_Name(Py_TYPE(tmp)));
8185 : 0 : goto failed;
8186 : : }
8187 : 2070 : len = PyList_GET_SIZE(tmp);
8188 : 2070 : values = _Py_asdl_expr_seq_new(len, arena);
8189 [ - + ]: 2070 : if (values == NULL) goto failed;
8190 [ + + ]: 6475 : for (i = 0; i < len; i++) {
8191 : : expr_ty val;
8192 : 4405 : PyObject *tmp2 = PyList_GET_ITEM(tmp, i);
8193 : 4405 : Py_INCREF(tmp2);
8194 [ - + ]: 4405 : if (_Py_EnterRecursiveCall(" while traversing 'BoolOp' node")) {
8195 : 0 : goto failed;
8196 : : }
8197 : 4405 : res = obj2ast_expr(state, tmp2, &val, arena);
8198 : 4405 : _Py_LeaveRecursiveCall();
8199 : 4405 : Py_DECREF(tmp2);
8200 [ - + ]: 4405 : if (res != 0) goto failed;
8201 [ - + ]: 4405 : if (len != PyList_GET_SIZE(tmp)) {
8202 : 0 : PyErr_SetString(PyExc_RuntimeError, "BoolOp field \"values\" changed size during iteration");
8203 : 0 : goto failed;
8204 : : }
8205 : 4405 : asdl_seq_SET(values, i, val);
8206 : : }
8207 [ + - ]: 2070 : Py_CLEAR(tmp);
8208 : : }
8209 : 2070 : *out = _PyAST_BoolOp(op, values, lineno, col_offset, end_lineno,
8210 : : end_col_offset, arena);
8211 [ - + ]: 2070 : if (*out == NULL) goto failed;
8212 : 2070 : return 0;
8213 : : }
8214 : 265617 : tp = state->NamedExpr_type;
8215 : 265617 : isinstance = PyObject_IsInstance(obj, tp);
8216 [ - + ]: 265617 : if (isinstance == -1) {
8217 : 0 : return 1;
8218 : : }
8219 [ + + ]: 265617 : if (isinstance) {
8220 : : expr_ty target;
8221 : : expr_ty value;
8222 : :
8223 [ - + ]: 22 : if (_PyObject_LookupAttr(obj, state->target, &tmp) < 0) {
8224 : 22 : return 1;
8225 : : }
8226 [ - + ]: 22 : if (tmp == NULL) {
8227 : 0 : PyErr_SetString(PyExc_TypeError, "required field \"target\" missing from NamedExpr");
8228 : 0 : return 1;
8229 : : }
8230 : : else {
8231 : : int res;
8232 [ - + ]: 22 : if (_Py_EnterRecursiveCall(" while traversing 'NamedExpr' node")) {
8233 : 0 : goto failed;
8234 : : }
8235 : 22 : res = obj2ast_expr(state, tmp, &target, arena);
8236 : 22 : _Py_LeaveRecursiveCall();
8237 [ - + ]: 22 : if (res != 0) goto failed;
8238 [ + - ]: 22 : Py_CLEAR(tmp);
8239 : : }
8240 [ - + ]: 22 : if (_PyObject_LookupAttr(obj, state->value, &tmp) < 0) {
8241 : 0 : return 1;
8242 : : }
8243 [ - + ]: 22 : if (tmp == NULL) {
8244 : 0 : PyErr_SetString(PyExc_TypeError, "required field \"value\" missing from NamedExpr");
8245 : 0 : return 1;
8246 : : }
8247 : : else {
8248 : : int res;
8249 [ - + ]: 22 : if (_Py_EnterRecursiveCall(" while traversing 'NamedExpr' node")) {
8250 : 0 : goto failed;
8251 : : }
8252 : 22 : res = obj2ast_expr(state, tmp, &value, arena);
8253 : 22 : _Py_LeaveRecursiveCall();
8254 [ - + ]: 22 : if (res != 0) goto failed;
8255 [ + - ]: 22 : Py_CLEAR(tmp);
8256 : : }
8257 : 22 : *out = _PyAST_NamedExpr(target, value, lineno, col_offset, end_lineno,
8258 : : end_col_offset, arena);
8259 [ - + ]: 22 : if (*out == NULL) goto failed;
8260 : 22 : return 0;
8261 : : }
8262 : 265595 : tp = state->BinOp_type;
8263 : 265595 : isinstance = PyObject_IsInstance(obj, tp);
8264 [ - + ]: 265595 : if (isinstance == -1) {
8265 : 0 : return 1;
8266 : : }
8267 [ + + ]: 265595 : if (isinstance) {
8268 : : expr_ty left;
8269 : : operator_ty op;
8270 : : expr_ty right;
8271 : :
8272 [ - + ]: 6682 : if (_PyObject_LookupAttr(obj, state->left, &tmp) < 0) {
8273 : 6682 : return 1;
8274 : : }
8275 [ - + ]: 6682 : if (tmp == NULL) {
8276 : 0 : PyErr_SetString(PyExc_TypeError, "required field \"left\" missing from BinOp");
8277 : 0 : return 1;
8278 : : }
8279 : : else {
8280 : : int res;
8281 [ - + ]: 6682 : if (_Py_EnterRecursiveCall(" while traversing 'BinOp' node")) {
8282 : 0 : goto failed;
8283 : : }
8284 : 6682 : res = obj2ast_expr(state, tmp, &left, arena);
8285 : 6682 : _Py_LeaveRecursiveCall();
8286 [ - + ]: 6682 : if (res != 0) goto failed;
8287 [ + - ]: 6682 : Py_CLEAR(tmp);
8288 : : }
8289 [ - + ]: 6682 : if (_PyObject_LookupAttr(obj, state->op, &tmp) < 0) {
8290 : 0 : return 1;
8291 : : }
8292 [ - + ]: 6682 : if (tmp == NULL) {
8293 : 0 : PyErr_SetString(PyExc_TypeError, "required field \"op\" missing from BinOp");
8294 : 0 : return 1;
8295 : : }
8296 : : else {
8297 : : int res;
8298 [ - + ]: 6682 : if (_Py_EnterRecursiveCall(" while traversing 'BinOp' node")) {
8299 : 0 : goto failed;
8300 : : }
8301 : 6682 : res = obj2ast_operator(state, tmp, &op, arena);
8302 : 6682 : _Py_LeaveRecursiveCall();
8303 [ - + ]: 6682 : if (res != 0) goto failed;
8304 [ + - ]: 6682 : Py_CLEAR(tmp);
8305 : : }
8306 [ - + ]: 6682 : if (_PyObject_LookupAttr(obj, state->right, &tmp) < 0) {
8307 : 0 : return 1;
8308 : : }
8309 [ - + ]: 6682 : if (tmp == NULL) {
8310 : 0 : PyErr_SetString(PyExc_TypeError, "required field \"right\" missing from BinOp");
8311 : 0 : return 1;
8312 : : }
8313 : : else {
8314 : : int res;
8315 [ - + ]: 6682 : if (_Py_EnterRecursiveCall(" while traversing 'BinOp' node")) {
8316 : 0 : goto failed;
8317 : : }
8318 : 6682 : res = obj2ast_expr(state, tmp, &right, arena);
8319 : 6682 : _Py_LeaveRecursiveCall();
8320 [ - + ]: 6682 : if (res != 0) goto failed;
8321 [ + - ]: 6682 : Py_CLEAR(tmp);
8322 : : }
8323 : 6682 : *out = _PyAST_BinOp(left, op, right, lineno, col_offset, end_lineno,
8324 : : end_col_offset, arena);
8325 [ - + ]: 6682 : if (*out == NULL) goto failed;
8326 : 6682 : return 0;
8327 : : }
8328 : 258913 : tp = state->UnaryOp_type;
8329 : 258913 : isinstance = PyObject_IsInstance(obj, tp);
8330 [ - + ]: 258913 : if (isinstance == -1) {
8331 : 0 : return 1;
8332 : : }
8333 [ + + ]: 258913 : if (isinstance) {
8334 : : unaryop_ty op;
8335 : : expr_ty operand;
8336 : :
8337 [ - + ]: 3083 : if (_PyObject_LookupAttr(obj, state->op, &tmp) < 0) {
8338 : 2999 : return 1;
8339 : : }
8340 [ - + ]: 3083 : if (tmp == NULL) {
8341 : 0 : PyErr_SetString(PyExc_TypeError, "required field \"op\" missing from UnaryOp");
8342 : 0 : return 1;
8343 : : }
8344 : : else {
8345 : : int res;
8346 [ - + ]: 3083 : if (_Py_EnterRecursiveCall(" while traversing 'UnaryOp' node")) {
8347 : 84 : goto failed;
8348 : : }
8349 : 3083 : res = obj2ast_unaryop(state, tmp, &op, arena);
8350 : 3083 : _Py_LeaveRecursiveCall();
8351 [ - + ]: 3083 : if (res != 0) goto failed;
8352 [ + - ]: 3083 : Py_CLEAR(tmp);
8353 : : }
8354 [ - + ]: 3083 : if (_PyObject_LookupAttr(obj, state->operand, &tmp) < 0) {
8355 : 0 : return 1;
8356 : : }
8357 [ - + ]: 3083 : if (tmp == NULL) {
8358 : 0 : PyErr_SetString(PyExc_TypeError, "required field \"operand\" missing from UnaryOp");
8359 : 0 : return 1;
8360 : : }
8361 : : else {
8362 : : int res;
8363 [ - + ]: 3083 : if (_Py_EnterRecursiveCall(" while traversing 'UnaryOp' node")) {
8364 : 0 : goto failed;
8365 : : }
8366 : 3083 : res = obj2ast_expr(state, tmp, &operand, arena);
8367 : 3083 : _Py_LeaveRecursiveCall();
8368 [ + + ]: 3083 : if (res != 0) goto failed;
8369 [ + - ]: 2999 : Py_CLEAR(tmp);
8370 : : }
8371 : 2999 : *out = _PyAST_UnaryOp(op, operand, lineno, col_offset, end_lineno,
8372 : : end_col_offset, arena);
8373 [ - + ]: 2999 : if (*out == NULL) goto failed;
8374 : 2999 : return 0;
8375 : : }
8376 : 255830 : tp = state->Lambda_type;
8377 : 255830 : isinstance = PyObject_IsInstance(obj, tp);
8378 [ - + ]: 255830 : if (isinstance == -1) {
8379 : 0 : return 1;
8380 : : }
8381 [ + + ]: 255830 : if (isinstance) {
8382 : : arguments_ty args;
8383 : : expr_ty body;
8384 : :
8385 [ - + ]: 168 : if (_PyObject_LookupAttr(obj, state->args, &tmp) < 0) {
8386 : 168 : return 1;
8387 : : }
8388 [ - + ]: 168 : if (tmp == NULL) {
8389 : 0 : PyErr_SetString(PyExc_TypeError, "required field \"args\" missing from Lambda");
8390 : 0 : return 1;
8391 : : }
8392 : : else {
8393 : : int res;
8394 [ - + ]: 168 : if (_Py_EnterRecursiveCall(" while traversing 'Lambda' node")) {
8395 : 0 : goto failed;
8396 : : }
8397 : 168 : res = obj2ast_arguments(state, tmp, &args, arena);
8398 : 168 : _Py_LeaveRecursiveCall();
8399 [ - + ]: 168 : if (res != 0) goto failed;
8400 [ + - ]: 168 : Py_CLEAR(tmp);
8401 : : }
8402 [ - + ]: 168 : if (_PyObject_LookupAttr(obj, state->body, &tmp) < 0) {
8403 : 0 : return 1;
8404 : : }
8405 [ - + ]: 168 : if (tmp == NULL) {
8406 : 0 : PyErr_SetString(PyExc_TypeError, "required field \"body\" missing from Lambda");
8407 : 0 : return 1;
8408 : : }
8409 : : else {
8410 : : int res;
8411 [ - + ]: 168 : if (_Py_EnterRecursiveCall(" while traversing 'Lambda' node")) {
8412 : 0 : goto failed;
8413 : : }
8414 : 168 : res = obj2ast_expr(state, tmp, &body, arena);
8415 : 168 : _Py_LeaveRecursiveCall();
8416 [ - + ]: 168 : if (res != 0) goto failed;
8417 [ + - ]: 168 : Py_CLEAR(tmp);
8418 : : }
8419 : 168 : *out = _PyAST_Lambda(args, body, lineno, col_offset, end_lineno,
8420 : : end_col_offset, arena);
8421 [ - + ]: 168 : if (*out == NULL) goto failed;
8422 : 168 : return 0;
8423 : : }
8424 : 255662 : tp = state->IfExp_type;
8425 : 255662 : isinstance = PyObject_IsInstance(obj, tp);
8426 [ - + ]: 255662 : if (isinstance == -1) {
8427 : 0 : return 1;
8428 : : }
8429 [ + + ]: 255662 : if (isinstance) {
8430 : : expr_ty test;
8431 : : expr_ty body;
8432 : : expr_ty orelse;
8433 : :
8434 [ - + ]: 238 : if (_PyObject_LookupAttr(obj, state->test, &tmp) < 0) {
8435 : 238 : return 1;
8436 : : }
8437 [ - + ]: 238 : if (tmp == NULL) {
8438 : 0 : PyErr_SetString(PyExc_TypeError, "required field \"test\" missing from IfExp");
8439 : 0 : return 1;
8440 : : }
8441 : : else {
8442 : : int res;
8443 [ - + ]: 238 : if (_Py_EnterRecursiveCall(" while traversing 'IfExp' node")) {
8444 : 0 : goto failed;
8445 : : }
8446 : 238 : res = obj2ast_expr(state, tmp, &test, arena);
8447 : 238 : _Py_LeaveRecursiveCall();
8448 [ - + ]: 238 : if (res != 0) goto failed;
8449 [ + - ]: 238 : Py_CLEAR(tmp);
8450 : : }
8451 [ - + ]: 238 : if (_PyObject_LookupAttr(obj, state->body, &tmp) < 0) {
8452 : 0 : return 1;
8453 : : }
8454 [ - + ]: 238 : if (tmp == NULL) {
8455 : 0 : PyErr_SetString(PyExc_TypeError, "required field \"body\" missing from IfExp");
8456 : 0 : return 1;
8457 : : }
8458 : : else {
8459 : : int res;
8460 [ - + ]: 238 : if (_Py_EnterRecursiveCall(" while traversing 'IfExp' node")) {
8461 : 0 : goto failed;
8462 : : }
8463 : 238 : res = obj2ast_expr(state, tmp, &body, arena);
8464 : 238 : _Py_LeaveRecursiveCall();
8465 [ - + ]: 238 : if (res != 0) goto failed;
8466 [ + - ]: 238 : Py_CLEAR(tmp);
8467 : : }
8468 [ - + ]: 238 : if (_PyObject_LookupAttr(obj, state->orelse, &tmp) < 0) {
8469 : 0 : return 1;
8470 : : }
8471 [ - + ]: 238 : if (tmp == NULL) {
8472 : 0 : PyErr_SetString(PyExc_TypeError, "required field \"orelse\" missing from IfExp");
8473 : 0 : return 1;
8474 : : }
8475 : : else {
8476 : : int res;
8477 [ - + ]: 238 : if (_Py_EnterRecursiveCall(" while traversing 'IfExp' node")) {
8478 : 0 : goto failed;
8479 : : }
8480 : 238 : res = obj2ast_expr(state, tmp, &orelse, arena);
8481 : 238 : _Py_LeaveRecursiveCall();
8482 [ - + ]: 238 : if (res != 0) goto failed;
8483 [ + - ]: 238 : Py_CLEAR(tmp);
8484 : : }
8485 : 238 : *out = _PyAST_IfExp(test, body, orelse, lineno, col_offset, end_lineno,
8486 : : end_col_offset, arena);
8487 [ - + ]: 238 : if (*out == NULL) goto failed;
8488 : 238 : return 0;
8489 : : }
8490 : 255424 : tp = state->Dict_type;
8491 : 255424 : isinstance = PyObject_IsInstance(obj, tp);
8492 [ - + ]: 255424 : if (isinstance == -1) {
8493 : 0 : return 1;
8494 : : }
8495 [ + + ]: 255424 : if (isinstance) {
8496 : : asdl_expr_seq* keys;
8497 : : asdl_expr_seq* values;
8498 : :
8499 [ - + ]: 625 : if (_PyObject_LookupAttr(obj, state->keys, &tmp) < 0) {
8500 : 0 : return 1;
8501 : : }
8502 [ - + ]: 625 : if (tmp == NULL) {
8503 : 0 : PyErr_SetString(PyExc_TypeError, "required field \"keys\" missing from Dict");
8504 : 0 : return 1;
8505 : : }
8506 : : else {
8507 : : int res;
8508 : : Py_ssize_t len;
8509 : : Py_ssize_t i;
8510 [ - + ]: 625 : if (!PyList_Check(tmp)) {
8511 : 0 : PyErr_Format(PyExc_TypeError, "Dict field \"keys\" must be a list, not a %.200s", _PyType_Name(Py_TYPE(tmp)));
8512 : 0 : goto failed;
8513 : : }
8514 : 625 : len = PyList_GET_SIZE(tmp);
8515 : 625 : keys = _Py_asdl_expr_seq_new(len, arena);
8516 [ - + ]: 625 : if (keys == NULL) goto failed;
8517 [ + + ]: 3353 : for (i = 0; i < len; i++) {
8518 : : expr_ty val;
8519 : 2728 : PyObject *tmp2 = PyList_GET_ITEM(tmp, i);
8520 : 2728 : Py_INCREF(tmp2);
8521 [ - + ]: 2728 : if (_Py_EnterRecursiveCall(" while traversing 'Dict' node")) {
8522 : 0 : goto failed;
8523 : : }
8524 : 2728 : res = obj2ast_expr(state, tmp2, &val, arena);
8525 : 2728 : _Py_LeaveRecursiveCall();
8526 : 2728 : Py_DECREF(tmp2);
8527 [ - + ]: 2728 : if (res != 0) goto failed;
8528 [ - + ]: 2728 : if (len != PyList_GET_SIZE(tmp)) {
8529 : 0 : PyErr_SetString(PyExc_RuntimeError, "Dict field \"keys\" changed size during iteration");
8530 : 0 : goto failed;
8531 : : }
8532 : 2728 : asdl_seq_SET(keys, i, val);
8533 : : }
8534 [ + - ]: 625 : Py_CLEAR(tmp);
8535 : : }
8536 [ - + ]: 625 : if (_PyObject_LookupAttr(obj, state->values, &tmp) < 0) {
8537 : 0 : return 1;
8538 : : }
8539 [ - + ]: 625 : if (tmp == NULL) {
8540 : 0 : PyErr_SetString(PyExc_TypeError, "required field \"values\" missing from Dict");
8541 : 0 : return 1;
8542 : : }
8543 : : else {
8544 : : int res;
8545 : : Py_ssize_t len;
8546 : : Py_ssize_t i;
8547 [ - + ]: 625 : if (!PyList_Check(tmp)) {
8548 : 0 : PyErr_Format(PyExc_TypeError, "Dict field \"values\" must be a list, not a %.200s", _PyType_Name(Py_TYPE(tmp)));
8549 : 0 : goto failed;
8550 : : }
8551 : 625 : len = PyList_GET_SIZE(tmp);
8552 : 625 : values = _Py_asdl_expr_seq_new(len, arena);
8553 [ - + ]: 625 : if (values == NULL) goto failed;
8554 [ + + ]: 3354 : for (i = 0; i < len; i++) {
8555 : : expr_ty val;
8556 : 2729 : PyObject *tmp2 = PyList_GET_ITEM(tmp, i);
8557 : 2729 : Py_INCREF(tmp2);
8558 [ - + ]: 2729 : if (_Py_EnterRecursiveCall(" while traversing 'Dict' node")) {
8559 : 0 : goto failed;
8560 : : }
8561 : 2729 : res = obj2ast_expr(state, tmp2, &val, arena);
8562 : 2729 : _Py_LeaveRecursiveCall();
8563 : 2729 : Py_DECREF(tmp2);
8564 [ - + ]: 2729 : if (res != 0) goto failed;
8565 [ - + ]: 2729 : if (len != PyList_GET_SIZE(tmp)) {
8566 : 0 : PyErr_SetString(PyExc_RuntimeError, "Dict field \"values\" changed size during iteration");
8567 : 0 : goto failed;
8568 : : }
8569 : 2729 : asdl_seq_SET(values, i, val);
8570 : : }
8571 [ + - ]: 625 : Py_CLEAR(tmp);
8572 : : }
8573 : 625 : *out = _PyAST_Dict(keys, values, lineno, col_offset, end_lineno,
8574 : : end_col_offset, arena);
8575 [ - + ]: 625 : if (*out == NULL) goto failed;
8576 : 625 : return 0;
8577 : : }
8578 : 254799 : tp = state->Set_type;
8579 : 254799 : isinstance = PyObject_IsInstance(obj, tp);
8580 [ - + ]: 254799 : if (isinstance == -1) {
8581 : 0 : return 1;
8582 : : }
8583 [ + + ]: 254799 : if (isinstance) {
8584 : : asdl_expr_seq* elts;
8585 : :
8586 [ - + ]: 114 : if (_PyObject_LookupAttr(obj, state->elts, &tmp) < 0) {
8587 : 0 : return 1;
8588 : : }
8589 [ - + ]: 114 : if (tmp == NULL) {
8590 : 0 : PyErr_SetString(PyExc_TypeError, "required field \"elts\" missing from Set");
8591 : 0 : return 1;
8592 : : }
8593 : : else {
8594 : : int res;
8595 : : Py_ssize_t len;
8596 : : Py_ssize_t i;
8597 [ - + ]: 114 : if (!PyList_Check(tmp)) {
8598 : 0 : PyErr_Format(PyExc_TypeError, "Set field \"elts\" must be a list, not a %.200s", _PyType_Name(Py_TYPE(tmp)));
8599 : 0 : goto failed;
8600 : : }
8601 : 114 : len = PyList_GET_SIZE(tmp);
8602 : 114 : elts = _Py_asdl_expr_seq_new(len, arena);
8603 [ - + ]: 114 : if (elts == NULL) goto failed;
8604 [ + + ]: 411 : for (i = 0; i < len; i++) {
8605 : : expr_ty val;
8606 : 297 : PyObject *tmp2 = PyList_GET_ITEM(tmp, i);
8607 : 297 : Py_INCREF(tmp2);
8608 [ - + ]: 297 : if (_Py_EnterRecursiveCall(" while traversing 'Set' node")) {
8609 : 0 : goto failed;
8610 : : }
8611 : 297 : res = obj2ast_expr(state, tmp2, &val, arena);
8612 : 297 : _Py_LeaveRecursiveCall();
8613 : 297 : Py_DECREF(tmp2);
8614 [ - + ]: 297 : if (res != 0) goto failed;
8615 [ - + ]: 297 : if (len != PyList_GET_SIZE(tmp)) {
8616 : 0 : PyErr_SetString(PyExc_RuntimeError, "Set field \"elts\" changed size during iteration");
8617 : 0 : goto failed;
8618 : : }
8619 : 297 : asdl_seq_SET(elts, i, val);
8620 : : }
8621 [ + - ]: 114 : Py_CLEAR(tmp);
8622 : : }
8623 : 114 : *out = _PyAST_Set(elts, lineno, col_offset, end_lineno, end_col_offset,
8624 : : arena);
8625 [ - + ]: 114 : if (*out == NULL) goto failed;
8626 : 114 : return 0;
8627 : : }
8628 : 254685 : tp = state->ListComp_type;
8629 : 254685 : isinstance = PyObject_IsInstance(obj, tp);
8630 [ - + ]: 254685 : if (isinstance == -1) {
8631 : 0 : return 1;
8632 : : }
8633 [ + + ]: 254685 : if (isinstance) {
8634 : : expr_ty elt;
8635 : : asdl_comprehension_seq* generators;
8636 : :
8637 [ - + ]: 320 : if (_PyObject_LookupAttr(obj, state->elt, &tmp) < 0) {
8638 : 320 : return 1;
8639 : : }
8640 [ - + ]: 320 : if (tmp == NULL) {
8641 : 0 : PyErr_SetString(PyExc_TypeError, "required field \"elt\" missing from ListComp");
8642 : 0 : return 1;
8643 : : }
8644 : : else {
8645 : : int res;
8646 [ - + ]: 320 : if (_Py_EnterRecursiveCall(" while traversing 'ListComp' node")) {
8647 : 0 : goto failed;
8648 : : }
8649 : 320 : res = obj2ast_expr(state, tmp, &elt, arena);
8650 : 320 : _Py_LeaveRecursiveCall();
8651 [ - + ]: 320 : if (res != 0) goto failed;
8652 [ + - ]: 320 : Py_CLEAR(tmp);
8653 : : }
8654 [ - + ]: 320 : if (_PyObject_LookupAttr(obj, state->generators, &tmp) < 0) {
8655 : 0 : return 1;
8656 : : }
8657 [ - + ]: 320 : if (tmp == NULL) {
8658 : 0 : PyErr_SetString(PyExc_TypeError, "required field \"generators\" missing from ListComp");
8659 : 0 : return 1;
8660 : : }
8661 : : else {
8662 : : int res;
8663 : : Py_ssize_t len;
8664 : : Py_ssize_t i;
8665 [ - + ]: 320 : if (!PyList_Check(tmp)) {
8666 : 0 : PyErr_Format(PyExc_TypeError, "ListComp field \"generators\" must be a list, not a %.200s", _PyType_Name(Py_TYPE(tmp)));
8667 : 0 : goto failed;
8668 : : }
8669 : 320 : len = PyList_GET_SIZE(tmp);
8670 : 320 : generators = _Py_asdl_comprehension_seq_new(len, arena);
8671 [ - + ]: 320 : if (generators == NULL) goto failed;
8672 [ + + ]: 656 : for (i = 0; i < len; i++) {
8673 : : comprehension_ty val;
8674 : 336 : PyObject *tmp2 = PyList_GET_ITEM(tmp, i);
8675 : 336 : Py_INCREF(tmp2);
8676 [ - + ]: 336 : if (_Py_EnterRecursiveCall(" while traversing 'ListComp' node")) {
8677 : 0 : goto failed;
8678 : : }
8679 : 336 : res = obj2ast_comprehension(state, tmp2, &val, arena);
8680 : 336 : _Py_LeaveRecursiveCall();
8681 : 336 : Py_DECREF(tmp2);
8682 [ - + ]: 336 : if (res != 0) goto failed;
8683 [ - + ]: 336 : if (len != PyList_GET_SIZE(tmp)) {
8684 : 0 : PyErr_SetString(PyExc_RuntimeError, "ListComp field \"generators\" changed size during iteration");
8685 : 0 : goto failed;
8686 : : }
8687 : 336 : asdl_seq_SET(generators, i, val);
8688 : : }
8689 [ + - ]: 320 : Py_CLEAR(tmp);
8690 : : }
8691 : 320 : *out = _PyAST_ListComp(elt, generators, lineno, col_offset, end_lineno,
8692 : : end_col_offset, arena);
8693 [ - + ]: 320 : if (*out == NULL) goto failed;
8694 : 320 : return 0;
8695 : : }
8696 : 254365 : tp = state->SetComp_type;
8697 : 254365 : isinstance = PyObject_IsInstance(obj, tp);
8698 [ - + ]: 254365 : if (isinstance == -1) {
8699 : 0 : return 1;
8700 : : }
8701 [ + + ]: 254365 : if (isinstance) {
8702 : : expr_ty elt;
8703 : : asdl_comprehension_seq* generators;
8704 : :
8705 [ - + ]: 23 : if (_PyObject_LookupAttr(obj, state->elt, &tmp) < 0) {
8706 : 23 : return 1;
8707 : : }
8708 [ - + ]: 23 : if (tmp == NULL) {
8709 : 0 : PyErr_SetString(PyExc_TypeError, "required field \"elt\" missing from SetComp");
8710 : 0 : return 1;
8711 : : }
8712 : : else {
8713 : : int res;
8714 [ - + ]: 23 : if (_Py_EnterRecursiveCall(" while traversing 'SetComp' node")) {
8715 : 0 : goto failed;
8716 : : }
8717 : 23 : res = obj2ast_expr(state, tmp, &elt, arena);
8718 : 23 : _Py_LeaveRecursiveCall();
8719 [ - + ]: 23 : if (res != 0) goto failed;
8720 [ + - ]: 23 : Py_CLEAR(tmp);
8721 : : }
8722 [ - + ]: 23 : if (_PyObject_LookupAttr(obj, state->generators, &tmp) < 0) {
8723 : 0 : return 1;
8724 : : }
8725 [ - + ]: 23 : if (tmp == NULL) {
8726 : 0 : PyErr_SetString(PyExc_TypeError, "required field \"generators\" missing from SetComp");
8727 : 0 : return 1;
8728 : : }
8729 : : else {
8730 : : int res;
8731 : : Py_ssize_t len;
8732 : : Py_ssize_t i;
8733 [ - + ]: 23 : if (!PyList_Check(tmp)) {
8734 : 0 : PyErr_Format(PyExc_TypeError, "SetComp field \"generators\" must be a list, not a %.200s", _PyType_Name(Py_TYPE(tmp)));
8735 : 0 : goto failed;
8736 : : }
8737 : 23 : len = PyList_GET_SIZE(tmp);
8738 : 23 : generators = _Py_asdl_comprehension_seq_new(len, arena);
8739 [ - + ]: 23 : if (generators == NULL) goto failed;
8740 [ + + ]: 45 : for (i = 0; i < len; i++) {
8741 : : comprehension_ty val;
8742 : 22 : PyObject *tmp2 = PyList_GET_ITEM(tmp, i);
8743 : 22 : Py_INCREF(tmp2);
8744 [ - + ]: 22 : if (_Py_EnterRecursiveCall(" while traversing 'SetComp' node")) {
8745 : 0 : goto failed;
8746 : : }
8747 : 22 : res = obj2ast_comprehension(state, tmp2, &val, arena);
8748 : 22 : _Py_LeaveRecursiveCall();
8749 : 22 : Py_DECREF(tmp2);
8750 [ - + ]: 22 : if (res != 0) goto failed;
8751 [ - + ]: 22 : if (len != PyList_GET_SIZE(tmp)) {
8752 : 0 : PyErr_SetString(PyExc_RuntimeError, "SetComp field \"generators\" changed size during iteration");
8753 : 0 : goto failed;
8754 : : }
8755 : 22 : asdl_seq_SET(generators, i, val);
8756 : : }
8757 [ + - ]: 23 : Py_CLEAR(tmp);
8758 : : }
8759 : 23 : *out = _PyAST_SetComp(elt, generators, lineno, col_offset, end_lineno,
8760 : : end_col_offset, arena);
8761 [ - + ]: 23 : if (*out == NULL) goto failed;
8762 : 23 : return 0;
8763 : : }
8764 : 254342 : tp = state->DictComp_type;
8765 : 254342 : isinstance = PyObject_IsInstance(obj, tp);
8766 [ - + ]: 254342 : if (isinstance == -1) {
8767 : 0 : return 1;
8768 : : }
8769 [ + + ]: 254342 : if (isinstance) {
8770 : : expr_ty key;
8771 : : expr_ty value;
8772 : : asdl_comprehension_seq* generators;
8773 : :
8774 [ - + ]: 37 : if (_PyObject_LookupAttr(obj, state->key, &tmp) < 0) {
8775 : 37 : return 1;
8776 : : }
8777 [ - + ]: 37 : if (tmp == NULL) {
8778 : 0 : PyErr_SetString(PyExc_TypeError, "required field \"key\" missing from DictComp");
8779 : 0 : return 1;
8780 : : }
8781 : : else {
8782 : : int res;
8783 [ - + ]: 37 : if (_Py_EnterRecursiveCall(" while traversing 'DictComp' node")) {
8784 : 0 : goto failed;
8785 : : }
8786 : 37 : res = obj2ast_expr(state, tmp, &key, arena);
8787 : 37 : _Py_LeaveRecursiveCall();
8788 [ - + ]: 37 : if (res != 0) goto failed;
8789 [ + - ]: 37 : Py_CLEAR(tmp);
8790 : : }
8791 [ - + ]: 37 : if (_PyObject_LookupAttr(obj, state->value, &tmp) < 0) {
8792 : 0 : return 1;
8793 : : }
8794 [ - + ]: 37 : if (tmp == NULL) {
8795 : 0 : PyErr_SetString(PyExc_TypeError, "required field \"value\" missing from DictComp");
8796 : 0 : return 1;
8797 : : }
8798 : : else {
8799 : : int res;
8800 [ - + ]: 37 : if (_Py_EnterRecursiveCall(" while traversing 'DictComp' node")) {
8801 : 0 : goto failed;
8802 : : }
8803 : 37 : res = obj2ast_expr(state, tmp, &value, arena);
8804 : 37 : _Py_LeaveRecursiveCall();
8805 [ - + ]: 37 : if (res != 0) goto failed;
8806 [ + - ]: 37 : Py_CLEAR(tmp);
8807 : : }
8808 [ - + ]: 37 : if (_PyObject_LookupAttr(obj, state->generators, &tmp) < 0) {
8809 : 0 : return 1;
8810 : : }
8811 [ - + ]: 37 : if (tmp == NULL) {
8812 : 0 : PyErr_SetString(PyExc_TypeError, "required field \"generators\" missing from DictComp");
8813 : 0 : return 1;
8814 : : }
8815 : : else {
8816 : : int res;
8817 : : Py_ssize_t len;
8818 : : Py_ssize_t i;
8819 [ - + ]: 37 : if (!PyList_Check(tmp)) {
8820 : 0 : PyErr_Format(PyExc_TypeError, "DictComp field \"generators\" must be a list, not a %.200s", _PyType_Name(Py_TYPE(tmp)));
8821 : 0 : goto failed;
8822 : : }
8823 : 37 : len = PyList_GET_SIZE(tmp);
8824 : 37 : generators = _Py_asdl_comprehension_seq_new(len, arena);
8825 [ - + ]: 37 : if (generators == NULL) goto failed;
8826 [ + + ]: 77 : for (i = 0; i < len; i++) {
8827 : : comprehension_ty val;
8828 : 40 : PyObject *tmp2 = PyList_GET_ITEM(tmp, i);
8829 : 40 : Py_INCREF(tmp2);
8830 [ - + ]: 40 : if (_Py_EnterRecursiveCall(" while traversing 'DictComp' node")) {
8831 : 0 : goto failed;
8832 : : }
8833 : 40 : res = obj2ast_comprehension(state, tmp2, &val, arena);
8834 : 40 : _Py_LeaveRecursiveCall();
8835 : 40 : Py_DECREF(tmp2);
8836 [ - + ]: 40 : if (res != 0) goto failed;
8837 [ - + ]: 40 : if (len != PyList_GET_SIZE(tmp)) {
8838 : 0 : PyErr_SetString(PyExc_RuntimeError, "DictComp field \"generators\" changed size during iteration");
8839 : 0 : goto failed;
8840 : : }
8841 : 40 : asdl_seq_SET(generators, i, val);
8842 : : }
8843 [ + - ]: 37 : Py_CLEAR(tmp);
8844 : : }
8845 : 37 : *out = _PyAST_DictComp(key, value, generators, lineno, col_offset,
8846 : : end_lineno, end_col_offset, arena);
8847 [ - + ]: 37 : if (*out == NULL) goto failed;
8848 : 37 : return 0;
8849 : : }
8850 : 254305 : tp = state->GeneratorExp_type;
8851 : 254305 : isinstance = PyObject_IsInstance(obj, tp);
8852 [ - + ]: 254305 : if (isinstance == -1) {
8853 : 0 : return 1;
8854 : : }
8855 [ + + ]: 254305 : if (isinstance) {
8856 : : expr_ty elt;
8857 : : asdl_comprehension_seq* generators;
8858 : :
8859 [ - + ]: 232 : if (_PyObject_LookupAttr(obj, state->elt, &tmp) < 0) {
8860 : 232 : return 1;
8861 : : }
8862 [ - + ]: 232 : if (tmp == NULL) {
8863 : 0 : PyErr_SetString(PyExc_TypeError, "required field \"elt\" missing from GeneratorExp");
8864 : 0 : return 1;
8865 : : }
8866 : : else {
8867 : : int res;
8868 [ - + ]: 232 : if (_Py_EnterRecursiveCall(" while traversing 'GeneratorExp' node")) {
8869 : 0 : goto failed;
8870 : : }
8871 : 232 : res = obj2ast_expr(state, tmp, &elt, arena);
8872 : 232 : _Py_LeaveRecursiveCall();
8873 [ - + ]: 232 : if (res != 0) goto failed;
8874 [ + - ]: 232 : Py_CLEAR(tmp);
8875 : : }
8876 [ - + ]: 232 : if (_PyObject_LookupAttr(obj, state->generators, &tmp) < 0) {
8877 : 0 : return 1;
8878 : : }
8879 [ - + ]: 232 : if (tmp == NULL) {
8880 : 0 : PyErr_SetString(PyExc_TypeError, "required field \"generators\" missing from GeneratorExp");
8881 : 0 : return 1;
8882 : : }
8883 : : else {
8884 : : int res;
8885 : : Py_ssize_t len;
8886 : : Py_ssize_t i;
8887 [ - + ]: 232 : if (!PyList_Check(tmp)) {
8888 : 0 : PyErr_Format(PyExc_TypeError, "GeneratorExp field \"generators\" must be a list, not a %.200s", _PyType_Name(Py_TYPE(tmp)));
8889 : 0 : goto failed;
8890 : : }
8891 : 232 : len = PyList_GET_SIZE(tmp);
8892 : 232 : generators = _Py_asdl_comprehension_seq_new(len, arena);
8893 [ - + ]: 232 : if (generators == NULL) goto failed;
8894 [ + + ]: 469 : for (i = 0; i < len; i++) {
8895 : : comprehension_ty val;
8896 : 237 : PyObject *tmp2 = PyList_GET_ITEM(tmp, i);
8897 : 237 : Py_INCREF(tmp2);
8898 [ - + ]: 237 : if (_Py_EnterRecursiveCall(" while traversing 'GeneratorExp' node")) {
8899 : 0 : goto failed;
8900 : : }
8901 : 237 : res = obj2ast_comprehension(state, tmp2, &val, arena);
8902 : 237 : _Py_LeaveRecursiveCall();
8903 : 237 : Py_DECREF(tmp2);
8904 [ - + ]: 237 : if (res != 0) goto failed;
8905 [ - + ]: 237 : if (len != PyList_GET_SIZE(tmp)) {
8906 : 0 : PyErr_SetString(PyExc_RuntimeError, "GeneratorExp field \"generators\" changed size during iteration");
8907 : 0 : goto failed;
8908 : : }
8909 : 237 : asdl_seq_SET(generators, i, val);
8910 : : }
8911 [ + - ]: 232 : Py_CLEAR(tmp);
8912 : : }
8913 : 232 : *out = _PyAST_GeneratorExp(elt, generators, lineno, col_offset,
8914 : : end_lineno, end_col_offset, arena);
8915 [ - + ]: 232 : if (*out == NULL) goto failed;
8916 : 232 : return 0;
8917 : : }
8918 : 254073 : tp = state->Await_type;
8919 : 254073 : isinstance = PyObject_IsInstance(obj, tp);
8920 [ - + ]: 254073 : if (isinstance == -1) {
8921 : 0 : return 1;
8922 : : }
8923 [ + + ]: 254073 : if (isinstance) {
8924 : : expr_ty value;
8925 : :
8926 [ - + ]: 14 : if (_PyObject_LookupAttr(obj, state->value, &tmp) < 0) {
8927 : 14 : return 1;
8928 : : }
8929 [ - + ]: 14 : if (tmp == NULL) {
8930 : 0 : PyErr_SetString(PyExc_TypeError, "required field \"value\" missing from Await");
8931 : 0 : return 1;
8932 : : }
8933 : : else {
8934 : : int res;
8935 [ - + ]: 14 : if (_Py_EnterRecursiveCall(" while traversing 'Await' node")) {
8936 : 0 : goto failed;
8937 : : }
8938 : 14 : res = obj2ast_expr(state, tmp, &value, arena);
8939 : 14 : _Py_LeaveRecursiveCall();
8940 [ - + ]: 14 : if (res != 0) goto failed;
8941 [ + - ]: 14 : Py_CLEAR(tmp);
8942 : : }
8943 : 14 : *out = _PyAST_Await(value, lineno, col_offset, end_lineno,
8944 : : end_col_offset, arena);
8945 [ - + ]: 14 : if (*out == NULL) goto failed;
8946 : 14 : return 0;
8947 : : }
8948 : 254059 : tp = state->Yield_type;
8949 : 254059 : isinstance = PyObject_IsInstance(obj, tp);
8950 [ - + ]: 254059 : if (isinstance == -1) {
8951 : 0 : return 1;
8952 : : }
8953 [ + + ]: 254059 : if (isinstance) {
8954 : : expr_ty value;
8955 : :
8956 [ - + ]: 210 : if (_PyObject_LookupAttr(obj, state->value, &tmp) < 0) {
8957 : 210 : return 1;
8958 : : }
8959 [ + - + + ]: 210 : if (tmp == NULL || tmp == Py_None) {
8960 [ + - ]: 7 : Py_CLEAR(tmp);
8961 : 7 : value = NULL;
8962 : : }
8963 : : else {
8964 : : int res;
8965 [ - + ]: 203 : if (_Py_EnterRecursiveCall(" while traversing 'Yield' node")) {
8966 : 0 : goto failed;
8967 : : }
8968 : 203 : res = obj2ast_expr(state, tmp, &value, arena);
8969 : 203 : _Py_LeaveRecursiveCall();
8970 [ - + ]: 203 : if (res != 0) goto failed;
8971 [ + - ]: 203 : Py_CLEAR(tmp);
8972 : : }
8973 : 210 : *out = _PyAST_Yield(value, lineno, col_offset, end_lineno,
8974 : : end_col_offset, arena);
8975 [ - + ]: 210 : if (*out == NULL) goto failed;
8976 : 210 : return 0;
8977 : : }
8978 : 253849 : tp = state->YieldFrom_type;
8979 : 253849 : isinstance = PyObject_IsInstance(obj, tp);
8980 [ - + ]: 253849 : if (isinstance == -1) {
8981 : 0 : return 1;
8982 : : }
8983 [ + + ]: 253849 : if (isinstance) {
8984 : : expr_ty value;
8985 : :
8986 [ - + ]: 52 : if (_PyObject_LookupAttr(obj, state->value, &tmp) < 0) {
8987 : 51 : return 1;
8988 : : }
8989 [ - + ]: 52 : if (tmp == NULL) {
8990 : 0 : PyErr_SetString(PyExc_TypeError, "required field \"value\" missing from YieldFrom");
8991 : 0 : return 1;
8992 : : }
8993 : : else {
8994 : : int res;
8995 [ - + ]: 52 : if (_Py_EnterRecursiveCall(" while traversing 'YieldFrom' node")) {
8996 : 1 : goto failed;
8997 : : }
8998 : 52 : res = obj2ast_expr(state, tmp, &value, arena);
8999 : 52 : _Py_LeaveRecursiveCall();
9000 [ - + ]: 52 : if (res != 0) goto failed;
9001 [ + - ]: 52 : Py_CLEAR(tmp);
9002 : : }
9003 : 52 : *out = _PyAST_YieldFrom(value, lineno, col_offset, end_lineno,
9004 : : end_col_offset, arena);
9005 [ + + ]: 52 : if (*out == NULL) goto failed;
9006 : 51 : return 0;
9007 : : }
9008 : 253797 : tp = state->Compare_type;
9009 : 253797 : isinstance = PyObject_IsInstance(obj, tp);
9010 [ - + ]: 253797 : if (isinstance == -1) {
9011 : 0 : return 1;
9012 : : }
9013 [ + + ]: 253797 : if (isinstance) {
9014 : : expr_ty left;
9015 : : asdl_int_seq* ops;
9016 : : asdl_expr_seq* comparators;
9017 : :
9018 [ - + ]: 8198 : if (_PyObject_LookupAttr(obj, state->left, &tmp) < 0) {
9019 : 8198 : return 1;
9020 : : }
9021 [ - + ]: 8198 : if (tmp == NULL) {
9022 : 0 : PyErr_SetString(PyExc_TypeError, "required field \"left\" missing from Compare");
9023 : 0 : return 1;
9024 : : }
9025 : : else {
9026 : : int res;
9027 [ - + ]: 8198 : if (_Py_EnterRecursiveCall(" while traversing 'Compare' node")) {
9028 : 0 : goto failed;
9029 : : }
9030 : 8198 : res = obj2ast_expr(state, tmp, &left, arena);
9031 : 8198 : _Py_LeaveRecursiveCall();
9032 [ - + ]: 8198 : if (res != 0) goto failed;
9033 [ + - ]: 8198 : Py_CLEAR(tmp);
9034 : : }
9035 [ - + ]: 8198 : if (_PyObject_LookupAttr(obj, state->ops, &tmp) < 0) {
9036 : 0 : return 1;
9037 : : }
9038 [ - + ]: 8198 : if (tmp == NULL) {
9039 : 0 : PyErr_SetString(PyExc_TypeError, "required field \"ops\" missing from Compare");
9040 : 0 : return 1;
9041 : : }
9042 : : else {
9043 : : int res;
9044 : : Py_ssize_t len;
9045 : : Py_ssize_t i;
9046 [ - + ]: 8198 : if (!PyList_Check(tmp)) {
9047 : 0 : PyErr_Format(PyExc_TypeError, "Compare field \"ops\" must be a list, not a %.200s", _PyType_Name(Py_TYPE(tmp)));
9048 : 0 : goto failed;
9049 : : }
9050 : 8198 : len = PyList_GET_SIZE(tmp);
9051 : 8198 : ops = _Py_asdl_int_seq_new(len, arena);
9052 [ - + ]: 8198 : if (ops == NULL) goto failed;
9053 [ + + ]: 16532 : for (i = 0; i < len; i++) {
9054 : : cmpop_ty val;
9055 : 8334 : PyObject *tmp2 = PyList_GET_ITEM(tmp, i);
9056 : 8334 : Py_INCREF(tmp2);
9057 [ - + ]: 8334 : if (_Py_EnterRecursiveCall(" while traversing 'Compare' node")) {
9058 : 0 : goto failed;
9059 : : }
9060 : 8334 : res = obj2ast_cmpop(state, tmp2, &val, arena);
9061 : 8334 : _Py_LeaveRecursiveCall();
9062 : 8334 : Py_DECREF(tmp2);
9063 [ - + ]: 8334 : if (res != 0) goto failed;
9064 [ - + ]: 8334 : if (len != PyList_GET_SIZE(tmp)) {
9065 : 0 : PyErr_SetString(PyExc_RuntimeError, "Compare field \"ops\" changed size during iteration");
9066 : 0 : goto failed;
9067 : : }
9068 : 8334 : asdl_seq_SET(ops, i, val);
9069 : : }
9070 [ + - ]: 8198 : Py_CLEAR(tmp);
9071 : : }
9072 [ - + ]: 8198 : if (_PyObject_LookupAttr(obj, state->comparators, &tmp) < 0) {
9073 : 0 : return 1;
9074 : : }
9075 [ - + ]: 8198 : if (tmp == NULL) {
9076 : 0 : PyErr_SetString(PyExc_TypeError, "required field \"comparators\" missing from Compare");
9077 : 0 : return 1;
9078 : : }
9079 : : else {
9080 : : int res;
9081 : : Py_ssize_t len;
9082 : : Py_ssize_t i;
9083 [ - + ]: 8198 : if (!PyList_Check(tmp)) {
9084 : 0 : PyErr_Format(PyExc_TypeError, "Compare field \"comparators\" must be a list, not a %.200s", _PyType_Name(Py_TYPE(tmp)));
9085 : 0 : goto failed;
9086 : : }
9087 : 8198 : len = PyList_GET_SIZE(tmp);
9088 : 8198 : comparators = _Py_asdl_expr_seq_new(len, arena);
9089 [ - + ]: 8198 : if (comparators == NULL) goto failed;
9090 [ + + ]: 16532 : for (i = 0; i < len; i++) {
9091 : : expr_ty val;
9092 : 8334 : PyObject *tmp2 = PyList_GET_ITEM(tmp, i);
9093 : 8334 : Py_INCREF(tmp2);
9094 [ - + ]: 8334 : if (_Py_EnterRecursiveCall(" while traversing 'Compare' node")) {
9095 : 0 : goto failed;
9096 : : }
9097 : 8334 : res = obj2ast_expr(state, tmp2, &val, arena);
9098 : 8334 : _Py_LeaveRecursiveCall();
9099 : 8334 : Py_DECREF(tmp2);
9100 [ - + ]: 8334 : if (res != 0) goto failed;
9101 [ - + ]: 8334 : if (len != PyList_GET_SIZE(tmp)) {
9102 : 0 : PyErr_SetString(PyExc_RuntimeError, "Compare field \"comparators\" changed size during iteration");
9103 : 0 : goto failed;
9104 : : }
9105 : 8334 : asdl_seq_SET(comparators, i, val);
9106 : : }
9107 [ + - ]: 8198 : Py_CLEAR(tmp);
9108 : : }
9109 : 8198 : *out = _PyAST_Compare(left, ops, comparators, lineno, col_offset,
9110 : : end_lineno, end_col_offset, arena);
9111 [ - + ]: 8198 : if (*out == NULL) goto failed;
9112 : 8198 : return 0;
9113 : : }
9114 : 245599 : tp = state->Call_type;
9115 : 245599 : isinstance = PyObject_IsInstance(obj, tp);
9116 [ - + ]: 245599 : if (isinstance == -1) {
9117 : 0 : return 1;
9118 : : }
9119 [ + + ]: 245599 : if (isinstance) {
9120 : : expr_ty func;
9121 : : asdl_expr_seq* args;
9122 : : asdl_keyword_seq* keywords;
9123 : :
9124 [ - + ]: 30125 : if (_PyObject_LookupAttr(obj, state->func, &tmp) < 0) {
9125 : 30125 : return 1;
9126 : : }
9127 [ - + ]: 30125 : if (tmp == NULL) {
9128 : 0 : PyErr_SetString(PyExc_TypeError, "required field \"func\" missing from Call");
9129 : 0 : return 1;
9130 : : }
9131 : : else {
9132 : : int res;
9133 [ - + ]: 30125 : if (_Py_EnterRecursiveCall(" while traversing 'Call' node")) {
9134 : 0 : goto failed;
9135 : : }
9136 : 30125 : res = obj2ast_expr(state, tmp, &func, arena);
9137 : 30125 : _Py_LeaveRecursiveCall();
9138 [ - + ]: 30125 : if (res != 0) goto failed;
9139 [ + - ]: 30125 : Py_CLEAR(tmp);
9140 : : }
9141 [ - + ]: 30125 : if (_PyObject_LookupAttr(obj, state->args, &tmp) < 0) {
9142 : 0 : return 1;
9143 : : }
9144 [ - + ]: 30125 : if (tmp == NULL) {
9145 : 0 : PyErr_SetString(PyExc_TypeError, "required field \"args\" missing from Call");
9146 : 0 : return 1;
9147 : : }
9148 : : else {
9149 : : int res;
9150 : : Py_ssize_t len;
9151 : : Py_ssize_t i;
9152 [ - + ]: 30125 : if (!PyList_Check(tmp)) {
9153 : 0 : PyErr_Format(PyExc_TypeError, "Call field \"args\" must be a list, not a %.200s", _PyType_Name(Py_TYPE(tmp)));
9154 : 0 : goto failed;
9155 : : }
9156 : 30125 : len = PyList_GET_SIZE(tmp);
9157 : 30125 : args = _Py_asdl_expr_seq_new(len, arena);
9158 [ - + ]: 30125 : if (args == NULL) goto failed;
9159 [ + + ]: 67103 : for (i = 0; i < len; i++) {
9160 : : expr_ty val;
9161 : 36978 : PyObject *tmp2 = PyList_GET_ITEM(tmp, i);
9162 : 36978 : Py_INCREF(tmp2);
9163 [ - + ]: 36978 : if (_Py_EnterRecursiveCall(" while traversing 'Call' node")) {
9164 : 0 : goto failed;
9165 : : }
9166 : 36978 : res = obj2ast_expr(state, tmp2, &val, arena);
9167 : 36978 : _Py_LeaveRecursiveCall();
9168 : 36978 : Py_DECREF(tmp2);
9169 [ - + ]: 36978 : if (res != 0) goto failed;
9170 [ - + ]: 36978 : if (len != PyList_GET_SIZE(tmp)) {
9171 : 0 : PyErr_SetString(PyExc_RuntimeError, "Call field \"args\" changed size during iteration");
9172 : 0 : goto failed;
9173 : : }
9174 : 36978 : asdl_seq_SET(args, i, val);
9175 : : }
9176 [ + - ]: 30125 : Py_CLEAR(tmp);
9177 : : }
9178 [ - + ]: 30125 : if (_PyObject_LookupAttr(obj, state->keywords, &tmp) < 0) {
9179 : 0 : return 1;
9180 : : }
9181 [ - + ]: 30125 : if (tmp == NULL) {
9182 : 0 : PyErr_SetString(PyExc_TypeError, "required field \"keywords\" missing from Call");
9183 : 0 : return 1;
9184 : : }
9185 : : else {
9186 : : int res;
9187 : : Py_ssize_t len;
9188 : : Py_ssize_t i;
9189 [ - + ]: 30125 : if (!PyList_Check(tmp)) {
9190 : 0 : PyErr_Format(PyExc_TypeError, "Call field \"keywords\" must be a list, not a %.200s", _PyType_Name(Py_TYPE(tmp)));
9191 : 0 : goto failed;
9192 : : }
9193 : 30125 : len = PyList_GET_SIZE(tmp);
9194 : 30125 : keywords = _Py_asdl_keyword_seq_new(len, arena);
9195 [ - + ]: 30125 : if (keywords == NULL) goto failed;
9196 [ + + ]: 33385 : for (i = 0; i < len; i++) {
9197 : : keyword_ty val;
9198 : 3260 : PyObject *tmp2 = PyList_GET_ITEM(tmp, i);
9199 : 3260 : Py_INCREF(tmp2);
9200 [ - + ]: 3260 : if (_Py_EnterRecursiveCall(" while traversing 'Call' node")) {
9201 : 0 : goto failed;
9202 : : }
9203 : 3260 : res = obj2ast_keyword(state, tmp2, &val, arena);
9204 : 3260 : _Py_LeaveRecursiveCall();
9205 : 3260 : Py_DECREF(tmp2);
9206 [ - + ]: 3260 : if (res != 0) goto failed;
9207 [ - + ]: 3260 : if (len != PyList_GET_SIZE(tmp)) {
9208 : 0 : PyErr_SetString(PyExc_RuntimeError, "Call field \"keywords\" changed size during iteration");
9209 : 0 : goto failed;
9210 : : }
9211 : 3260 : asdl_seq_SET(keywords, i, val);
9212 : : }
9213 [ + - ]: 30125 : Py_CLEAR(tmp);
9214 : : }
9215 : 30125 : *out = _PyAST_Call(func, args, keywords, lineno, col_offset,
9216 : : end_lineno, end_col_offset, arena);
9217 [ - + ]: 30125 : if (*out == NULL) goto failed;
9218 : 30125 : return 0;
9219 : : }
9220 : 215474 : tp = state->FormattedValue_type;
9221 : 215474 : isinstance = PyObject_IsInstance(obj, tp);
9222 [ - + ]: 215474 : if (isinstance == -1) {
9223 : 0 : return 1;
9224 : : }
9225 [ + + ]: 215474 : if (isinstance) {
9226 : : expr_ty value;
9227 : : int conversion;
9228 : : expr_ty format_spec;
9229 : :
9230 [ - + ]: 552 : if (_PyObject_LookupAttr(obj, state->value, &tmp) < 0) {
9231 : 552 : return 1;
9232 : : }
9233 [ - + ]: 552 : if (tmp == NULL) {
9234 : 0 : PyErr_SetString(PyExc_TypeError, "required field \"value\" missing from FormattedValue");
9235 : 0 : return 1;
9236 : : }
9237 : : else {
9238 : : int res;
9239 [ - + ]: 552 : if (_Py_EnterRecursiveCall(" while traversing 'FormattedValue' node")) {
9240 : 0 : goto failed;
9241 : : }
9242 : 552 : res = obj2ast_expr(state, tmp, &value, arena);
9243 : 552 : _Py_LeaveRecursiveCall();
9244 [ - + ]: 552 : if (res != 0) goto failed;
9245 [ + - ]: 552 : Py_CLEAR(tmp);
9246 : : }
9247 [ - + ]: 552 : if (_PyObject_LookupAttr(obj, state->conversion, &tmp) < 0) {
9248 : 0 : return 1;
9249 : : }
9250 [ - + ]: 552 : if (tmp == NULL) {
9251 : 0 : PyErr_SetString(PyExc_TypeError, "required field \"conversion\" missing from FormattedValue");
9252 : 0 : return 1;
9253 : : }
9254 : : else {
9255 : : int res;
9256 [ - + ]: 552 : if (_Py_EnterRecursiveCall(" while traversing 'FormattedValue' node")) {
9257 : 0 : goto failed;
9258 : : }
9259 : 552 : res = obj2ast_int(state, tmp, &conversion, arena);
9260 : 552 : _Py_LeaveRecursiveCall();
9261 [ - + ]: 552 : if (res != 0) goto failed;
9262 [ + - ]: 552 : Py_CLEAR(tmp);
9263 : : }
9264 [ - + ]: 552 : if (_PyObject_LookupAttr(obj, state->format_spec, &tmp) < 0) {
9265 : 0 : return 1;
9266 : : }
9267 [ + - + + ]: 552 : if (tmp == NULL || tmp == Py_None) {
9268 [ + - ]: 533 : Py_CLEAR(tmp);
9269 : 533 : format_spec = NULL;
9270 : : }
9271 : : else {
9272 : : int res;
9273 [ - + ]: 19 : if (_Py_EnterRecursiveCall(" while traversing 'FormattedValue' node")) {
9274 : 0 : goto failed;
9275 : : }
9276 : 19 : res = obj2ast_expr(state, tmp, &format_spec, arena);
9277 : 19 : _Py_LeaveRecursiveCall();
9278 [ - + ]: 19 : if (res != 0) goto failed;
9279 [ + - ]: 19 : Py_CLEAR(tmp);
9280 : : }
9281 : 552 : *out = _PyAST_FormattedValue(value, conversion, format_spec, lineno,
9282 : : col_offset, end_lineno, end_col_offset,
9283 : : arena);
9284 [ - + ]: 552 : if (*out == NULL) goto failed;
9285 : 552 : return 0;
9286 : : }
9287 : 214922 : tp = state->JoinedStr_type;
9288 : 214922 : isinstance = PyObject_IsInstance(obj, tp);
9289 [ - + ]: 214922 : if (isinstance == -1) {
9290 : 0 : return 1;
9291 : : }
9292 [ + + ]: 214922 : if (isinstance) {
9293 : : asdl_expr_seq* values;
9294 : :
9295 [ - + ]: 389 : if (_PyObject_LookupAttr(obj, state->values, &tmp) < 0) {
9296 : 0 : return 1;
9297 : : }
9298 [ - + ]: 389 : if (tmp == NULL) {
9299 : 0 : PyErr_SetString(PyExc_TypeError, "required field \"values\" missing from JoinedStr");
9300 : 0 : return 1;
9301 : : }
9302 : : else {
9303 : : int res;
9304 : : Py_ssize_t len;
9305 : : Py_ssize_t i;
9306 [ - + ]: 389 : if (!PyList_Check(tmp)) {
9307 : 0 : PyErr_Format(PyExc_TypeError, "JoinedStr field \"values\" must be a list, not a %.200s", _PyType_Name(Py_TYPE(tmp)));
9308 : 0 : goto failed;
9309 : : }
9310 : 389 : len = PyList_GET_SIZE(tmp);
9311 : 389 : values = _Py_asdl_expr_seq_new(len, arena);
9312 [ - + ]: 389 : if (values == NULL) goto failed;
9313 [ + + ]: 1574 : for (i = 0; i < len; i++) {
9314 : : expr_ty val;
9315 : 1185 : PyObject *tmp2 = PyList_GET_ITEM(tmp, i);
9316 : 1185 : Py_INCREF(tmp2);
9317 [ - + ]: 1185 : if (_Py_EnterRecursiveCall(" while traversing 'JoinedStr' node")) {
9318 : 0 : goto failed;
9319 : : }
9320 : 1185 : res = obj2ast_expr(state, tmp2, &val, arena);
9321 : 1185 : _Py_LeaveRecursiveCall();
9322 : 1185 : Py_DECREF(tmp2);
9323 [ - + ]: 1185 : if (res != 0) goto failed;
9324 [ - + ]: 1185 : if (len != PyList_GET_SIZE(tmp)) {
9325 : 0 : PyErr_SetString(PyExc_RuntimeError, "JoinedStr field \"values\" changed size during iteration");
9326 : 0 : goto failed;
9327 : : }
9328 : 1185 : asdl_seq_SET(values, i, val);
9329 : : }
9330 [ + - ]: 389 : Py_CLEAR(tmp);
9331 : : }
9332 : 389 : *out = _PyAST_JoinedStr(values, lineno, col_offset, end_lineno,
9333 : : end_col_offset, arena);
9334 [ - + ]: 389 : if (*out == NULL) goto failed;
9335 : 389 : return 0;
9336 : : }
9337 : 214533 : tp = state->Constant_type;
9338 : 214533 : isinstance = PyObject_IsInstance(obj, tp);
9339 [ - + ]: 214533 : if (isinstance == -1) {
9340 : 0 : return 1;
9341 : : }
9342 [ + + ]: 214533 : if (isinstance) {
9343 : : constant value;
9344 : : string kind;
9345 : :
9346 [ - + ]: 46691 : if (_PyObject_LookupAttr(obj, state->value, &tmp) < 0) {
9347 : 46691 : return 1;
9348 : : }
9349 [ - + ]: 46691 : if (tmp == NULL) {
9350 : 0 : PyErr_SetString(PyExc_TypeError, "required field \"value\" missing from Constant");
9351 : 0 : return 1;
9352 : : }
9353 : : else {
9354 : : int res;
9355 [ - + ]: 46691 : if (_Py_EnterRecursiveCall(" while traversing 'Constant' node")) {
9356 : 0 : goto failed;
9357 : : }
9358 : 46691 : res = obj2ast_constant(state, tmp, &value, arena);
9359 : 46691 : _Py_LeaveRecursiveCall();
9360 [ - + ]: 46691 : if (res != 0) goto failed;
9361 [ + - ]: 46691 : Py_CLEAR(tmp);
9362 : : }
9363 [ - + ]: 46691 : if (_PyObject_LookupAttr(obj, state->kind, &tmp) < 0) {
9364 : 0 : return 1;
9365 : : }
9366 [ + - + - ]: 46691 : if (tmp == NULL || tmp == Py_None) {
9367 [ + - ]: 46691 : Py_CLEAR(tmp);
9368 : 46691 : kind = NULL;
9369 : : }
9370 : : else {
9371 : : int res;
9372 [ # # ]: 0 : if (_Py_EnterRecursiveCall(" while traversing 'Constant' node")) {
9373 : 0 : goto failed;
9374 : : }
9375 : 0 : res = obj2ast_string(state, tmp, &kind, arena);
9376 : 0 : _Py_LeaveRecursiveCall();
9377 [ # # ]: 0 : if (res != 0) goto failed;
9378 [ # # ]: 0 : Py_CLEAR(tmp);
9379 : : }
9380 : 46691 : *out = _PyAST_Constant(value, kind, lineno, col_offset, end_lineno,
9381 : : end_col_offset, arena);
9382 [ - + ]: 46691 : if (*out == NULL) goto failed;
9383 : 46691 : return 0;
9384 : : }
9385 : 167842 : tp = state->Attribute_type;
9386 : 167842 : isinstance = PyObject_IsInstance(obj, tp);
9387 [ - + ]: 167842 : if (isinstance == -1) {
9388 : 0 : return 1;
9389 : : }
9390 [ + + ]: 167842 : if (isinstance) {
9391 : : expr_ty value;
9392 : : identifier attr;
9393 : : expr_context_ty ctx;
9394 : :
9395 [ - + ]: 35088 : if (_PyObject_LookupAttr(obj, state->value, &tmp) < 0) {
9396 : 35088 : return 1;
9397 : : }
9398 [ - + ]: 35088 : if (tmp == NULL) {
9399 : 0 : PyErr_SetString(PyExc_TypeError, "required field \"value\" missing from Attribute");
9400 : 0 : return 1;
9401 : : }
9402 : : else {
9403 : : int res;
9404 [ - + ]: 35088 : if (_Py_EnterRecursiveCall(" while traversing 'Attribute' node")) {
9405 : 0 : goto failed;
9406 : : }
9407 : 35088 : res = obj2ast_expr(state, tmp, &value, arena);
9408 : 35088 : _Py_LeaveRecursiveCall();
9409 [ - + ]: 35088 : if (res != 0) goto failed;
9410 [ + - ]: 35088 : Py_CLEAR(tmp);
9411 : : }
9412 [ - + ]: 35088 : if (_PyObject_LookupAttr(obj, state->attr, &tmp) < 0) {
9413 : 0 : return 1;
9414 : : }
9415 [ - + ]: 35088 : if (tmp == NULL) {
9416 : 0 : PyErr_SetString(PyExc_TypeError, "required field \"attr\" missing from Attribute");
9417 : 0 : return 1;
9418 : : }
9419 : : else {
9420 : : int res;
9421 [ - + ]: 35088 : if (_Py_EnterRecursiveCall(" while traversing 'Attribute' node")) {
9422 : 0 : goto failed;
9423 : : }
9424 : 35088 : res = obj2ast_identifier(state, tmp, &attr, arena);
9425 : 35088 : _Py_LeaveRecursiveCall();
9426 [ - + ]: 35088 : if (res != 0) goto failed;
9427 [ + - ]: 35088 : Py_CLEAR(tmp);
9428 : : }
9429 [ - + ]: 35088 : if (_PyObject_LookupAttr(obj, state->ctx, &tmp) < 0) {
9430 : 0 : return 1;
9431 : : }
9432 [ - + ]: 35088 : if (tmp == NULL) {
9433 : 0 : PyErr_SetString(PyExc_TypeError, "required field \"ctx\" missing from Attribute");
9434 : 0 : return 1;
9435 : : }
9436 : : else {
9437 : : int res;
9438 [ - + ]: 35088 : if (_Py_EnterRecursiveCall(" while traversing 'Attribute' node")) {
9439 : 0 : goto failed;
9440 : : }
9441 : 35088 : res = obj2ast_expr_context(state, tmp, &ctx, arena);
9442 : 35088 : _Py_LeaveRecursiveCall();
9443 [ - + ]: 35088 : if (res != 0) goto failed;
9444 [ + - ]: 35088 : Py_CLEAR(tmp);
9445 : : }
9446 : 35088 : *out = _PyAST_Attribute(value, attr, ctx, lineno, col_offset,
9447 : : end_lineno, end_col_offset, arena);
9448 [ - + ]: 35088 : if (*out == NULL) goto failed;
9449 : 35088 : return 0;
9450 : : }
9451 : 132754 : tp = state->Subscript_type;
9452 : 132754 : isinstance = PyObject_IsInstance(obj, tp);
9453 [ - + ]: 132754 : if (isinstance == -1) {
9454 : 0 : return 1;
9455 : : }
9456 [ + + ]: 132754 : if (isinstance) {
9457 : : expr_ty value;
9458 : : expr_ty slice;
9459 : : expr_context_ty ctx;
9460 : :
9461 [ - + ]: 4948 : if (_PyObject_LookupAttr(obj, state->value, &tmp) < 0) {
9462 : 4948 : return 1;
9463 : : }
9464 [ - + ]: 4948 : if (tmp == NULL) {
9465 : 0 : PyErr_SetString(PyExc_TypeError, "required field \"value\" missing from Subscript");
9466 : 0 : return 1;
9467 : : }
9468 : : else {
9469 : : int res;
9470 [ - + ]: 4948 : if (_Py_EnterRecursiveCall(" while traversing 'Subscript' node")) {
9471 : 0 : goto failed;
9472 : : }
9473 : 4948 : res = obj2ast_expr(state, tmp, &value, arena);
9474 : 4948 : _Py_LeaveRecursiveCall();
9475 [ - + ]: 4948 : if (res != 0) goto failed;
9476 [ + - ]: 4948 : Py_CLEAR(tmp);
9477 : : }
9478 [ - + ]: 4948 : if (_PyObject_LookupAttr(obj, state->slice, &tmp) < 0) {
9479 : 0 : return 1;
9480 : : }
9481 [ - + ]: 4948 : if (tmp == NULL) {
9482 : 0 : PyErr_SetString(PyExc_TypeError, "required field \"slice\" missing from Subscript");
9483 : 0 : return 1;
9484 : : }
9485 : : else {
9486 : : int res;
9487 [ - + ]: 4948 : if (_Py_EnterRecursiveCall(" while traversing 'Subscript' node")) {
9488 : 0 : goto failed;
9489 : : }
9490 : 4948 : res = obj2ast_expr(state, tmp, &slice, arena);
9491 : 4948 : _Py_LeaveRecursiveCall();
9492 [ - + ]: 4948 : if (res != 0) goto failed;
9493 [ + - ]: 4948 : Py_CLEAR(tmp);
9494 : : }
9495 [ - + ]: 4948 : if (_PyObject_LookupAttr(obj, state->ctx, &tmp) < 0) {
9496 : 0 : return 1;
9497 : : }
9498 [ - + ]: 4948 : if (tmp == NULL) {
9499 : 0 : PyErr_SetString(PyExc_TypeError, "required field \"ctx\" missing from Subscript");
9500 : 0 : return 1;
9501 : : }
9502 : : else {
9503 : : int res;
9504 [ - + ]: 4948 : if (_Py_EnterRecursiveCall(" while traversing 'Subscript' node")) {
9505 : 0 : goto failed;
9506 : : }
9507 : 4948 : res = obj2ast_expr_context(state, tmp, &ctx, arena);
9508 : 4948 : _Py_LeaveRecursiveCall();
9509 [ - + ]: 4948 : if (res != 0) goto failed;
9510 [ + - ]: 4948 : Py_CLEAR(tmp);
9511 : : }
9512 : 4948 : *out = _PyAST_Subscript(value, slice, ctx, lineno, col_offset,
9513 : : end_lineno, end_col_offset, arena);
9514 [ - + ]: 4948 : if (*out == NULL) goto failed;
9515 : 4948 : return 0;
9516 : : }
9517 : 127806 : tp = state->Starred_type;
9518 : 127806 : isinstance = PyObject_IsInstance(obj, tp);
9519 [ - + ]: 127806 : if (isinstance == -1) {
9520 : 0 : return 1;
9521 : : }
9522 [ + + ]: 127806 : if (isinstance) {
9523 : : expr_ty value;
9524 : : expr_context_ty ctx;
9525 : :
9526 [ - + ]: 316 : if (_PyObject_LookupAttr(obj, state->value, &tmp) < 0) {
9527 : 316 : return 1;
9528 : : }
9529 [ - + ]: 316 : if (tmp == NULL) {
9530 : 0 : PyErr_SetString(PyExc_TypeError, "required field \"value\" missing from Starred");
9531 : 0 : return 1;
9532 : : }
9533 : : else {
9534 : : int res;
9535 [ - + ]: 316 : if (_Py_EnterRecursiveCall(" while traversing 'Starred' node")) {
9536 : 0 : goto failed;
9537 : : }
9538 : 316 : res = obj2ast_expr(state, tmp, &value, arena);
9539 : 316 : _Py_LeaveRecursiveCall();
9540 [ - + ]: 316 : if (res != 0) goto failed;
9541 [ + - ]: 316 : Py_CLEAR(tmp);
9542 : : }
9543 [ - + ]: 316 : if (_PyObject_LookupAttr(obj, state->ctx, &tmp) < 0) {
9544 : 0 : return 1;
9545 : : }
9546 [ - + ]: 316 : if (tmp == NULL) {
9547 : 0 : PyErr_SetString(PyExc_TypeError, "required field \"ctx\" missing from Starred");
9548 : 0 : return 1;
9549 : : }
9550 : : else {
9551 : : int res;
9552 [ - + ]: 316 : if (_Py_EnterRecursiveCall(" while traversing 'Starred' node")) {
9553 : 0 : goto failed;
9554 : : }
9555 : 316 : res = obj2ast_expr_context(state, tmp, &ctx, arena);
9556 : 316 : _Py_LeaveRecursiveCall();
9557 [ - + ]: 316 : if (res != 0) goto failed;
9558 [ + - ]: 316 : Py_CLEAR(tmp);
9559 : : }
9560 : 316 : *out = _PyAST_Starred(value, ctx, lineno, col_offset, end_lineno,
9561 : : end_col_offset, arena);
9562 [ - + ]: 316 : if (*out == NULL) goto failed;
9563 : 316 : return 0;
9564 : : }
9565 : 127490 : tp = state->Name_type;
9566 : 127490 : isinstance = PyObject_IsInstance(obj, tp);
9567 [ - + ]: 127490 : if (isinstance == -1) {
9568 : 0 : return 1;
9569 : : }
9570 [ + + ]: 127490 : if (isinstance) {
9571 : : identifier id;
9572 : : expr_context_ty ctx;
9573 : :
9574 [ - + ]: 119463 : if (_PyObject_LookupAttr(obj, state->id, &tmp) < 0) {
9575 : 119462 : return 1;
9576 : : }
9577 [ - + ]: 119463 : if (tmp == NULL) {
9578 : 0 : PyErr_SetString(PyExc_TypeError, "required field \"id\" missing from Name");
9579 : 0 : return 1;
9580 : : }
9581 : : else {
9582 : : int res;
9583 [ - + ]: 119463 : if (_Py_EnterRecursiveCall(" while traversing 'Name' node")) {
9584 : 1 : goto failed;
9585 : : }
9586 : 119463 : res = obj2ast_identifier(state, tmp, &id, arena);
9587 : 119463 : _Py_LeaveRecursiveCall();
9588 [ + + ]: 119463 : if (res != 0) goto failed;
9589 [ + - ]: 119462 : Py_CLEAR(tmp);
9590 : : }
9591 [ - + ]: 119462 : if (_PyObject_LookupAttr(obj, state->ctx, &tmp) < 0) {
9592 : 0 : return 1;
9593 : : }
9594 [ - + ]: 119462 : if (tmp == NULL) {
9595 : 0 : PyErr_SetString(PyExc_TypeError, "required field \"ctx\" missing from Name");
9596 : 0 : return 1;
9597 : : }
9598 : : else {
9599 : : int res;
9600 [ - + ]: 119462 : if (_Py_EnterRecursiveCall(" while traversing 'Name' node")) {
9601 : 0 : goto failed;
9602 : : }
9603 : 119462 : res = obj2ast_expr_context(state, tmp, &ctx, arena);
9604 : 119462 : _Py_LeaveRecursiveCall();
9605 [ - + ]: 119462 : if (res != 0) goto failed;
9606 [ + - ]: 119462 : Py_CLEAR(tmp);
9607 : : }
9608 : 119462 : *out = _PyAST_Name(id, ctx, lineno, col_offset, end_lineno,
9609 : : end_col_offset, arena);
9610 [ - + ]: 119462 : if (*out == NULL) goto failed;
9611 : 119462 : return 0;
9612 : : }
9613 : 8027 : tp = state->List_type;
9614 : 8027 : isinstance = PyObject_IsInstance(obj, tp);
9615 [ - + ]: 8027 : if (isinstance == -1) {
9616 : 0 : return 1;
9617 : : }
9618 [ + + ]: 8027 : if (isinstance) {
9619 : : asdl_expr_seq* elts;
9620 : : expr_context_ty ctx;
9621 : :
9622 [ - + ]: 1489 : if (_PyObject_LookupAttr(obj, state->elts, &tmp) < 0) {
9623 : 1489 : return 1;
9624 : : }
9625 [ - + ]: 1489 : if (tmp == NULL) {
9626 : 0 : PyErr_SetString(PyExc_TypeError, "required field \"elts\" missing from List");
9627 : 0 : return 1;
9628 : : }
9629 : : else {
9630 : : int res;
9631 : : Py_ssize_t len;
9632 : : Py_ssize_t i;
9633 [ - + ]: 1489 : if (!PyList_Check(tmp)) {
9634 : 0 : PyErr_Format(PyExc_TypeError, "List field \"elts\" must be a list, not a %.200s", _PyType_Name(Py_TYPE(tmp)));
9635 : 0 : goto failed;
9636 : : }
9637 : 1489 : len = PyList_GET_SIZE(tmp);
9638 : 1489 : elts = _Py_asdl_expr_seq_new(len, arena);
9639 [ - + ]: 1489 : if (elts == NULL) goto failed;
9640 [ + + ]: 4944 : for (i = 0; i < len; i++) {
9641 : : expr_ty val;
9642 : 3455 : PyObject *tmp2 = PyList_GET_ITEM(tmp, i);
9643 : 3455 : Py_INCREF(tmp2);
9644 [ - + ]: 3455 : if (_Py_EnterRecursiveCall(" while traversing 'List' node")) {
9645 : 0 : goto failed;
9646 : : }
9647 : 3455 : res = obj2ast_expr(state, tmp2, &val, arena);
9648 : 3455 : _Py_LeaveRecursiveCall();
9649 : 3455 : Py_DECREF(tmp2);
9650 [ - + ]: 3455 : if (res != 0) goto failed;
9651 [ - + ]: 3455 : if (len != PyList_GET_SIZE(tmp)) {
9652 : 0 : PyErr_SetString(PyExc_RuntimeError, "List field \"elts\" changed size during iteration");
9653 : 0 : goto failed;
9654 : : }
9655 : 3455 : asdl_seq_SET(elts, i, val);
9656 : : }
9657 [ + - ]: 1489 : Py_CLEAR(tmp);
9658 : : }
9659 [ - + ]: 1489 : if (_PyObject_LookupAttr(obj, state->ctx, &tmp) < 0) {
9660 : 0 : return 1;
9661 : : }
9662 [ - + ]: 1489 : if (tmp == NULL) {
9663 : 0 : PyErr_SetString(PyExc_TypeError, "required field \"ctx\" missing from List");
9664 : 0 : return 1;
9665 : : }
9666 : : else {
9667 : : int res;
9668 [ - + ]: 1489 : if (_Py_EnterRecursiveCall(" while traversing 'List' node")) {
9669 : 0 : goto failed;
9670 : : }
9671 : 1489 : res = obj2ast_expr_context(state, tmp, &ctx, arena);
9672 : 1489 : _Py_LeaveRecursiveCall();
9673 [ - + ]: 1489 : if (res != 0) goto failed;
9674 [ + - ]: 1489 : Py_CLEAR(tmp);
9675 : : }
9676 : 1489 : *out = _PyAST_List(elts, ctx, lineno, col_offset, end_lineno,
9677 : : end_col_offset, arena);
9678 [ - + ]: 1489 : if (*out == NULL) goto failed;
9679 : 1489 : return 0;
9680 : : }
9681 : 6538 : tp = state->Tuple_type;
9682 : 6538 : isinstance = PyObject_IsInstance(obj, tp);
9683 [ - + ]: 6538 : if (isinstance == -1) {
9684 : 0 : return 1;
9685 : : }
9686 [ + + ]: 6538 : if (isinstance) {
9687 : : asdl_expr_seq* elts;
9688 : : expr_context_ty ctx;
9689 : :
9690 [ - + ]: 5243 : if (_PyObject_LookupAttr(obj, state->elts, &tmp) < 0) {
9691 : 5243 : return 1;
9692 : : }
9693 [ - + ]: 5243 : if (tmp == NULL) {
9694 : 0 : PyErr_SetString(PyExc_TypeError, "required field \"elts\" missing from Tuple");
9695 : 0 : return 1;
9696 : : }
9697 : : else {
9698 : : int res;
9699 : : Py_ssize_t len;
9700 : : Py_ssize_t i;
9701 [ - + ]: 5243 : if (!PyList_Check(tmp)) {
9702 : 0 : PyErr_Format(PyExc_TypeError, "Tuple field \"elts\" must be a list, not a %.200s", _PyType_Name(Py_TYPE(tmp)));
9703 : 0 : goto failed;
9704 : : }
9705 : 5243 : len = PyList_GET_SIZE(tmp);
9706 : 5243 : elts = _Py_asdl_expr_seq_new(len, arena);
9707 [ - + ]: 5243 : if (elts == NULL) goto failed;
9708 [ + + ]: 17586 : for (i = 0; i < len; i++) {
9709 : : expr_ty val;
9710 : 12343 : PyObject *tmp2 = PyList_GET_ITEM(tmp, i);
9711 : 12343 : Py_INCREF(tmp2);
9712 [ - + ]: 12343 : if (_Py_EnterRecursiveCall(" while traversing 'Tuple' node")) {
9713 : 0 : goto failed;
9714 : : }
9715 : 12343 : res = obj2ast_expr(state, tmp2, &val, arena);
9716 : 12343 : _Py_LeaveRecursiveCall();
9717 : 12343 : Py_DECREF(tmp2);
9718 [ - + ]: 12343 : if (res != 0) goto failed;
9719 [ - + ]: 12343 : if (len != PyList_GET_SIZE(tmp)) {
9720 : 0 : PyErr_SetString(PyExc_RuntimeError, "Tuple field \"elts\" changed size during iteration");
9721 : 0 : goto failed;
9722 : : }
9723 : 12343 : asdl_seq_SET(elts, i, val);
9724 : : }
9725 [ + - ]: 5243 : Py_CLEAR(tmp);
9726 : : }
9727 [ - + ]: 5243 : if (_PyObject_LookupAttr(obj, state->ctx, &tmp) < 0) {
9728 : 0 : return 1;
9729 : : }
9730 [ - + ]: 5243 : if (tmp == NULL) {
9731 : 0 : PyErr_SetString(PyExc_TypeError, "required field \"ctx\" missing from Tuple");
9732 : 0 : return 1;
9733 : : }
9734 : : else {
9735 : : int res;
9736 [ - + ]: 5243 : if (_Py_EnterRecursiveCall(" while traversing 'Tuple' node")) {
9737 : 0 : goto failed;
9738 : : }
9739 : 5243 : res = obj2ast_expr_context(state, tmp, &ctx, arena);
9740 : 5243 : _Py_LeaveRecursiveCall();
9741 [ - + ]: 5243 : if (res != 0) goto failed;
9742 [ + - ]: 5243 : Py_CLEAR(tmp);
9743 : : }
9744 : 5243 : *out = _PyAST_Tuple(elts, ctx, lineno, col_offset, end_lineno,
9745 : : end_col_offset, arena);
9746 [ - + ]: 5243 : if (*out == NULL) goto failed;
9747 : 5243 : return 0;
9748 : : }
9749 : 1295 : tp = state->Slice_type;
9750 : 1295 : isinstance = PyObject_IsInstance(obj, tp);
9751 [ - + ]: 1295 : if (isinstance == -1) {
9752 : 0 : return 1;
9753 : : }
9754 [ + + ]: 1295 : if (isinstance) {
9755 : : expr_ty lower;
9756 : : expr_ty upper;
9757 : : expr_ty step;
9758 : :
9759 [ - + ]: 1294 : if (_PyObject_LookupAttr(obj, state->lower, &tmp) < 0) {
9760 : 1294 : return 1;
9761 : : }
9762 [ + - + + ]: 1294 : if (tmp == NULL || tmp == Py_None) {
9763 [ + - ]: 520 : Py_CLEAR(tmp);
9764 : 520 : lower = NULL;
9765 : : }
9766 : : else {
9767 : : int res;
9768 [ - + ]: 774 : if (_Py_EnterRecursiveCall(" while traversing 'Slice' node")) {
9769 : 0 : goto failed;
9770 : : }
9771 : 774 : res = obj2ast_expr(state, tmp, &lower, arena);
9772 : 774 : _Py_LeaveRecursiveCall();
9773 [ - + ]: 774 : if (res != 0) goto failed;
9774 [ + - ]: 774 : Py_CLEAR(tmp);
9775 : : }
9776 [ - + ]: 1294 : if (_PyObject_LookupAttr(obj, state->upper, &tmp) < 0) {
9777 : 0 : return 1;
9778 : : }
9779 [ + - + + ]: 1294 : if (tmp == NULL || tmp == Py_None) {
9780 [ + - ]: 498 : Py_CLEAR(tmp);
9781 : 498 : upper = NULL;
9782 : : }
9783 : : else {
9784 : : int res;
9785 [ - + ]: 796 : if (_Py_EnterRecursiveCall(" while traversing 'Slice' node")) {
9786 : 0 : goto failed;
9787 : : }
9788 : 796 : res = obj2ast_expr(state, tmp, &upper, arena);
9789 : 796 : _Py_LeaveRecursiveCall();
9790 [ - + ]: 796 : if (res != 0) goto failed;
9791 [ + - ]: 796 : Py_CLEAR(tmp);
9792 : : }
9793 [ - + ]: 1294 : if (_PyObject_LookupAttr(obj, state->step, &tmp) < 0) {
9794 : 0 : return 1;
9795 : : }
9796 [ + - + + ]: 1294 : if (tmp == NULL || tmp == Py_None) {
9797 [ + - ]: 1263 : Py_CLEAR(tmp);
9798 : 1263 : step = NULL;
9799 : : }
9800 : : else {
9801 : : int res;
9802 [ - + ]: 31 : if (_Py_EnterRecursiveCall(" while traversing 'Slice' node")) {
9803 : 0 : goto failed;
9804 : : }
9805 : 31 : res = obj2ast_expr(state, tmp, &step, arena);
9806 : 31 : _Py_LeaveRecursiveCall();
9807 [ - + ]: 31 : if (res != 0) goto failed;
9808 [ + - ]: 31 : Py_CLEAR(tmp);
9809 : : }
9810 : 1294 : *out = _PyAST_Slice(lower, upper, step, lineno, col_offset, end_lineno,
9811 : : end_col_offset, arena);
9812 [ - + ]: 1294 : if (*out == NULL) goto failed;
9813 : 1294 : return 0;
9814 : : }
9815 : :
9816 : 1 : PyErr_Format(PyExc_TypeError, "expected some sort of expr, but got %R", obj);
9817 : 89 : failed:
9818 : 89 : Py_XDECREF(tmp);
9819 : 89 : return 1;
9820 : : }
9821 : :
9822 : : int
9823 : 166546 : obj2ast_expr_context(struct ast_state *state, PyObject* obj, expr_context_ty*
9824 : : out, PyArena* arena)
9825 : : {
9826 : : int isinstance;
9827 : :
9828 : 166546 : isinstance = PyObject_IsInstance(obj, state->Load_type);
9829 [ - + ]: 166546 : if (isinstance == -1) {
9830 : 0 : return 1;
9831 : : }
9832 [ + + ]: 166546 : if (isinstance) {
9833 : 138190 : *out = Load;
9834 : 138190 : return 0;
9835 : : }
9836 : 28356 : isinstance = PyObject_IsInstance(obj, state->Store_type);
9837 [ - + ]: 28356 : if (isinstance == -1) {
9838 : 0 : return 1;
9839 : : }
9840 [ + + ]: 28356 : if (isinstance) {
9841 : 28036 : *out = Store;
9842 : 28036 : return 0;
9843 : : }
9844 : 320 : isinstance = PyObject_IsInstance(obj, state->Del_type);
9845 [ - + ]: 320 : if (isinstance == -1) {
9846 : 0 : return 1;
9847 : : }
9848 [ + - ]: 320 : if (isinstance) {
9849 : 320 : *out = Del;
9850 : 320 : return 0;
9851 : : }
9852 : :
9853 : 0 : PyErr_Format(PyExc_TypeError, "expected some sort of expr_context, but got %R", obj);
9854 : 0 : return 1;
9855 : : }
9856 : :
9857 : : int
9858 : 2070 : obj2ast_boolop(struct ast_state *state, PyObject* obj, boolop_ty* out, PyArena*
9859 : : arena)
9860 : : {
9861 : : int isinstance;
9862 : :
9863 : 2070 : isinstance = PyObject_IsInstance(obj, state->And_type);
9864 [ - + ]: 2070 : if (isinstance == -1) {
9865 : 0 : return 1;
9866 : : }
9867 [ + + ]: 2070 : if (isinstance) {
9868 : 1273 : *out = And;
9869 : 1273 : return 0;
9870 : : }
9871 : 797 : isinstance = PyObject_IsInstance(obj, state->Or_type);
9872 [ - + ]: 797 : if (isinstance == -1) {
9873 : 0 : return 1;
9874 : : }
9875 [ + - ]: 797 : if (isinstance) {
9876 : 797 : *out = Or;
9877 : 797 : return 0;
9878 : : }
9879 : :
9880 : 0 : PyErr_Format(PyExc_TypeError, "expected some sort of boolop, but got %R", obj);
9881 : 0 : return 1;
9882 : : }
9883 : :
9884 : : int
9885 : 7542 : obj2ast_operator(struct ast_state *state, PyObject* obj, operator_ty* out,
9886 : : PyArena* arena)
9887 : : {
9888 : : int isinstance;
9889 : :
9890 : 7542 : isinstance = PyObject_IsInstance(obj, state->Add_type);
9891 [ - + ]: 7542 : if (isinstance == -1) {
9892 : 0 : return 1;
9893 : : }
9894 [ + + ]: 7542 : if (isinstance) {
9895 : 3109 : *out = Add;
9896 : 3109 : return 0;
9897 : : }
9898 : 4433 : isinstance = PyObject_IsInstance(obj, state->Sub_type);
9899 [ - + ]: 4433 : if (isinstance == -1) {
9900 : 0 : return 1;
9901 : : }
9902 [ + + ]: 4433 : if (isinstance) {
9903 : 981 : *out = Sub;
9904 : 981 : return 0;
9905 : : }
9906 : 3452 : isinstance = PyObject_IsInstance(obj, state->Mult_type);
9907 [ - + ]: 3452 : if (isinstance == -1) {
9908 : 0 : return 1;
9909 : : }
9910 [ + + ]: 3452 : if (isinstance) {
9911 : 812 : *out = Mult;
9912 : 812 : return 0;
9913 : : }
9914 : 2640 : isinstance = PyObject_IsInstance(obj, state->MatMult_type);
9915 [ - + ]: 2640 : if (isinstance == -1) {
9916 : 0 : return 1;
9917 : : }
9918 [ + + ]: 2640 : if (isinstance) {
9919 : 4 : *out = MatMult;
9920 : 4 : return 0;
9921 : : }
9922 : 2636 : isinstance = PyObject_IsInstance(obj, state->Div_type);
9923 [ - + ]: 2636 : if (isinstance == -1) {
9924 : 0 : return 1;
9925 : : }
9926 [ + + ]: 2636 : if (isinstance) {
9927 : 181 : *out = Div;
9928 : 181 : return 0;
9929 : : }
9930 : 2455 : isinstance = PyObject_IsInstance(obj, state->Mod_type);
9931 [ - + ]: 2455 : if (isinstance == -1) {
9932 : 0 : return 1;
9933 : : }
9934 [ + + ]: 2455 : if (isinstance) {
9935 : 1453 : *out = Mod;
9936 : 1453 : return 0;
9937 : : }
9938 : 1002 : isinstance = PyObject_IsInstance(obj, state->Pow_type);
9939 [ - + ]: 1002 : if (isinstance == -1) {
9940 : 0 : return 1;
9941 : : }
9942 [ + + ]: 1002 : if (isinstance) {
9943 : 133 : *out = Pow;
9944 : 133 : return 0;
9945 : : }
9946 : 869 : isinstance = PyObject_IsInstance(obj, state->LShift_type);
9947 [ - + ]: 869 : if (isinstance == -1) {
9948 : 0 : return 1;
9949 : : }
9950 [ + + ]: 869 : if (isinstance) {
9951 : 143 : *out = LShift;
9952 : 143 : return 0;
9953 : : }
9954 : 726 : isinstance = PyObject_IsInstance(obj, state->RShift_type);
9955 [ - + ]: 726 : if (isinstance == -1) {
9956 : 0 : return 1;
9957 : : }
9958 [ + + ]: 726 : if (isinstance) {
9959 : 66 : *out = RShift;
9960 : 66 : return 0;
9961 : : }
9962 : 660 : isinstance = PyObject_IsInstance(obj, state->BitOr_type);
9963 [ - + ]: 660 : if (isinstance == -1) {
9964 : 0 : return 1;
9965 : : }
9966 [ + + ]: 660 : if (isinstance) {
9967 : 201 : *out = BitOr;
9968 : 201 : return 0;
9969 : : }
9970 : 459 : isinstance = PyObject_IsInstance(obj, state->BitXor_type);
9971 [ - + ]: 459 : if (isinstance == -1) {
9972 : 0 : return 1;
9973 : : }
9974 [ + + ]: 459 : if (isinstance) {
9975 : 41 : *out = BitXor;
9976 : 41 : return 0;
9977 : : }
9978 : 418 : isinstance = PyObject_IsInstance(obj, state->BitAnd_type);
9979 [ - + ]: 418 : if (isinstance == -1) {
9980 : 0 : return 1;
9981 : : }
9982 [ + + ]: 418 : if (isinstance) {
9983 : 253 : *out = BitAnd;
9984 : 253 : return 0;
9985 : : }
9986 : 165 : isinstance = PyObject_IsInstance(obj, state->FloorDiv_type);
9987 [ - + ]: 165 : if (isinstance == -1) {
9988 : 0 : return 1;
9989 : : }
9990 [ + - ]: 165 : if (isinstance) {
9991 : 165 : *out = FloorDiv;
9992 : 165 : return 0;
9993 : : }
9994 : :
9995 : 0 : PyErr_Format(PyExc_TypeError, "expected some sort of operator, but got %R", obj);
9996 : 0 : return 1;
9997 : : }
9998 : :
9999 : : int
10000 : 3083 : obj2ast_unaryop(struct ast_state *state, PyObject* obj, unaryop_ty* out,
10001 : : PyArena* arena)
10002 : : {
10003 : : int isinstance;
10004 : :
10005 : 3083 : isinstance = PyObject_IsInstance(obj, state->Invert_type);
10006 [ - + ]: 3083 : if (isinstance == -1) {
10007 : 0 : return 1;
10008 : : }
10009 [ + + ]: 3083 : if (isinstance) {
10010 : 32 : *out = Invert;
10011 : 32 : return 0;
10012 : : }
10013 : 3051 : isinstance = PyObject_IsInstance(obj, state->Not_type);
10014 [ - + ]: 3051 : if (isinstance == -1) {
10015 : 0 : return 1;
10016 : : }
10017 [ + + ]: 3051 : if (isinstance) {
10018 : 1909 : *out = Not;
10019 : 1909 : return 0;
10020 : : }
10021 : 1142 : isinstance = PyObject_IsInstance(obj, state->UAdd_type);
10022 [ - + ]: 1142 : if (isinstance == -1) {
10023 : 0 : return 1;
10024 : : }
10025 [ + + ]: 1142 : if (isinstance) {
10026 : 14 : *out = UAdd;
10027 : 14 : return 0;
10028 : : }
10029 : 1128 : isinstance = PyObject_IsInstance(obj, state->USub_type);
10030 [ - + ]: 1128 : if (isinstance == -1) {
10031 : 0 : return 1;
10032 : : }
10033 [ + - ]: 1128 : if (isinstance) {
10034 : 1128 : *out = USub;
10035 : 1128 : return 0;
10036 : : }
10037 : :
10038 : 0 : PyErr_Format(PyExc_TypeError, "expected some sort of unaryop, but got %R", obj);
10039 : 0 : return 1;
10040 : : }
10041 : :
10042 : : int
10043 : 8334 : obj2ast_cmpop(struct ast_state *state, PyObject* obj, cmpop_ty* out, PyArena*
10044 : : arena)
10045 : : {
10046 : : int isinstance;
10047 : :
10048 : 8334 : isinstance = PyObject_IsInstance(obj, state->Eq_type);
10049 [ - + ]: 8334 : if (isinstance == -1) {
10050 : 0 : return 1;
10051 : : }
10052 [ + + ]: 8334 : if (isinstance) {
10053 : 2295 : *out = Eq;
10054 : 2295 : return 0;
10055 : : }
10056 : 6039 : isinstance = PyObject_IsInstance(obj, state->NotEq_type);
10057 [ - + ]: 6039 : if (isinstance == -1) {
10058 : 0 : return 1;
10059 : : }
10060 [ + + ]: 6039 : if (isinstance) {
10061 : 599 : *out = NotEq;
10062 : 599 : return 0;
10063 : : }
10064 : 5440 : isinstance = PyObject_IsInstance(obj, state->Lt_type);
10065 [ - + ]: 5440 : if (isinstance == -1) {
10066 : 0 : return 1;
10067 : : }
10068 [ + + ]: 5440 : if (isinstance) {
10069 : 588 : *out = Lt;
10070 : 588 : return 0;
10071 : : }
10072 : 4852 : isinstance = PyObject_IsInstance(obj, state->LtE_type);
10073 [ - + ]: 4852 : if (isinstance == -1) {
10074 : 0 : return 1;
10075 : : }
10076 [ + + ]: 4852 : if (isinstance) {
10077 : 325 : *out = LtE;
10078 : 325 : return 0;
10079 : : }
10080 : 4527 : isinstance = PyObject_IsInstance(obj, state->Gt_type);
10081 [ - + ]: 4527 : if (isinstance == -1) {
10082 : 0 : return 1;
10083 : : }
10084 [ + + ]: 4527 : if (isinstance) {
10085 : 489 : *out = Gt;
10086 : 489 : return 0;
10087 : : }
10088 : 4038 : isinstance = PyObject_IsInstance(obj, state->GtE_type);
10089 [ - + ]: 4038 : if (isinstance == -1) {
10090 : 0 : return 1;
10091 : : }
10092 [ + + ]: 4038 : if (isinstance) {
10093 : 281 : *out = GtE;
10094 : 281 : return 0;
10095 : : }
10096 : 3757 : isinstance = PyObject_IsInstance(obj, state->Is_type);
10097 [ - + ]: 3757 : if (isinstance == -1) {
10098 : 0 : return 1;
10099 : : }
10100 [ + + ]: 3757 : if (isinstance) {
10101 : 1412 : *out = Is;
10102 : 1412 : return 0;
10103 : : }
10104 : 2345 : isinstance = PyObject_IsInstance(obj, state->IsNot_type);
10105 [ - + ]: 2345 : if (isinstance == -1) {
10106 : 0 : return 1;
10107 : : }
10108 [ + + ]: 2345 : if (isinstance) {
10109 : 962 : *out = IsNot;
10110 : 962 : return 0;
10111 : : }
10112 : 1383 : isinstance = PyObject_IsInstance(obj, state->In_type);
10113 [ - + ]: 1383 : if (isinstance == -1) {
10114 : 0 : return 1;
10115 : : }
10116 [ + + ]: 1383 : if (isinstance) {
10117 : 1070 : *out = In;
10118 : 1070 : return 0;
10119 : : }
10120 : 313 : isinstance = PyObject_IsInstance(obj, state->NotIn_type);
10121 [ - + ]: 313 : if (isinstance == -1) {
10122 : 0 : return 1;
10123 : : }
10124 [ + - ]: 313 : if (isinstance) {
10125 : 313 : *out = NotIn;
10126 : 313 : return 0;
10127 : : }
10128 : :
10129 : 0 : PyErr_Format(PyExc_TypeError, "expected some sort of cmpop, but got %R", obj);
10130 : 0 : return 1;
10131 : : }
10132 : :
10133 : : int
10134 : 635 : obj2ast_comprehension(struct ast_state *state, PyObject* obj, comprehension_ty*
10135 : : out, PyArena* arena)
10136 : : {
10137 : 635 : PyObject* tmp = NULL;
10138 : : expr_ty target;
10139 : : expr_ty iter;
10140 : : asdl_expr_seq* ifs;
10141 : : int is_async;
10142 : :
10143 [ - + ]: 635 : if (_PyObject_LookupAttr(obj, state->target, &tmp) < 0) {
10144 : 0 : return 1;
10145 : : }
10146 [ - + ]: 635 : if (tmp == NULL) {
10147 : 0 : PyErr_SetString(PyExc_TypeError, "required field \"target\" missing from comprehension");
10148 : 0 : return 1;
10149 : : }
10150 : : else {
10151 : : int res;
10152 [ - + ]: 635 : if (_Py_EnterRecursiveCall(" while traversing 'comprehension' node")) {
10153 : 0 : goto failed;
10154 : : }
10155 : 635 : res = obj2ast_expr(state, tmp, &target, arena);
10156 : 635 : _Py_LeaveRecursiveCall();
10157 [ - + ]: 635 : if (res != 0) goto failed;
10158 [ + - ]: 635 : Py_CLEAR(tmp);
10159 : : }
10160 [ - + ]: 635 : if (_PyObject_LookupAttr(obj, state->iter, &tmp) < 0) {
10161 : 0 : return 1;
10162 : : }
10163 [ - + ]: 635 : if (tmp == NULL) {
10164 : 0 : PyErr_SetString(PyExc_TypeError, "required field \"iter\" missing from comprehension");
10165 : 0 : return 1;
10166 : : }
10167 : : else {
10168 : : int res;
10169 [ - + ]: 635 : if (_Py_EnterRecursiveCall(" while traversing 'comprehension' node")) {
10170 : 0 : goto failed;
10171 : : }
10172 : 635 : res = obj2ast_expr(state, tmp, &iter, arena);
10173 : 635 : _Py_LeaveRecursiveCall();
10174 [ - + ]: 635 : if (res != 0) goto failed;
10175 [ + - ]: 635 : Py_CLEAR(tmp);
10176 : : }
10177 [ - + ]: 635 : if (_PyObject_LookupAttr(obj, state->ifs, &tmp) < 0) {
10178 : 0 : return 1;
10179 : : }
10180 [ - + ]: 635 : if (tmp == NULL) {
10181 : 0 : PyErr_SetString(PyExc_TypeError, "required field \"ifs\" missing from comprehension");
10182 : 0 : return 1;
10183 : : }
10184 : : else {
10185 : : int res;
10186 : : Py_ssize_t len;
10187 : : Py_ssize_t i;
10188 [ - + ]: 635 : if (!PyList_Check(tmp)) {
10189 : 0 : PyErr_Format(PyExc_TypeError, "comprehension field \"ifs\" must be a list, not a %.200s", _PyType_Name(Py_TYPE(tmp)));
10190 : 0 : goto failed;
10191 : : }
10192 : 635 : len = PyList_GET_SIZE(tmp);
10193 : 635 : ifs = _Py_asdl_expr_seq_new(len, arena);
10194 [ - + ]: 635 : if (ifs == NULL) goto failed;
10195 [ + + ]: 796 : for (i = 0; i < len; i++) {
10196 : : expr_ty val;
10197 : 161 : PyObject *tmp2 = PyList_GET_ITEM(tmp, i);
10198 : 161 : Py_INCREF(tmp2);
10199 [ - + ]: 161 : if (_Py_EnterRecursiveCall(" while traversing 'comprehension' node")) {
10200 : 0 : goto failed;
10201 : : }
10202 : 161 : res = obj2ast_expr(state, tmp2, &val, arena);
10203 : 161 : _Py_LeaveRecursiveCall();
10204 : 161 : Py_DECREF(tmp2);
10205 [ - + ]: 161 : if (res != 0) goto failed;
10206 [ - + ]: 161 : if (len != PyList_GET_SIZE(tmp)) {
10207 : 0 : PyErr_SetString(PyExc_RuntimeError, "comprehension field \"ifs\" changed size during iteration");
10208 : 0 : goto failed;
10209 : : }
10210 : 161 : asdl_seq_SET(ifs, i, val);
10211 : : }
10212 [ + - ]: 635 : Py_CLEAR(tmp);
10213 : : }
10214 [ - + ]: 635 : if (_PyObject_LookupAttr(obj, state->is_async, &tmp) < 0) {
10215 : 0 : return 1;
10216 : : }
10217 [ - + ]: 635 : if (tmp == NULL) {
10218 : 0 : PyErr_SetString(PyExc_TypeError, "required field \"is_async\" missing from comprehension");
10219 : 0 : return 1;
10220 : : }
10221 : : else {
10222 : : int res;
10223 [ - + ]: 635 : if (_Py_EnterRecursiveCall(" while traversing 'comprehension' node")) {
10224 : 0 : goto failed;
10225 : : }
10226 : 635 : res = obj2ast_int(state, tmp, &is_async, arena);
10227 : 635 : _Py_LeaveRecursiveCall();
10228 [ - + ]: 635 : if (res != 0) goto failed;
10229 [ + - ]: 635 : Py_CLEAR(tmp);
10230 : : }
10231 : 635 : *out = _PyAST_comprehension(target, iter, ifs, is_async, arena);
10232 : 635 : return 0;
10233 : 0 : failed:
10234 : 0 : Py_XDECREF(tmp);
10235 : 0 : return 1;
10236 : : }
10237 : :
10238 : : int
10239 : 1409 : obj2ast_excepthandler(struct ast_state *state, PyObject* obj, excepthandler_ty*
10240 : : out, PyArena* arena)
10241 : : {
10242 : : int isinstance;
10243 : :
10244 : 1409 : PyObject *tmp = NULL;
10245 : : PyObject *tp;
10246 : : int lineno;
10247 : : int col_offset;
10248 : : int end_lineno;
10249 : : int end_col_offset;
10250 : :
10251 [ - + ]: 1409 : if (obj == Py_None) {
10252 : 0 : *out = NULL;
10253 : 0 : return 0;
10254 : : }
10255 [ - + ]: 1409 : if (_PyObject_LookupAttr(obj, state->lineno, &tmp) < 0) {
10256 : 0 : return 1;
10257 : : }
10258 [ - + ]: 1409 : if (tmp == NULL) {
10259 : 0 : PyErr_SetString(PyExc_TypeError, "required field \"lineno\" missing from excepthandler");
10260 : 0 : return 1;
10261 : : }
10262 : : else {
10263 : : int res;
10264 [ - + ]: 1409 : if (_Py_EnterRecursiveCall(" while traversing 'excepthandler' node")) {
10265 : 0 : goto failed;
10266 : : }
10267 : 1409 : res = obj2ast_int(state, tmp, &lineno, arena);
10268 : 1409 : _Py_LeaveRecursiveCall();
10269 [ - + ]: 1409 : if (res != 0) goto failed;
10270 [ + - ]: 1409 : Py_CLEAR(tmp);
10271 : : }
10272 [ - + ]: 1409 : if (_PyObject_LookupAttr(obj, state->col_offset, &tmp) < 0) {
10273 : 0 : return 1;
10274 : : }
10275 [ - + ]: 1409 : if (tmp == NULL) {
10276 : 0 : PyErr_SetString(PyExc_TypeError, "required field \"col_offset\" missing from excepthandler");
10277 : 0 : return 1;
10278 : : }
10279 : : else {
10280 : : int res;
10281 [ - + ]: 1409 : if (_Py_EnterRecursiveCall(" while traversing 'excepthandler' node")) {
10282 : 0 : goto failed;
10283 : : }
10284 : 1409 : res = obj2ast_int(state, tmp, &col_offset, arena);
10285 : 1409 : _Py_LeaveRecursiveCall();
10286 [ - + ]: 1409 : if (res != 0) goto failed;
10287 [ + - ]: 1409 : Py_CLEAR(tmp);
10288 : : }
10289 [ - + ]: 1409 : if (_PyObject_LookupAttr(obj, state->end_lineno, &tmp) < 0) {
10290 : 0 : return 1;
10291 : : }
10292 [ + - - + ]: 1409 : if (tmp == NULL || tmp == Py_None) {
10293 [ # # ]: 0 : Py_CLEAR(tmp);
10294 : 0 : end_lineno = lineno;
10295 : : }
10296 : : else {
10297 : : int res;
10298 [ - + ]: 1409 : if (_Py_EnterRecursiveCall(" while traversing 'excepthandler' node")) {
10299 : 0 : goto failed;
10300 : : }
10301 : 1409 : res = obj2ast_int(state, tmp, &end_lineno, arena);
10302 : 1409 : _Py_LeaveRecursiveCall();
10303 [ - + ]: 1409 : if (res != 0) goto failed;
10304 [ + - ]: 1409 : Py_CLEAR(tmp);
10305 : : }
10306 [ - + ]: 1409 : if (_PyObject_LookupAttr(obj, state->end_col_offset, &tmp) < 0) {
10307 : 0 : return 1;
10308 : : }
10309 [ + - - + ]: 1409 : if (tmp == NULL || tmp == Py_None) {
10310 [ # # ]: 0 : Py_CLEAR(tmp);
10311 : 0 : end_col_offset = col_offset;
10312 : : }
10313 : : else {
10314 : : int res;
10315 [ - + ]: 1409 : if (_Py_EnterRecursiveCall(" while traversing 'excepthandler' node")) {
10316 : 0 : goto failed;
10317 : : }
10318 : 1409 : res = obj2ast_int(state, tmp, &end_col_offset, arena);
10319 : 1409 : _Py_LeaveRecursiveCall();
10320 [ - + ]: 1409 : if (res != 0) goto failed;
10321 [ + - ]: 1409 : Py_CLEAR(tmp);
10322 : : }
10323 : 1409 : tp = state->ExceptHandler_type;
10324 : 1409 : isinstance = PyObject_IsInstance(obj, tp);
10325 [ - + ]: 1409 : if (isinstance == -1) {
10326 : 0 : return 1;
10327 : : }
10328 [ + - ]: 1409 : if (isinstance) {
10329 : : expr_ty type;
10330 : : identifier name;
10331 : : asdl_stmt_seq* body;
10332 : :
10333 [ - + ]: 1409 : if (_PyObject_LookupAttr(obj, state->type, &tmp) < 0) {
10334 : 1409 : return 1;
10335 : : }
10336 [ + - + + ]: 1409 : if (tmp == NULL || tmp == Py_None) {
10337 [ + - ]: 96 : Py_CLEAR(tmp);
10338 : 96 : type = NULL;
10339 : : }
10340 : : else {
10341 : : int res;
10342 [ - + ]: 1313 : if (_Py_EnterRecursiveCall(" while traversing 'ExceptHandler' node")) {
10343 : 0 : goto failed;
10344 : : }
10345 : 1313 : res = obj2ast_expr(state, tmp, &type, arena);
10346 : 1313 : _Py_LeaveRecursiveCall();
10347 [ - + ]: 1313 : if (res != 0) goto failed;
10348 [ + - ]: 1313 : Py_CLEAR(tmp);
10349 : : }
10350 [ - + ]: 1409 : if (_PyObject_LookupAttr(obj, state->name, &tmp) < 0) {
10351 : 0 : return 1;
10352 : : }
10353 [ + - + + ]: 1409 : if (tmp == NULL || tmp == Py_None) {
10354 [ + - ]: 1174 : Py_CLEAR(tmp);
10355 : 1174 : name = NULL;
10356 : : }
10357 : : else {
10358 : : int res;
10359 [ - + ]: 235 : if (_Py_EnterRecursiveCall(" while traversing 'ExceptHandler' node")) {
10360 : 0 : goto failed;
10361 : : }
10362 : 235 : res = obj2ast_identifier(state, tmp, &name, arena);
10363 : 235 : _Py_LeaveRecursiveCall();
10364 [ - + ]: 235 : if (res != 0) goto failed;
10365 [ + - ]: 235 : Py_CLEAR(tmp);
10366 : : }
10367 [ - + ]: 1409 : if (_PyObject_LookupAttr(obj, state->body, &tmp) < 0) {
10368 : 0 : return 1;
10369 : : }
10370 [ - + ]: 1409 : if (tmp == NULL) {
10371 : 0 : PyErr_SetString(PyExc_TypeError, "required field \"body\" missing from ExceptHandler");
10372 : 0 : return 1;
10373 : : }
10374 : : else {
10375 : : int res;
10376 : : Py_ssize_t len;
10377 : : Py_ssize_t i;
10378 [ - + ]: 1409 : if (!PyList_Check(tmp)) {
10379 : 0 : PyErr_Format(PyExc_TypeError, "ExceptHandler field \"body\" must be a list, not a %.200s", _PyType_Name(Py_TYPE(tmp)));
10380 : 0 : goto failed;
10381 : : }
10382 : 1409 : len = PyList_GET_SIZE(tmp);
10383 : 1409 : body = _Py_asdl_stmt_seq_new(len, arena);
10384 [ - + ]: 1409 : if (body == NULL) goto failed;
10385 [ + + ]: 3281 : for (i = 0; i < len; i++) {
10386 : : stmt_ty val;
10387 : 1872 : PyObject *tmp2 = PyList_GET_ITEM(tmp, i);
10388 : 1872 : Py_INCREF(tmp2);
10389 [ - + ]: 1872 : if (_Py_EnterRecursiveCall(" while traversing 'ExceptHandler' node")) {
10390 : 0 : goto failed;
10391 : : }
10392 : 1872 : res = obj2ast_stmt(state, tmp2, &val, arena);
10393 : 1872 : _Py_LeaveRecursiveCall();
10394 : 1872 : Py_DECREF(tmp2);
10395 [ - + ]: 1872 : if (res != 0) goto failed;
10396 [ - + ]: 1872 : if (len != PyList_GET_SIZE(tmp)) {
10397 : 0 : PyErr_SetString(PyExc_RuntimeError, "ExceptHandler field \"body\" changed size during iteration");
10398 : 0 : goto failed;
10399 : : }
10400 : 1872 : asdl_seq_SET(body, i, val);
10401 : : }
10402 [ + - ]: 1409 : Py_CLEAR(tmp);
10403 : : }
10404 : 1409 : *out = _PyAST_ExceptHandler(type, name, body, lineno, col_offset,
10405 : : end_lineno, end_col_offset, arena);
10406 [ - + ]: 1409 : if (*out == NULL) goto failed;
10407 : 1409 : return 0;
10408 : : }
10409 : :
10410 : 0 : PyErr_Format(PyExc_TypeError, "expected some sort of excepthandler, but got %R", obj);
10411 : 0 : failed:
10412 : 0 : Py_XDECREF(tmp);
10413 : 0 : return 1;
10414 : : }
10415 : :
10416 : : int
10417 : 7602 : obj2ast_arguments(struct ast_state *state, PyObject* obj, arguments_ty* out,
10418 : : PyArena* arena)
10419 : : {
10420 : 7602 : PyObject* tmp = NULL;
10421 : : asdl_arg_seq* posonlyargs;
10422 : : asdl_arg_seq* args;
10423 : : arg_ty vararg;
10424 : : asdl_arg_seq* kwonlyargs;
10425 : : asdl_expr_seq* kw_defaults;
10426 : : arg_ty kwarg;
10427 : : asdl_expr_seq* defaults;
10428 : :
10429 [ - + ]: 7602 : if (_PyObject_LookupAttr(obj, state->posonlyargs, &tmp) < 0) {
10430 : 0 : return 1;
10431 : : }
10432 [ - + ]: 7602 : if (tmp == NULL) {
10433 : 0 : PyErr_SetString(PyExc_TypeError, "required field \"posonlyargs\" missing from arguments");
10434 : 0 : return 1;
10435 : : }
10436 : : else {
10437 : : int res;
10438 : : Py_ssize_t len;
10439 : : Py_ssize_t i;
10440 [ - + ]: 7602 : if (!PyList_Check(tmp)) {
10441 : 0 : PyErr_Format(PyExc_TypeError, "arguments field \"posonlyargs\" must be a list, not a %.200s", _PyType_Name(Py_TYPE(tmp)));
10442 : 0 : goto failed;
10443 : : }
10444 : 7602 : len = PyList_GET_SIZE(tmp);
10445 : 7602 : posonlyargs = _Py_asdl_arg_seq_new(len, arena);
10446 [ - + ]: 7602 : if (posonlyargs == NULL) goto failed;
10447 [ + + ]: 7721 : for (i = 0; i < len; i++) {
10448 : : arg_ty val;
10449 : 119 : PyObject *tmp2 = PyList_GET_ITEM(tmp, i);
10450 : 119 : Py_INCREF(tmp2);
10451 [ - + ]: 119 : if (_Py_EnterRecursiveCall(" while traversing 'arguments' node")) {
10452 : 0 : goto failed;
10453 : : }
10454 : 119 : res = obj2ast_arg(state, tmp2, &val, arena);
10455 : 119 : _Py_LeaveRecursiveCall();
10456 : 119 : Py_DECREF(tmp2);
10457 [ - + ]: 119 : if (res != 0) goto failed;
10458 [ - + ]: 119 : if (len != PyList_GET_SIZE(tmp)) {
10459 : 0 : PyErr_SetString(PyExc_RuntimeError, "arguments field \"posonlyargs\" changed size during iteration");
10460 : 0 : goto failed;
10461 : : }
10462 : 119 : asdl_seq_SET(posonlyargs, i, val);
10463 : : }
10464 [ + - ]: 7602 : Py_CLEAR(tmp);
10465 : : }
10466 [ - + ]: 7602 : if (_PyObject_LookupAttr(obj, state->args, &tmp) < 0) {
10467 : 0 : return 1;
10468 : : }
10469 [ - + ]: 7602 : if (tmp == NULL) {
10470 : 0 : PyErr_SetString(PyExc_TypeError, "required field \"args\" missing from arguments");
10471 : 0 : return 1;
10472 : : }
10473 : : else {
10474 : : int res;
10475 : : Py_ssize_t len;
10476 : : Py_ssize_t i;
10477 [ - + ]: 7602 : if (!PyList_Check(tmp)) {
10478 : 0 : PyErr_Format(PyExc_TypeError, "arguments field \"args\" must be a list, not a %.200s", _PyType_Name(Py_TYPE(tmp)));
10479 : 0 : goto failed;
10480 : : }
10481 : 7602 : len = PyList_GET_SIZE(tmp);
10482 : 7602 : args = _Py_asdl_arg_seq_new(len, arena);
10483 [ - + ]: 7602 : if (args == NULL) goto failed;
10484 [ + + ]: 21725 : for (i = 0; i < len; i++) {
10485 : : arg_ty val;
10486 : 14123 : PyObject *tmp2 = PyList_GET_ITEM(tmp, i);
10487 : 14123 : Py_INCREF(tmp2);
10488 [ - + ]: 14123 : if (_Py_EnterRecursiveCall(" while traversing 'arguments' node")) {
10489 : 0 : goto failed;
10490 : : }
10491 : 14123 : res = obj2ast_arg(state, tmp2, &val, arena);
10492 : 14123 : _Py_LeaveRecursiveCall();
10493 : 14123 : Py_DECREF(tmp2);
10494 [ - + ]: 14123 : if (res != 0) goto failed;
10495 [ - + ]: 14123 : if (len != PyList_GET_SIZE(tmp)) {
10496 : 0 : PyErr_SetString(PyExc_RuntimeError, "arguments field \"args\" changed size during iteration");
10497 : 0 : goto failed;
10498 : : }
10499 : 14123 : asdl_seq_SET(args, i, val);
10500 : : }
10501 [ + - ]: 7602 : Py_CLEAR(tmp);
10502 : : }
10503 [ - + ]: 7602 : if (_PyObject_LookupAttr(obj, state->vararg, &tmp) < 0) {
10504 : 0 : return 1;
10505 : : }
10506 [ + - + + ]: 7602 : if (tmp == NULL || tmp == Py_None) {
10507 [ + - ]: 7319 : Py_CLEAR(tmp);
10508 : 7319 : vararg = NULL;
10509 : : }
10510 : : else {
10511 : : int res;
10512 [ - + ]: 283 : if (_Py_EnterRecursiveCall(" while traversing 'arguments' node")) {
10513 : 0 : goto failed;
10514 : : }
10515 : 283 : res = obj2ast_arg(state, tmp, &vararg, arena);
10516 : 283 : _Py_LeaveRecursiveCall();
10517 [ - + ]: 283 : if (res != 0) goto failed;
10518 [ + - ]: 283 : Py_CLEAR(tmp);
10519 : : }
10520 [ - + ]: 7602 : if (_PyObject_LookupAttr(obj, state->kwonlyargs, &tmp) < 0) {
10521 : 0 : return 1;
10522 : : }
10523 [ - + ]: 7602 : if (tmp == NULL) {
10524 : 0 : PyErr_SetString(PyExc_TypeError, "required field \"kwonlyargs\" missing from arguments");
10525 : 0 : return 1;
10526 : : }
10527 : : else {
10528 : : int res;
10529 : : Py_ssize_t len;
10530 : : Py_ssize_t i;
10531 [ - + ]: 7602 : if (!PyList_Check(tmp)) {
10532 : 0 : PyErr_Format(PyExc_TypeError, "arguments field \"kwonlyargs\" must be a list, not a %.200s", _PyType_Name(Py_TYPE(tmp)));
10533 : 0 : goto failed;
10534 : : }
10535 : 7602 : len = PyList_GET_SIZE(tmp);
10536 : 7602 : kwonlyargs = _Py_asdl_arg_seq_new(len, arena);
10537 [ - + ]: 7602 : if (kwonlyargs == NULL) goto failed;
10538 [ + + ]: 8089 : for (i = 0; i < len; i++) {
10539 : : arg_ty val;
10540 : 487 : PyObject *tmp2 = PyList_GET_ITEM(tmp, i);
10541 : 487 : Py_INCREF(tmp2);
10542 [ - + ]: 487 : if (_Py_EnterRecursiveCall(" while traversing 'arguments' node")) {
10543 : 0 : goto failed;
10544 : : }
10545 : 487 : res = obj2ast_arg(state, tmp2, &val, arena);
10546 : 487 : _Py_LeaveRecursiveCall();
10547 : 487 : Py_DECREF(tmp2);
10548 [ - + ]: 487 : if (res != 0) goto failed;
10549 [ - + ]: 487 : if (len != PyList_GET_SIZE(tmp)) {
10550 : 0 : PyErr_SetString(PyExc_RuntimeError, "arguments field \"kwonlyargs\" changed size during iteration");
10551 : 0 : goto failed;
10552 : : }
10553 : 487 : asdl_seq_SET(kwonlyargs, i, val);
10554 : : }
10555 [ + - ]: 7602 : Py_CLEAR(tmp);
10556 : : }
10557 [ - + ]: 7602 : if (_PyObject_LookupAttr(obj, state->kw_defaults, &tmp) < 0) {
10558 : 0 : return 1;
10559 : : }
10560 [ - + ]: 7602 : if (tmp == NULL) {
10561 : 0 : PyErr_SetString(PyExc_TypeError, "required field \"kw_defaults\" missing from arguments");
10562 : 0 : return 1;
10563 : : }
10564 : : else {
10565 : : int res;
10566 : : Py_ssize_t len;
10567 : : Py_ssize_t i;
10568 [ - + ]: 7602 : if (!PyList_Check(tmp)) {
10569 : 0 : PyErr_Format(PyExc_TypeError, "arguments field \"kw_defaults\" must be a list, not a %.200s", _PyType_Name(Py_TYPE(tmp)));
10570 : 0 : goto failed;
10571 : : }
10572 : 7602 : len = PyList_GET_SIZE(tmp);
10573 : 7602 : kw_defaults = _Py_asdl_expr_seq_new(len, arena);
10574 [ - + ]: 7602 : if (kw_defaults == NULL) goto failed;
10575 [ + + ]: 8089 : for (i = 0; i < len; i++) {
10576 : : expr_ty val;
10577 : 487 : PyObject *tmp2 = PyList_GET_ITEM(tmp, i);
10578 : 487 : Py_INCREF(tmp2);
10579 [ - + ]: 487 : if (_Py_EnterRecursiveCall(" while traversing 'arguments' node")) {
10580 : 0 : goto failed;
10581 : : }
10582 : 487 : res = obj2ast_expr(state, tmp2, &val, arena);
10583 : 487 : _Py_LeaveRecursiveCall();
10584 : 487 : Py_DECREF(tmp2);
10585 [ - + ]: 487 : if (res != 0) goto failed;
10586 [ - + ]: 487 : if (len != PyList_GET_SIZE(tmp)) {
10587 : 0 : PyErr_SetString(PyExc_RuntimeError, "arguments field \"kw_defaults\" changed size during iteration");
10588 : 0 : goto failed;
10589 : : }
10590 : 487 : asdl_seq_SET(kw_defaults, i, val);
10591 : : }
10592 [ + - ]: 7602 : Py_CLEAR(tmp);
10593 : : }
10594 [ - + ]: 7602 : if (_PyObject_LookupAttr(obj, state->kwarg, &tmp) < 0) {
10595 : 0 : return 1;
10596 : : }
10597 [ + - + + ]: 7602 : if (tmp == NULL || tmp == Py_None) {
10598 [ + - ]: 7430 : Py_CLEAR(tmp);
10599 : 7430 : kwarg = NULL;
10600 : : }
10601 : : else {
10602 : : int res;
10603 [ - + ]: 172 : if (_Py_EnterRecursiveCall(" while traversing 'arguments' node")) {
10604 : 0 : goto failed;
10605 : : }
10606 : 172 : res = obj2ast_arg(state, tmp, &kwarg, arena);
10607 : 172 : _Py_LeaveRecursiveCall();
10608 [ - + ]: 172 : if (res != 0) goto failed;
10609 [ + - ]: 172 : Py_CLEAR(tmp);
10610 : : }
10611 [ - + ]: 7602 : if (_PyObject_LookupAttr(obj, state->defaults, &tmp) < 0) {
10612 : 0 : return 1;
10613 : : }
10614 [ - + ]: 7602 : if (tmp == NULL) {
10615 : 0 : PyErr_SetString(PyExc_TypeError, "required field \"defaults\" missing from arguments");
10616 : 0 : return 1;
10617 : : }
10618 : : else {
10619 : : int res;
10620 : : Py_ssize_t len;
10621 : : Py_ssize_t i;
10622 [ - + ]: 7602 : if (!PyList_Check(tmp)) {
10623 : 0 : PyErr_Format(PyExc_TypeError, "arguments field \"defaults\" must be a list, not a %.200s", _PyType_Name(Py_TYPE(tmp)));
10624 : 0 : goto failed;
10625 : : }
10626 : 7602 : len = PyList_GET_SIZE(tmp);
10627 : 7602 : defaults = _Py_asdl_expr_seq_new(len, arena);
10628 [ - + ]: 7602 : if (defaults == NULL) goto failed;
10629 [ + + ]: 10023 : for (i = 0; i < len; i++) {
10630 : : expr_ty val;
10631 : 2421 : PyObject *tmp2 = PyList_GET_ITEM(tmp, i);
10632 : 2421 : Py_INCREF(tmp2);
10633 [ - + ]: 2421 : if (_Py_EnterRecursiveCall(" while traversing 'arguments' node")) {
10634 : 0 : goto failed;
10635 : : }
10636 : 2421 : res = obj2ast_expr(state, tmp2, &val, arena);
10637 : 2421 : _Py_LeaveRecursiveCall();
10638 : 2421 : Py_DECREF(tmp2);
10639 [ - + ]: 2421 : if (res != 0) goto failed;
10640 [ - + ]: 2421 : if (len != PyList_GET_SIZE(tmp)) {
10641 : 0 : PyErr_SetString(PyExc_RuntimeError, "arguments field \"defaults\" changed size during iteration");
10642 : 0 : goto failed;
10643 : : }
10644 : 2421 : asdl_seq_SET(defaults, i, val);
10645 : : }
10646 [ + - ]: 7602 : Py_CLEAR(tmp);
10647 : : }
10648 : 7602 : *out = _PyAST_arguments(posonlyargs, args, vararg, kwonlyargs, kw_defaults,
10649 : : kwarg, defaults, arena);
10650 : 7602 : return 0;
10651 : 0 : failed:
10652 : 0 : Py_XDECREF(tmp);
10653 : 0 : return 1;
10654 : : }
10655 : :
10656 : : int
10657 : 15184 : obj2ast_arg(struct ast_state *state, PyObject* obj, arg_ty* out, PyArena* arena)
10658 : : {
10659 : 15184 : PyObject* tmp = NULL;
10660 : : identifier arg;
10661 : : expr_ty annotation;
10662 : : string type_comment;
10663 : : int lineno;
10664 : : int col_offset;
10665 : : int end_lineno;
10666 : : int end_col_offset;
10667 : :
10668 [ - + ]: 15184 : if (_PyObject_LookupAttr(obj, state->arg, &tmp) < 0) {
10669 : 0 : return 1;
10670 : : }
10671 [ - + ]: 15184 : if (tmp == NULL) {
10672 : 0 : PyErr_SetString(PyExc_TypeError, "required field \"arg\" missing from arg");
10673 : 0 : return 1;
10674 : : }
10675 : : else {
10676 : : int res;
10677 [ - + ]: 15184 : if (_Py_EnterRecursiveCall(" while traversing 'arg' node")) {
10678 : 0 : goto failed;
10679 : : }
10680 : 15184 : res = obj2ast_identifier(state, tmp, &arg, arena);
10681 : 15184 : _Py_LeaveRecursiveCall();
10682 [ - + ]: 15184 : if (res != 0) goto failed;
10683 [ + - ]: 15184 : Py_CLEAR(tmp);
10684 : : }
10685 [ - + ]: 15184 : if (_PyObject_LookupAttr(obj, state->annotation, &tmp) < 0) {
10686 : 0 : return 1;
10687 : : }
10688 [ + - + + ]: 15184 : if (tmp == NULL || tmp == Py_None) {
10689 [ + - ]: 15108 : Py_CLEAR(tmp);
10690 : 15108 : annotation = NULL;
10691 : : }
10692 : : else {
10693 : : int res;
10694 [ - + ]: 76 : if (_Py_EnterRecursiveCall(" while traversing 'arg' node")) {
10695 : 0 : goto failed;
10696 : : }
10697 : 76 : res = obj2ast_expr(state, tmp, &annotation, arena);
10698 : 76 : _Py_LeaveRecursiveCall();
10699 [ - + ]: 76 : if (res != 0) goto failed;
10700 [ + - ]: 76 : Py_CLEAR(tmp);
10701 : : }
10702 [ - + ]: 15184 : if (_PyObject_LookupAttr(obj, state->type_comment, &tmp) < 0) {
10703 : 0 : return 1;
10704 : : }
10705 [ + - + - ]: 15184 : if (tmp == NULL || tmp == Py_None) {
10706 [ + - ]: 15184 : Py_CLEAR(tmp);
10707 : 15184 : type_comment = NULL;
10708 : : }
10709 : : else {
10710 : : int res;
10711 [ # # ]: 0 : if (_Py_EnterRecursiveCall(" while traversing 'arg' node")) {
10712 : 0 : goto failed;
10713 : : }
10714 : 0 : res = obj2ast_string(state, tmp, &type_comment, arena);
10715 : 0 : _Py_LeaveRecursiveCall();
10716 [ # # ]: 0 : if (res != 0) goto failed;
10717 [ # # ]: 0 : Py_CLEAR(tmp);
10718 : : }
10719 [ - + ]: 15184 : if (_PyObject_LookupAttr(obj, state->lineno, &tmp) < 0) {
10720 : 0 : return 1;
10721 : : }
10722 [ - + ]: 15184 : if (tmp == NULL) {
10723 : 0 : PyErr_SetString(PyExc_TypeError, "required field \"lineno\" missing from arg");
10724 : 0 : return 1;
10725 : : }
10726 : : else {
10727 : : int res;
10728 [ - + ]: 15184 : if (_Py_EnterRecursiveCall(" while traversing 'arg' node")) {
10729 : 0 : goto failed;
10730 : : }
10731 : 15184 : res = obj2ast_int(state, tmp, &lineno, arena);
10732 : 15184 : _Py_LeaveRecursiveCall();
10733 [ - + ]: 15184 : if (res != 0) goto failed;
10734 [ + - ]: 15184 : Py_CLEAR(tmp);
10735 : : }
10736 [ - + ]: 15184 : if (_PyObject_LookupAttr(obj, state->col_offset, &tmp) < 0) {
10737 : 0 : return 1;
10738 : : }
10739 [ - + ]: 15184 : if (tmp == NULL) {
10740 : 0 : PyErr_SetString(PyExc_TypeError, "required field \"col_offset\" missing from arg");
10741 : 0 : return 1;
10742 : : }
10743 : : else {
10744 : : int res;
10745 [ - + ]: 15184 : if (_Py_EnterRecursiveCall(" while traversing 'arg' node")) {
10746 : 0 : goto failed;
10747 : : }
10748 : 15184 : res = obj2ast_int(state, tmp, &col_offset, arena);
10749 : 15184 : _Py_LeaveRecursiveCall();
10750 [ - + ]: 15184 : if (res != 0) goto failed;
10751 [ + - ]: 15184 : Py_CLEAR(tmp);
10752 : : }
10753 [ - + ]: 15184 : if (_PyObject_LookupAttr(obj, state->end_lineno, &tmp) < 0) {
10754 : 0 : return 1;
10755 : : }
10756 [ + - - + ]: 15184 : if (tmp == NULL || tmp == Py_None) {
10757 [ # # ]: 0 : Py_CLEAR(tmp);
10758 : 0 : end_lineno = lineno;
10759 : : }
10760 : : else {
10761 : : int res;
10762 [ - + ]: 15184 : if (_Py_EnterRecursiveCall(" while traversing 'arg' node")) {
10763 : 0 : goto failed;
10764 : : }
10765 : 15184 : res = obj2ast_int(state, tmp, &end_lineno, arena);
10766 : 15184 : _Py_LeaveRecursiveCall();
10767 [ - + ]: 15184 : if (res != 0) goto failed;
10768 [ + - ]: 15184 : Py_CLEAR(tmp);
10769 : : }
10770 [ - + ]: 15184 : if (_PyObject_LookupAttr(obj, state->end_col_offset, &tmp) < 0) {
10771 : 0 : return 1;
10772 : : }
10773 [ + - - + ]: 15184 : if (tmp == NULL || tmp == Py_None) {
10774 [ # # ]: 0 : Py_CLEAR(tmp);
10775 : 0 : end_col_offset = col_offset;
10776 : : }
10777 : : else {
10778 : : int res;
10779 [ - + ]: 15184 : if (_Py_EnterRecursiveCall(" while traversing 'arg' node")) {
10780 : 0 : goto failed;
10781 : : }
10782 : 15184 : res = obj2ast_int(state, tmp, &end_col_offset, arena);
10783 : 15184 : _Py_LeaveRecursiveCall();
10784 [ - + ]: 15184 : if (res != 0) goto failed;
10785 [ + - ]: 15184 : Py_CLEAR(tmp);
10786 : : }
10787 : 15184 : *out = _PyAST_arg(arg, annotation, type_comment, lineno, col_offset,
10788 : : end_lineno, end_col_offset, arena);
10789 : 15184 : return 0;
10790 : 0 : failed:
10791 : 0 : Py_XDECREF(tmp);
10792 : 0 : return 1;
10793 : : }
10794 : :
10795 : : int
10796 : 3305 : obj2ast_keyword(struct ast_state *state, PyObject* obj, keyword_ty* out,
10797 : : PyArena* arena)
10798 : : {
10799 : 3305 : PyObject* tmp = NULL;
10800 : : identifier arg;
10801 : : expr_ty value;
10802 : : int lineno;
10803 : : int col_offset;
10804 : : int end_lineno;
10805 : : int end_col_offset;
10806 : :
10807 [ - + ]: 3305 : if (_PyObject_LookupAttr(obj, state->arg, &tmp) < 0) {
10808 : 0 : return 1;
10809 : : }
10810 [ + - + + ]: 3305 : if (tmp == NULL || tmp == Py_None) {
10811 [ + - ]: 154 : Py_CLEAR(tmp);
10812 : 154 : arg = NULL;
10813 : : }
10814 : : else {
10815 : : int res;
10816 [ - + ]: 3151 : if (_Py_EnterRecursiveCall(" while traversing 'keyword' node")) {
10817 : 0 : goto failed;
10818 : : }
10819 : 3151 : res = obj2ast_identifier(state, tmp, &arg, arena);
10820 : 3151 : _Py_LeaveRecursiveCall();
10821 [ - + ]: 3151 : if (res != 0) goto failed;
10822 [ + - ]: 3151 : Py_CLEAR(tmp);
10823 : : }
10824 [ - + ]: 3305 : if (_PyObject_LookupAttr(obj, state->value, &tmp) < 0) {
10825 : 0 : return 1;
10826 : : }
10827 [ - + ]: 3305 : if (tmp == NULL) {
10828 : 0 : PyErr_SetString(PyExc_TypeError, "required field \"value\" missing from keyword");
10829 : 0 : return 1;
10830 : : }
10831 : : else {
10832 : : int res;
10833 [ - + ]: 3305 : if (_Py_EnterRecursiveCall(" while traversing 'keyword' node")) {
10834 : 0 : goto failed;
10835 : : }
10836 : 3305 : res = obj2ast_expr(state, tmp, &value, arena);
10837 : 3305 : _Py_LeaveRecursiveCall();
10838 [ - + ]: 3305 : if (res != 0) goto failed;
10839 [ + - ]: 3305 : Py_CLEAR(tmp);
10840 : : }
10841 [ - + ]: 3305 : if (_PyObject_LookupAttr(obj, state->lineno, &tmp) < 0) {
10842 : 0 : return 1;
10843 : : }
10844 [ - + ]: 3305 : if (tmp == NULL) {
10845 : 0 : PyErr_SetString(PyExc_TypeError, "required field \"lineno\" missing from keyword");
10846 : 0 : return 1;
10847 : : }
10848 : : else {
10849 : : int res;
10850 [ - + ]: 3305 : if (_Py_EnterRecursiveCall(" while traversing 'keyword' node")) {
10851 : 0 : goto failed;
10852 : : }
10853 : 3305 : res = obj2ast_int(state, tmp, &lineno, arena);
10854 : 3305 : _Py_LeaveRecursiveCall();
10855 [ - + ]: 3305 : if (res != 0) goto failed;
10856 [ + - ]: 3305 : Py_CLEAR(tmp);
10857 : : }
10858 [ - + ]: 3305 : if (_PyObject_LookupAttr(obj, state->col_offset, &tmp) < 0) {
10859 : 0 : return 1;
10860 : : }
10861 [ - + ]: 3305 : if (tmp == NULL) {
10862 : 0 : PyErr_SetString(PyExc_TypeError, "required field \"col_offset\" missing from keyword");
10863 : 0 : return 1;
10864 : : }
10865 : : else {
10866 : : int res;
10867 [ - + ]: 3305 : if (_Py_EnterRecursiveCall(" while traversing 'keyword' node")) {
10868 : 0 : goto failed;
10869 : : }
10870 : 3305 : res = obj2ast_int(state, tmp, &col_offset, arena);
10871 : 3305 : _Py_LeaveRecursiveCall();
10872 [ - + ]: 3305 : if (res != 0) goto failed;
10873 [ + - ]: 3305 : Py_CLEAR(tmp);
10874 : : }
10875 [ - + ]: 3305 : if (_PyObject_LookupAttr(obj, state->end_lineno, &tmp) < 0) {
10876 : 0 : return 1;
10877 : : }
10878 [ + - - + ]: 3305 : if (tmp == NULL || tmp == Py_None) {
10879 [ # # ]: 0 : Py_CLEAR(tmp);
10880 : 0 : end_lineno = lineno;
10881 : : }
10882 : : else {
10883 : : int res;
10884 [ - + ]: 3305 : if (_Py_EnterRecursiveCall(" while traversing 'keyword' node")) {
10885 : 0 : goto failed;
10886 : : }
10887 : 3305 : res = obj2ast_int(state, tmp, &end_lineno, arena);
10888 : 3305 : _Py_LeaveRecursiveCall();
10889 [ - + ]: 3305 : if (res != 0) goto failed;
10890 [ + - ]: 3305 : Py_CLEAR(tmp);
10891 : : }
10892 [ - + ]: 3305 : if (_PyObject_LookupAttr(obj, state->end_col_offset, &tmp) < 0) {
10893 : 0 : return 1;
10894 : : }
10895 [ + - - + ]: 3305 : if (tmp == NULL || tmp == Py_None) {
10896 [ # # ]: 0 : Py_CLEAR(tmp);
10897 : 0 : end_col_offset = col_offset;
10898 : : }
10899 : : else {
10900 : : int res;
10901 [ - + ]: 3305 : if (_Py_EnterRecursiveCall(" while traversing 'keyword' node")) {
10902 : 0 : goto failed;
10903 : : }
10904 : 3305 : res = obj2ast_int(state, tmp, &end_col_offset, arena);
10905 : 3305 : _Py_LeaveRecursiveCall();
10906 [ - + ]: 3305 : if (res != 0) goto failed;
10907 [ + - ]: 3305 : Py_CLEAR(tmp);
10908 : : }
10909 : 3305 : *out = _PyAST_keyword(arg, value, lineno, col_offset, end_lineno,
10910 : : end_col_offset, arena);
10911 : 3305 : return 0;
10912 : 0 : failed:
10913 : 0 : Py_XDECREF(tmp);
10914 : 0 : return 1;
10915 : : }
10916 : :
10917 : : int
10918 : 1620 : obj2ast_alias(struct ast_state *state, PyObject* obj, alias_ty* out, PyArena*
10919 : : arena)
10920 : : {
10921 : 1620 : PyObject* tmp = NULL;
10922 : : identifier name;
10923 : : identifier asname;
10924 : : int lineno;
10925 : : int col_offset;
10926 : : int end_lineno;
10927 : : int end_col_offset;
10928 : :
10929 [ - + ]: 1620 : if (_PyObject_LookupAttr(obj, state->name, &tmp) < 0) {
10930 : 0 : return 1;
10931 : : }
10932 [ - + ]: 1620 : if (tmp == NULL) {
10933 : 0 : PyErr_SetString(PyExc_TypeError, "required field \"name\" missing from alias");
10934 : 0 : return 1;
10935 : : }
10936 : : else {
10937 : : int res;
10938 [ - + ]: 1620 : if (_Py_EnterRecursiveCall(" while traversing 'alias' node")) {
10939 : 0 : goto failed;
10940 : : }
10941 : 1620 : res = obj2ast_identifier(state, tmp, &name, arena);
10942 : 1620 : _Py_LeaveRecursiveCall();
10943 [ - + ]: 1620 : if (res != 0) goto failed;
10944 [ + - ]: 1620 : Py_CLEAR(tmp);
10945 : : }
10946 [ - + ]: 1620 : if (_PyObject_LookupAttr(obj, state->asname, &tmp) < 0) {
10947 : 0 : return 1;
10948 : : }
10949 [ + - + + ]: 1620 : if (tmp == NULL || tmp == Py_None) {
10950 [ + - ]: 1481 : Py_CLEAR(tmp);
10951 : 1481 : asname = NULL;
10952 : : }
10953 : : else {
10954 : : int res;
10955 [ - + ]: 139 : if (_Py_EnterRecursiveCall(" while traversing 'alias' node")) {
10956 : 0 : goto failed;
10957 : : }
10958 : 139 : res = obj2ast_identifier(state, tmp, &asname, arena);
10959 : 139 : _Py_LeaveRecursiveCall();
10960 [ - + ]: 139 : if (res != 0) goto failed;
10961 [ + - ]: 139 : Py_CLEAR(tmp);
10962 : : }
10963 [ - + ]: 1620 : if (_PyObject_LookupAttr(obj, state->lineno, &tmp) < 0) {
10964 : 0 : return 1;
10965 : : }
10966 [ - + ]: 1620 : if (tmp == NULL) {
10967 : 0 : PyErr_SetString(PyExc_TypeError, "required field \"lineno\" missing from alias");
10968 : 0 : return 1;
10969 : : }
10970 : : else {
10971 : : int res;
10972 [ - + ]: 1620 : if (_Py_EnterRecursiveCall(" while traversing 'alias' node")) {
10973 : 0 : goto failed;
10974 : : }
10975 : 1620 : res = obj2ast_int(state, tmp, &lineno, arena);
10976 : 1620 : _Py_LeaveRecursiveCall();
10977 [ - + ]: 1620 : if (res != 0) goto failed;
10978 [ + - ]: 1620 : Py_CLEAR(tmp);
10979 : : }
10980 [ - + ]: 1620 : if (_PyObject_LookupAttr(obj, state->col_offset, &tmp) < 0) {
10981 : 0 : return 1;
10982 : : }
10983 [ - + ]: 1620 : if (tmp == NULL) {
10984 : 0 : PyErr_SetString(PyExc_TypeError, "required field \"col_offset\" missing from alias");
10985 : 0 : return 1;
10986 : : }
10987 : : else {
10988 : : int res;
10989 [ - + ]: 1620 : if (_Py_EnterRecursiveCall(" while traversing 'alias' node")) {
10990 : 0 : goto failed;
10991 : : }
10992 : 1620 : res = obj2ast_int(state, tmp, &col_offset, arena);
10993 : 1620 : _Py_LeaveRecursiveCall();
10994 [ - + ]: 1620 : if (res != 0) goto failed;
10995 [ + - ]: 1620 : Py_CLEAR(tmp);
10996 : : }
10997 [ - + ]: 1620 : if (_PyObject_LookupAttr(obj, state->end_lineno, &tmp) < 0) {
10998 : 0 : return 1;
10999 : : }
11000 [ + - + + ]: 1620 : if (tmp == NULL || tmp == Py_None) {
11001 [ + - ]: 3 : Py_CLEAR(tmp);
11002 : 3 : end_lineno = lineno;
11003 : : }
11004 : : else {
11005 : : int res;
11006 [ - + ]: 1617 : if (_Py_EnterRecursiveCall(" while traversing 'alias' node")) {
11007 : 0 : goto failed;
11008 : : }
11009 : 1617 : res = obj2ast_int(state, tmp, &end_lineno, arena);
11010 : 1617 : _Py_LeaveRecursiveCall();
11011 [ - + ]: 1617 : if (res != 0) goto failed;
11012 [ + - ]: 1617 : Py_CLEAR(tmp);
11013 : : }
11014 [ - + ]: 1620 : if (_PyObject_LookupAttr(obj, state->end_col_offset, &tmp) < 0) {
11015 : 0 : return 1;
11016 : : }
11017 [ + - + + ]: 1620 : if (tmp == NULL || tmp == Py_None) {
11018 [ + - ]: 3 : Py_CLEAR(tmp);
11019 : 3 : end_col_offset = col_offset;
11020 : : }
11021 : : else {
11022 : : int res;
11023 [ - + ]: 1617 : if (_Py_EnterRecursiveCall(" while traversing 'alias' node")) {
11024 : 0 : goto failed;
11025 : : }
11026 : 1617 : res = obj2ast_int(state, tmp, &end_col_offset, arena);
11027 : 1617 : _Py_LeaveRecursiveCall();
11028 [ - + ]: 1617 : if (res != 0) goto failed;
11029 [ + - ]: 1617 : Py_CLEAR(tmp);
11030 : : }
11031 : 1620 : *out = _PyAST_alias(name, asname, lineno, col_offset, end_lineno,
11032 : : end_col_offset, arena);
11033 : 1620 : return 0;
11034 : 0 : failed:
11035 : 0 : Py_XDECREF(tmp);
11036 : 0 : return 1;
11037 : : }
11038 : :
11039 : : int
11040 : 417 : obj2ast_withitem(struct ast_state *state, PyObject* obj, withitem_ty* out,
11041 : : PyArena* arena)
11042 : : {
11043 : 417 : PyObject* tmp = NULL;
11044 : : expr_ty context_expr;
11045 : : expr_ty optional_vars;
11046 : :
11047 [ - + ]: 417 : if (_PyObject_LookupAttr(obj, state->context_expr, &tmp) < 0) {
11048 : 0 : return 1;
11049 : : }
11050 [ - + ]: 417 : if (tmp == NULL) {
11051 : 0 : PyErr_SetString(PyExc_TypeError, "required field \"context_expr\" missing from withitem");
11052 : 0 : return 1;
11053 : : }
11054 : : else {
11055 : : int res;
11056 [ - + ]: 417 : if (_Py_EnterRecursiveCall(" while traversing 'withitem' node")) {
11057 : 0 : goto failed;
11058 : : }
11059 : 417 : res = obj2ast_expr(state, tmp, &context_expr, arena);
11060 : 417 : _Py_LeaveRecursiveCall();
11061 [ - + ]: 417 : if (res != 0) goto failed;
11062 [ + - ]: 417 : Py_CLEAR(tmp);
11063 : : }
11064 [ - + ]: 417 : if (_PyObject_LookupAttr(obj, state->optional_vars, &tmp) < 0) {
11065 : 0 : return 1;
11066 : : }
11067 [ + - + + ]: 417 : if (tmp == NULL || tmp == Py_None) {
11068 [ + - ]: 225 : Py_CLEAR(tmp);
11069 : 225 : optional_vars = NULL;
11070 : : }
11071 : : else {
11072 : : int res;
11073 [ - + ]: 192 : if (_Py_EnterRecursiveCall(" while traversing 'withitem' node")) {
11074 : 0 : goto failed;
11075 : : }
11076 : 192 : res = obj2ast_expr(state, tmp, &optional_vars, arena);
11077 : 192 : _Py_LeaveRecursiveCall();
11078 [ - + ]: 192 : if (res != 0) goto failed;
11079 [ + - ]: 192 : Py_CLEAR(tmp);
11080 : : }
11081 : 417 : *out = _PyAST_withitem(context_expr, optional_vars, arena);
11082 : 417 : return 0;
11083 : 0 : failed:
11084 : 0 : Py_XDECREF(tmp);
11085 : 0 : return 1;
11086 : : }
11087 : :
11088 : : int
11089 : 33 : obj2ast_match_case(struct ast_state *state, PyObject* obj, match_case_ty* out,
11090 : : PyArena* arena)
11091 : : {
11092 : 33 : PyObject* tmp = NULL;
11093 : : pattern_ty pattern;
11094 : : expr_ty guard;
11095 : : asdl_stmt_seq* body;
11096 : :
11097 [ - + ]: 33 : if (_PyObject_LookupAttr(obj, state->pattern, &tmp) < 0) {
11098 : 0 : return 1;
11099 : : }
11100 [ - + ]: 33 : if (tmp == NULL) {
11101 : 0 : PyErr_SetString(PyExc_TypeError, "required field \"pattern\" missing from match_case");
11102 : 0 : return 1;
11103 : : }
11104 : : else {
11105 : : int res;
11106 [ - + ]: 33 : if (_Py_EnterRecursiveCall(" while traversing 'match_case' node")) {
11107 : 0 : goto failed;
11108 : : }
11109 : 33 : res = obj2ast_pattern(state, tmp, &pattern, arena);
11110 : 33 : _Py_LeaveRecursiveCall();
11111 [ - + ]: 33 : if (res != 0) goto failed;
11112 [ + - ]: 33 : Py_CLEAR(tmp);
11113 : : }
11114 [ - + ]: 33 : if (_PyObject_LookupAttr(obj, state->guard, &tmp) < 0) {
11115 : 0 : return 1;
11116 : : }
11117 [ + - + + ]: 33 : if (tmp == NULL || tmp == Py_None) {
11118 [ + - ]: 32 : Py_CLEAR(tmp);
11119 : 32 : guard = NULL;
11120 : : }
11121 : : else {
11122 : : int res;
11123 [ - + ]: 1 : if (_Py_EnterRecursiveCall(" while traversing 'match_case' node")) {
11124 : 0 : goto failed;
11125 : : }
11126 : 1 : res = obj2ast_expr(state, tmp, &guard, arena);
11127 : 1 : _Py_LeaveRecursiveCall();
11128 [ - + ]: 1 : if (res != 0) goto failed;
11129 [ + - ]: 1 : Py_CLEAR(tmp);
11130 : : }
11131 [ - + ]: 33 : if (_PyObject_LookupAttr(obj, state->body, &tmp) < 0) {
11132 : 0 : return 1;
11133 : : }
11134 [ - + ]: 33 : if (tmp == NULL) {
11135 : 0 : PyErr_SetString(PyExc_TypeError, "required field \"body\" missing from match_case");
11136 : 0 : return 1;
11137 : : }
11138 : : else {
11139 : : int res;
11140 : : Py_ssize_t len;
11141 : : Py_ssize_t i;
11142 [ - + ]: 33 : if (!PyList_Check(tmp)) {
11143 : 0 : PyErr_Format(PyExc_TypeError, "match_case field \"body\" must be a list, not a %.200s", _PyType_Name(Py_TYPE(tmp)));
11144 : 0 : goto failed;
11145 : : }
11146 : 33 : len = PyList_GET_SIZE(tmp);
11147 : 33 : body = _Py_asdl_stmt_seq_new(len, arena);
11148 [ - + ]: 33 : if (body == NULL) goto failed;
11149 [ + + ]: 71 : for (i = 0; i < len; i++) {
11150 : : stmt_ty val;
11151 : 38 : PyObject *tmp2 = PyList_GET_ITEM(tmp, i);
11152 : 38 : Py_INCREF(tmp2);
11153 [ - + ]: 38 : if (_Py_EnterRecursiveCall(" while traversing 'match_case' node")) {
11154 : 0 : goto failed;
11155 : : }
11156 : 38 : res = obj2ast_stmt(state, tmp2, &val, arena);
11157 : 38 : _Py_LeaveRecursiveCall();
11158 : 38 : Py_DECREF(tmp2);
11159 [ - + ]: 38 : if (res != 0) goto failed;
11160 [ - + ]: 38 : if (len != PyList_GET_SIZE(tmp)) {
11161 : 0 : PyErr_SetString(PyExc_RuntimeError, "match_case field \"body\" changed size during iteration");
11162 : 0 : goto failed;
11163 : : }
11164 : 38 : asdl_seq_SET(body, i, val);
11165 : : }
11166 [ + - ]: 33 : Py_CLEAR(tmp);
11167 : : }
11168 : 33 : *out = _PyAST_match_case(pattern, guard, body, arena);
11169 : 33 : return 0;
11170 : 0 : failed:
11171 : 0 : Py_XDECREF(tmp);
11172 : 0 : return 1;
11173 : : }
11174 : :
11175 : : int
11176 : 54 : obj2ast_pattern(struct ast_state *state, PyObject* obj, pattern_ty* out,
11177 : : PyArena* arena)
11178 : : {
11179 : : int isinstance;
11180 : :
11181 : 54 : PyObject *tmp = NULL;
11182 : : PyObject *tp;
11183 : : int lineno;
11184 : : int col_offset;
11185 : : int end_lineno;
11186 : : int end_col_offset;
11187 : :
11188 [ - + ]: 54 : if (obj == Py_None) {
11189 : 0 : *out = NULL;
11190 : 0 : return 0;
11191 : : }
11192 [ - + ]: 54 : if (_PyObject_LookupAttr(obj, state->lineno, &tmp) < 0) {
11193 : 0 : return 1;
11194 : : }
11195 [ - + ]: 54 : if (tmp == NULL) {
11196 : 0 : PyErr_SetString(PyExc_TypeError, "required field \"lineno\" missing from pattern");
11197 : 0 : return 1;
11198 : : }
11199 : : else {
11200 : : int res;
11201 [ - + ]: 54 : if (_Py_EnterRecursiveCall(" while traversing 'pattern' node")) {
11202 : 0 : goto failed;
11203 : : }
11204 : 54 : res = obj2ast_int(state, tmp, &lineno, arena);
11205 : 54 : _Py_LeaveRecursiveCall();
11206 [ - + ]: 54 : if (res != 0) goto failed;
11207 [ + - ]: 54 : Py_CLEAR(tmp);
11208 : : }
11209 [ - + ]: 54 : if (_PyObject_LookupAttr(obj, state->col_offset, &tmp) < 0) {
11210 : 0 : return 1;
11211 : : }
11212 [ - + ]: 54 : if (tmp == NULL) {
11213 : 0 : PyErr_SetString(PyExc_TypeError, "required field \"col_offset\" missing from pattern");
11214 : 0 : return 1;
11215 : : }
11216 : : else {
11217 : : int res;
11218 [ - + ]: 54 : if (_Py_EnterRecursiveCall(" while traversing 'pattern' node")) {
11219 : 0 : goto failed;
11220 : : }
11221 : 54 : res = obj2ast_int(state, tmp, &col_offset, arena);
11222 : 54 : _Py_LeaveRecursiveCall();
11223 [ - + ]: 54 : if (res != 0) goto failed;
11224 [ + - ]: 54 : Py_CLEAR(tmp);
11225 : : }
11226 [ - + ]: 54 : if (_PyObject_LookupAttr(obj, state->end_lineno, &tmp) < 0) {
11227 : 0 : return 1;
11228 : : }
11229 [ - + ]: 54 : if (tmp == NULL) {
11230 : 0 : PyErr_SetString(PyExc_TypeError, "required field \"end_lineno\" missing from pattern");
11231 : 0 : return 1;
11232 : : }
11233 : : else {
11234 : : int res;
11235 [ - + ]: 54 : if (_Py_EnterRecursiveCall(" while traversing 'pattern' node")) {
11236 : 0 : goto failed;
11237 : : }
11238 : 54 : res = obj2ast_int(state, tmp, &end_lineno, arena);
11239 : 54 : _Py_LeaveRecursiveCall();
11240 [ - + ]: 54 : if (res != 0) goto failed;
11241 [ + - ]: 54 : Py_CLEAR(tmp);
11242 : : }
11243 [ - + ]: 54 : if (_PyObject_LookupAttr(obj, state->end_col_offset, &tmp) < 0) {
11244 : 0 : return 1;
11245 : : }
11246 [ - + ]: 54 : if (tmp == NULL) {
11247 : 0 : PyErr_SetString(PyExc_TypeError, "required field \"end_col_offset\" missing from pattern");
11248 : 0 : return 1;
11249 : : }
11250 : : else {
11251 : : int res;
11252 [ - + ]: 54 : if (_Py_EnterRecursiveCall(" while traversing 'pattern' node")) {
11253 : 0 : goto failed;
11254 : : }
11255 : 54 : res = obj2ast_int(state, tmp, &end_col_offset, arena);
11256 : 54 : _Py_LeaveRecursiveCall();
11257 [ - + ]: 54 : if (res != 0) goto failed;
11258 [ + - ]: 54 : Py_CLEAR(tmp);
11259 : : }
11260 : 54 : tp = state->MatchValue_type;
11261 : 54 : isinstance = PyObject_IsInstance(obj, tp);
11262 [ - + ]: 54 : if (isinstance == -1) {
11263 : 0 : return 1;
11264 : : }
11265 [ + + ]: 54 : if (isinstance) {
11266 : : expr_ty value;
11267 : :
11268 [ - + ]: 15 : if (_PyObject_LookupAttr(obj, state->value, &tmp) < 0) {
11269 : 15 : return 1;
11270 : : }
11271 [ - + ]: 15 : if (tmp == NULL) {
11272 : 0 : PyErr_SetString(PyExc_TypeError, "required field \"value\" missing from MatchValue");
11273 : 0 : return 1;
11274 : : }
11275 : : else {
11276 : : int res;
11277 [ - + ]: 15 : if (_Py_EnterRecursiveCall(" while traversing 'MatchValue' node")) {
11278 : 0 : goto failed;
11279 : : }
11280 : 15 : res = obj2ast_expr(state, tmp, &value, arena);
11281 : 15 : _Py_LeaveRecursiveCall();
11282 [ - + ]: 15 : if (res != 0) goto failed;
11283 [ + - ]: 15 : Py_CLEAR(tmp);
11284 : : }
11285 : 15 : *out = _PyAST_MatchValue(value, lineno, col_offset, end_lineno,
11286 : : end_col_offset, arena);
11287 [ - + ]: 15 : if (*out == NULL) goto failed;
11288 : 15 : return 0;
11289 : : }
11290 : 39 : tp = state->MatchSingleton_type;
11291 : 39 : isinstance = PyObject_IsInstance(obj, tp);
11292 [ - + ]: 39 : if (isinstance == -1) {
11293 : 0 : return 1;
11294 : : }
11295 [ + + ]: 39 : if (isinstance) {
11296 : : constant value;
11297 : :
11298 [ - + ]: 6 : if (_PyObject_LookupAttr(obj, state->value, &tmp) < 0) {
11299 : 6 : return 1;
11300 : : }
11301 [ - + ]: 6 : if (tmp == NULL) {
11302 : 0 : PyErr_SetString(PyExc_TypeError, "required field \"value\" missing from MatchSingleton");
11303 : 0 : return 1;
11304 : : }
11305 : : else {
11306 : : int res;
11307 [ - + ]: 6 : if (_Py_EnterRecursiveCall(" while traversing 'MatchSingleton' node")) {
11308 : 0 : goto failed;
11309 : : }
11310 : 6 : res = obj2ast_constant(state, tmp, &value, arena);
11311 : 6 : _Py_LeaveRecursiveCall();
11312 [ - + ]: 6 : if (res != 0) goto failed;
11313 [ + - ]: 6 : Py_CLEAR(tmp);
11314 : : }
11315 : 6 : *out = _PyAST_MatchSingleton(value, lineno, col_offset, end_lineno,
11316 : : end_col_offset, arena);
11317 [ - + ]: 6 : if (*out == NULL) goto failed;
11318 : 6 : return 0;
11319 : : }
11320 : 33 : tp = state->MatchSequence_type;
11321 : 33 : isinstance = PyObject_IsInstance(obj, tp);
11322 [ - + ]: 33 : if (isinstance == -1) {
11323 : 0 : return 1;
11324 : : }
11325 [ + + ]: 33 : if (isinstance) {
11326 : : asdl_pattern_seq* patterns;
11327 : :
11328 [ - + ]: 5 : if (_PyObject_LookupAttr(obj, state->patterns, &tmp) < 0) {
11329 : 0 : return 1;
11330 : : }
11331 [ - + ]: 5 : if (tmp == NULL) {
11332 : 0 : PyErr_SetString(PyExc_TypeError, "required field \"patterns\" missing from MatchSequence");
11333 : 0 : return 1;
11334 : : }
11335 : : else {
11336 : : int res;
11337 : : Py_ssize_t len;
11338 : : Py_ssize_t i;
11339 [ - + ]: 5 : if (!PyList_Check(tmp)) {
11340 : 0 : PyErr_Format(PyExc_TypeError, "MatchSequence field \"patterns\" must be a list, not a %.200s", _PyType_Name(Py_TYPE(tmp)));
11341 : 0 : goto failed;
11342 : : }
11343 : 5 : len = PyList_GET_SIZE(tmp);
11344 : 5 : patterns = _Py_asdl_pattern_seq_new(len, arena);
11345 [ - + ]: 5 : if (patterns == NULL) goto failed;
11346 [ + + ]: 10 : for (i = 0; i < len; i++) {
11347 : : pattern_ty val;
11348 : 5 : PyObject *tmp2 = PyList_GET_ITEM(tmp, i);
11349 : 5 : Py_INCREF(tmp2);
11350 [ - + ]: 5 : if (_Py_EnterRecursiveCall(" while traversing 'MatchSequence' node")) {
11351 : 0 : goto failed;
11352 : : }
11353 : 5 : res = obj2ast_pattern(state, tmp2, &val, arena);
11354 : 5 : _Py_LeaveRecursiveCall();
11355 : 5 : Py_DECREF(tmp2);
11356 [ - + ]: 5 : if (res != 0) goto failed;
11357 [ - + ]: 5 : if (len != PyList_GET_SIZE(tmp)) {
11358 : 0 : PyErr_SetString(PyExc_RuntimeError, "MatchSequence field \"patterns\" changed size during iteration");
11359 : 0 : goto failed;
11360 : : }
11361 : 5 : asdl_seq_SET(patterns, i, val);
11362 : : }
11363 [ + - ]: 5 : Py_CLEAR(tmp);
11364 : : }
11365 : 5 : *out = _PyAST_MatchSequence(patterns, lineno, col_offset, end_lineno,
11366 : : end_col_offset, arena);
11367 [ - + ]: 5 : if (*out == NULL) goto failed;
11368 : 5 : return 0;
11369 : : }
11370 : 28 : tp = state->MatchMapping_type;
11371 : 28 : isinstance = PyObject_IsInstance(obj, tp);
11372 [ - + ]: 28 : if (isinstance == -1) {
11373 : 0 : return 1;
11374 : : }
11375 [ + + ]: 28 : if (isinstance) {
11376 : : asdl_expr_seq* keys;
11377 : : asdl_pattern_seq* patterns;
11378 : : identifier rest;
11379 : :
11380 [ - + ]: 4 : if (_PyObject_LookupAttr(obj, state->keys, &tmp) < 0) {
11381 : 4 : return 1;
11382 : : }
11383 [ - + ]: 4 : if (tmp == NULL) {
11384 : 0 : PyErr_SetString(PyExc_TypeError, "required field \"keys\" missing from MatchMapping");
11385 : 0 : return 1;
11386 : : }
11387 : : else {
11388 : : int res;
11389 : : Py_ssize_t len;
11390 : : Py_ssize_t i;
11391 [ - + ]: 4 : if (!PyList_Check(tmp)) {
11392 : 0 : PyErr_Format(PyExc_TypeError, "MatchMapping field \"keys\" must be a list, not a %.200s", _PyType_Name(Py_TYPE(tmp)));
11393 : 0 : goto failed;
11394 : : }
11395 : 4 : len = PyList_GET_SIZE(tmp);
11396 : 4 : keys = _Py_asdl_expr_seq_new(len, arena);
11397 [ - + ]: 4 : if (keys == NULL) goto failed;
11398 [ + + ]: 10 : for (i = 0; i < len; i++) {
11399 : : expr_ty val;
11400 : 6 : PyObject *tmp2 = PyList_GET_ITEM(tmp, i);
11401 : 6 : Py_INCREF(tmp2);
11402 [ - + ]: 6 : if (_Py_EnterRecursiveCall(" while traversing 'MatchMapping' node")) {
11403 : 0 : goto failed;
11404 : : }
11405 : 6 : res = obj2ast_expr(state, tmp2, &val, arena);
11406 : 6 : _Py_LeaveRecursiveCall();
11407 : 6 : Py_DECREF(tmp2);
11408 [ - + ]: 6 : if (res != 0) goto failed;
11409 [ - + ]: 6 : if (len != PyList_GET_SIZE(tmp)) {
11410 : 0 : PyErr_SetString(PyExc_RuntimeError, "MatchMapping field \"keys\" changed size during iteration");
11411 : 0 : goto failed;
11412 : : }
11413 : 6 : asdl_seq_SET(keys, i, val);
11414 : : }
11415 [ + - ]: 4 : Py_CLEAR(tmp);
11416 : : }
11417 [ - + ]: 4 : if (_PyObject_LookupAttr(obj, state->patterns, &tmp) < 0) {
11418 : 0 : return 1;
11419 : : }
11420 [ - + ]: 4 : if (tmp == NULL) {
11421 : 0 : PyErr_SetString(PyExc_TypeError, "required field \"patterns\" missing from MatchMapping");
11422 : 0 : return 1;
11423 : : }
11424 : : else {
11425 : : int res;
11426 : : Py_ssize_t len;
11427 : : Py_ssize_t i;
11428 [ - + ]: 4 : if (!PyList_Check(tmp)) {
11429 : 0 : PyErr_Format(PyExc_TypeError, "MatchMapping field \"patterns\" must be a list, not a %.200s", _PyType_Name(Py_TYPE(tmp)));
11430 : 0 : goto failed;
11431 : : }
11432 : 4 : len = PyList_GET_SIZE(tmp);
11433 : 4 : patterns = _Py_asdl_pattern_seq_new(len, arena);
11434 [ - + ]: 4 : if (patterns == NULL) goto failed;
11435 [ + + ]: 9 : for (i = 0; i < len; i++) {
11436 : : pattern_ty val;
11437 : 5 : PyObject *tmp2 = PyList_GET_ITEM(tmp, i);
11438 : 5 : Py_INCREF(tmp2);
11439 [ - + ]: 5 : if (_Py_EnterRecursiveCall(" while traversing 'MatchMapping' node")) {
11440 : 0 : goto failed;
11441 : : }
11442 : 5 : res = obj2ast_pattern(state, tmp2, &val, arena);
11443 : 5 : _Py_LeaveRecursiveCall();
11444 : 5 : Py_DECREF(tmp2);
11445 [ - + ]: 5 : if (res != 0) goto failed;
11446 [ - + ]: 5 : if (len != PyList_GET_SIZE(tmp)) {
11447 : 0 : PyErr_SetString(PyExc_RuntimeError, "MatchMapping field \"patterns\" changed size during iteration");
11448 : 0 : goto failed;
11449 : : }
11450 : 5 : asdl_seq_SET(patterns, i, val);
11451 : : }
11452 [ + - ]: 4 : Py_CLEAR(tmp);
11453 : : }
11454 [ - + ]: 4 : if (_PyObject_LookupAttr(obj, state->rest, &tmp) < 0) {
11455 : 0 : return 1;
11456 : : }
11457 [ + - + + ]: 4 : if (tmp == NULL || tmp == Py_None) {
11458 [ + - ]: 1 : Py_CLEAR(tmp);
11459 : 1 : rest = NULL;
11460 : : }
11461 : : else {
11462 : : int res;
11463 [ - + ]: 3 : if (_Py_EnterRecursiveCall(" while traversing 'MatchMapping' node")) {
11464 : 0 : goto failed;
11465 : : }
11466 : 3 : res = obj2ast_identifier(state, tmp, &rest, arena);
11467 : 3 : _Py_LeaveRecursiveCall();
11468 [ - + ]: 3 : if (res != 0) goto failed;
11469 [ + - ]: 3 : Py_CLEAR(tmp);
11470 : : }
11471 : 4 : *out = _PyAST_MatchMapping(keys, patterns, rest, lineno, col_offset,
11472 : : end_lineno, end_col_offset, arena);
11473 [ - + ]: 4 : if (*out == NULL) goto failed;
11474 : 4 : return 0;
11475 : : }
11476 : 24 : tp = state->MatchClass_type;
11477 : 24 : isinstance = PyObject_IsInstance(obj, tp);
11478 [ - + ]: 24 : if (isinstance == -1) {
11479 : 0 : return 1;
11480 : : }
11481 [ + + ]: 24 : if (isinstance) {
11482 : : expr_ty cls;
11483 : : asdl_pattern_seq* patterns;
11484 : : asdl_identifier_seq* kwd_attrs;
11485 : : asdl_pattern_seq* kwd_patterns;
11486 : :
11487 [ - + ]: 10 : if (_PyObject_LookupAttr(obj, state->cls, &tmp) < 0) {
11488 : 10 : return 1;
11489 : : }
11490 [ - + ]: 10 : if (tmp == NULL) {
11491 : 0 : PyErr_SetString(PyExc_TypeError, "required field \"cls\" missing from MatchClass");
11492 : 0 : return 1;
11493 : : }
11494 : : else {
11495 : : int res;
11496 [ - + ]: 10 : if (_Py_EnterRecursiveCall(" while traversing 'MatchClass' node")) {
11497 : 0 : goto failed;
11498 : : }
11499 : 10 : res = obj2ast_expr(state, tmp, &cls, arena);
11500 : 10 : _Py_LeaveRecursiveCall();
11501 [ - + ]: 10 : if (res != 0) goto failed;
11502 [ + - ]: 10 : Py_CLEAR(tmp);
11503 : : }
11504 [ - + ]: 10 : if (_PyObject_LookupAttr(obj, state->patterns, &tmp) < 0) {
11505 : 0 : return 1;
11506 : : }
11507 [ - + ]: 10 : if (tmp == NULL) {
11508 : 0 : PyErr_SetString(PyExc_TypeError, "required field \"patterns\" missing from MatchClass");
11509 : 0 : return 1;
11510 : : }
11511 : : else {
11512 : : int res;
11513 : : Py_ssize_t len;
11514 : : Py_ssize_t i;
11515 [ - + ]: 10 : if (!PyList_Check(tmp)) {
11516 : 0 : PyErr_Format(PyExc_TypeError, "MatchClass field \"patterns\" must be a list, not a %.200s", _PyType_Name(Py_TYPE(tmp)));
11517 : 0 : goto failed;
11518 : : }
11519 : 10 : len = PyList_GET_SIZE(tmp);
11520 : 10 : patterns = _Py_asdl_pattern_seq_new(len, arena);
11521 [ - + ]: 10 : if (patterns == NULL) goto failed;
11522 [ + + ]: 14 : for (i = 0; i < len; i++) {
11523 : : pattern_ty val;
11524 : 4 : PyObject *tmp2 = PyList_GET_ITEM(tmp, i);
11525 : 4 : Py_INCREF(tmp2);
11526 [ - + ]: 4 : if (_Py_EnterRecursiveCall(" while traversing 'MatchClass' node")) {
11527 : 0 : goto failed;
11528 : : }
11529 : 4 : res = obj2ast_pattern(state, tmp2, &val, arena);
11530 : 4 : _Py_LeaveRecursiveCall();
11531 : 4 : Py_DECREF(tmp2);
11532 [ - + ]: 4 : if (res != 0) goto failed;
11533 [ - + ]: 4 : if (len != PyList_GET_SIZE(tmp)) {
11534 : 0 : PyErr_SetString(PyExc_RuntimeError, "MatchClass field \"patterns\" changed size during iteration");
11535 : 0 : goto failed;
11536 : : }
11537 : 4 : asdl_seq_SET(patterns, i, val);
11538 : : }
11539 [ + - ]: 10 : Py_CLEAR(tmp);
11540 : : }
11541 [ - + ]: 10 : if (_PyObject_LookupAttr(obj, state->kwd_attrs, &tmp) < 0) {
11542 : 0 : return 1;
11543 : : }
11544 [ - + ]: 10 : if (tmp == NULL) {
11545 : 0 : PyErr_SetString(PyExc_TypeError, "required field \"kwd_attrs\" missing from MatchClass");
11546 : 0 : return 1;
11547 : : }
11548 : : else {
11549 : : int res;
11550 : : Py_ssize_t len;
11551 : : Py_ssize_t i;
11552 [ - + ]: 10 : if (!PyList_Check(tmp)) {
11553 : 0 : PyErr_Format(PyExc_TypeError, "MatchClass field \"kwd_attrs\" must be a list, not a %.200s", _PyType_Name(Py_TYPE(tmp)));
11554 : 0 : goto failed;
11555 : : }
11556 : 10 : len = PyList_GET_SIZE(tmp);
11557 : 10 : kwd_attrs = _Py_asdl_identifier_seq_new(len, arena);
11558 [ - + ]: 10 : if (kwd_attrs == NULL) goto failed;
11559 [ + + ]: 11 : for (i = 0; i < len; i++) {
11560 : : identifier val;
11561 : 1 : PyObject *tmp2 = PyList_GET_ITEM(tmp, i);
11562 : 1 : Py_INCREF(tmp2);
11563 [ - + ]: 1 : if (_Py_EnterRecursiveCall(" while traversing 'MatchClass' node")) {
11564 : 0 : goto failed;
11565 : : }
11566 : 1 : res = obj2ast_identifier(state, tmp2, &val, arena);
11567 : 1 : _Py_LeaveRecursiveCall();
11568 : 1 : Py_DECREF(tmp2);
11569 [ - + ]: 1 : if (res != 0) goto failed;
11570 [ - + ]: 1 : if (len != PyList_GET_SIZE(tmp)) {
11571 : 0 : PyErr_SetString(PyExc_RuntimeError, "MatchClass field \"kwd_attrs\" changed size during iteration");
11572 : 0 : goto failed;
11573 : : }
11574 : 1 : asdl_seq_SET(kwd_attrs, i, val);
11575 : : }
11576 [ + - ]: 10 : Py_CLEAR(tmp);
11577 : : }
11578 [ - + ]: 10 : if (_PyObject_LookupAttr(obj, state->kwd_patterns, &tmp) < 0) {
11579 : 0 : return 1;
11580 : : }
11581 [ - + ]: 10 : if (tmp == NULL) {
11582 : 0 : PyErr_SetString(PyExc_TypeError, "required field \"kwd_patterns\" missing from MatchClass");
11583 : 0 : return 1;
11584 : : }
11585 : : else {
11586 : : int res;
11587 : : Py_ssize_t len;
11588 : : Py_ssize_t i;
11589 [ - + ]: 10 : if (!PyList_Check(tmp)) {
11590 : 0 : PyErr_Format(PyExc_TypeError, "MatchClass field \"kwd_patterns\" must be a list, not a %.200s", _PyType_Name(Py_TYPE(tmp)));
11591 : 0 : goto failed;
11592 : : }
11593 : 10 : len = PyList_GET_SIZE(tmp);
11594 : 10 : kwd_patterns = _Py_asdl_pattern_seq_new(len, arena);
11595 [ - + ]: 10 : if (kwd_patterns == NULL) goto failed;
11596 [ + + ]: 13 : for (i = 0; i < len; i++) {
11597 : : pattern_ty val;
11598 : 3 : PyObject *tmp2 = PyList_GET_ITEM(tmp, i);
11599 : 3 : Py_INCREF(tmp2);
11600 [ - + ]: 3 : if (_Py_EnterRecursiveCall(" while traversing 'MatchClass' node")) {
11601 : 0 : goto failed;
11602 : : }
11603 : 3 : res = obj2ast_pattern(state, tmp2, &val, arena);
11604 : 3 : _Py_LeaveRecursiveCall();
11605 : 3 : Py_DECREF(tmp2);
11606 [ - + ]: 3 : if (res != 0) goto failed;
11607 [ - + ]: 3 : if (len != PyList_GET_SIZE(tmp)) {
11608 : 0 : PyErr_SetString(PyExc_RuntimeError, "MatchClass field \"kwd_patterns\" changed size during iteration");
11609 : 0 : goto failed;
11610 : : }
11611 : 3 : asdl_seq_SET(kwd_patterns, i, val);
11612 : : }
11613 [ + - ]: 10 : Py_CLEAR(tmp);
11614 : : }
11615 : 10 : *out = _PyAST_MatchClass(cls, patterns, kwd_attrs, kwd_patterns,
11616 : : lineno, col_offset, end_lineno,
11617 : : end_col_offset, arena);
11618 [ - + ]: 10 : if (*out == NULL) goto failed;
11619 : 10 : return 0;
11620 : : }
11621 : 14 : tp = state->MatchStar_type;
11622 : 14 : isinstance = PyObject_IsInstance(obj, tp);
11623 [ - + ]: 14 : if (isinstance == -1) {
11624 : 0 : return 1;
11625 : : }
11626 [ + + ]: 14 : if (isinstance) {
11627 : : identifier name;
11628 : :
11629 [ - + ]: 5 : if (_PyObject_LookupAttr(obj, state->name, &tmp) < 0) {
11630 : 5 : return 1;
11631 : : }
11632 [ + - + + ]: 5 : if (tmp == NULL || tmp == Py_None) {
11633 [ + - ]: 2 : Py_CLEAR(tmp);
11634 : 2 : name = NULL;
11635 : : }
11636 : : else {
11637 : : int res;
11638 [ - + ]: 3 : if (_Py_EnterRecursiveCall(" while traversing 'MatchStar' node")) {
11639 : 0 : goto failed;
11640 : : }
11641 : 3 : res = obj2ast_identifier(state, tmp, &name, arena);
11642 : 3 : _Py_LeaveRecursiveCall();
11643 [ - + ]: 3 : if (res != 0) goto failed;
11644 [ + - ]: 3 : Py_CLEAR(tmp);
11645 : : }
11646 : 5 : *out = _PyAST_MatchStar(name, lineno, col_offset, end_lineno,
11647 : : end_col_offset, arena);
11648 [ - + ]: 5 : if (*out == NULL) goto failed;
11649 : 5 : return 0;
11650 : : }
11651 : 9 : tp = state->MatchAs_type;
11652 : 9 : isinstance = PyObject_IsInstance(obj, tp);
11653 [ - + ]: 9 : if (isinstance == -1) {
11654 : 0 : return 1;
11655 : : }
11656 [ + + ]: 9 : if (isinstance) {
11657 : : pattern_ty pattern;
11658 : : identifier name;
11659 : :
11660 [ - + ]: 6 : if (_PyObject_LookupAttr(obj, state->pattern, &tmp) < 0) {
11661 : 6 : return 1;
11662 : : }
11663 [ + - + - ]: 6 : if (tmp == NULL || tmp == Py_None) {
11664 [ + - ]: 6 : Py_CLEAR(tmp);
11665 : 6 : pattern = NULL;
11666 : : }
11667 : : else {
11668 : : int res;
11669 [ # # ]: 0 : if (_Py_EnterRecursiveCall(" while traversing 'MatchAs' node")) {
11670 : 0 : goto failed;
11671 : : }
11672 : 0 : res = obj2ast_pattern(state, tmp, &pattern, arena);
11673 : 0 : _Py_LeaveRecursiveCall();
11674 [ # # ]: 0 : if (res != 0) goto failed;
11675 [ # # ]: 0 : Py_CLEAR(tmp);
11676 : : }
11677 [ - + ]: 6 : if (_PyObject_LookupAttr(obj, state->name, &tmp) < 0) {
11678 : 0 : return 1;
11679 : : }
11680 [ + - + + ]: 6 : if (tmp == NULL || tmp == Py_None) {
11681 [ + - ]: 1 : Py_CLEAR(tmp);
11682 : 1 : name = NULL;
11683 : : }
11684 : : else {
11685 : : int res;
11686 [ - + ]: 5 : if (_Py_EnterRecursiveCall(" while traversing 'MatchAs' node")) {
11687 : 0 : goto failed;
11688 : : }
11689 : 5 : res = obj2ast_identifier(state, tmp, &name, arena);
11690 : 5 : _Py_LeaveRecursiveCall();
11691 [ - + ]: 5 : if (res != 0) goto failed;
11692 [ + - ]: 5 : Py_CLEAR(tmp);
11693 : : }
11694 : 6 : *out = _PyAST_MatchAs(pattern, name, lineno, col_offset, end_lineno,
11695 : : end_col_offset, arena);
11696 [ - + ]: 6 : if (*out == NULL) goto failed;
11697 : 6 : return 0;
11698 : : }
11699 : 3 : tp = state->MatchOr_type;
11700 : 3 : isinstance = PyObject_IsInstance(obj, tp);
11701 [ - + ]: 3 : if (isinstance == -1) {
11702 : 0 : return 1;
11703 : : }
11704 [ + - ]: 3 : if (isinstance) {
11705 : : asdl_pattern_seq* patterns;
11706 : :
11707 [ - + ]: 3 : if (_PyObject_LookupAttr(obj, state->patterns, &tmp) < 0) {
11708 : 0 : return 1;
11709 : : }
11710 [ - + ]: 3 : if (tmp == NULL) {
11711 : 0 : PyErr_SetString(PyExc_TypeError, "required field \"patterns\" missing from MatchOr");
11712 : 0 : return 1;
11713 : : }
11714 : : else {
11715 : : int res;
11716 : : Py_ssize_t len;
11717 : : Py_ssize_t i;
11718 [ - + ]: 3 : if (!PyList_Check(tmp)) {
11719 : 0 : PyErr_Format(PyExc_TypeError, "MatchOr field \"patterns\" must be a list, not a %.200s", _PyType_Name(Py_TYPE(tmp)));
11720 : 0 : goto failed;
11721 : : }
11722 : 3 : len = PyList_GET_SIZE(tmp);
11723 : 3 : patterns = _Py_asdl_pattern_seq_new(len, arena);
11724 [ - + ]: 3 : if (patterns == NULL) goto failed;
11725 [ + + ]: 7 : for (i = 0; i < len; i++) {
11726 : : pattern_ty val;
11727 : 4 : PyObject *tmp2 = PyList_GET_ITEM(tmp, i);
11728 : 4 : Py_INCREF(tmp2);
11729 [ - + ]: 4 : if (_Py_EnterRecursiveCall(" while traversing 'MatchOr' node")) {
11730 : 0 : goto failed;
11731 : : }
11732 : 4 : res = obj2ast_pattern(state, tmp2, &val, arena);
11733 : 4 : _Py_LeaveRecursiveCall();
11734 : 4 : Py_DECREF(tmp2);
11735 [ - + ]: 4 : if (res != 0) goto failed;
11736 [ - + ]: 4 : if (len != PyList_GET_SIZE(tmp)) {
11737 : 0 : PyErr_SetString(PyExc_RuntimeError, "MatchOr field \"patterns\" changed size during iteration");
11738 : 0 : goto failed;
11739 : : }
11740 : 4 : asdl_seq_SET(patterns, i, val);
11741 : : }
11742 [ + - ]: 3 : Py_CLEAR(tmp);
11743 : : }
11744 : 3 : *out = _PyAST_MatchOr(patterns, lineno, col_offset, end_lineno,
11745 : : end_col_offset, arena);
11746 [ - + ]: 3 : if (*out == NULL) goto failed;
11747 : 3 : return 0;
11748 : : }
11749 : :
11750 : 0 : PyErr_Format(PyExc_TypeError, "expected some sort of pattern, but got %R", obj);
11751 : 0 : failed:
11752 : 0 : Py_XDECREF(tmp);
11753 : 0 : return 1;
11754 : : }
11755 : :
11756 : : int
11757 : 0 : obj2ast_type_ignore(struct ast_state *state, PyObject* obj, type_ignore_ty*
11758 : : out, PyArena* arena)
11759 : : {
11760 : : int isinstance;
11761 : :
11762 : 0 : PyObject *tmp = NULL;
11763 : : PyObject *tp;
11764 : :
11765 [ # # ]: 0 : if (obj == Py_None) {
11766 : 0 : *out = NULL;
11767 : 0 : return 0;
11768 : : }
11769 : 0 : tp = state->TypeIgnore_type;
11770 : 0 : isinstance = PyObject_IsInstance(obj, tp);
11771 [ # # ]: 0 : if (isinstance == -1) {
11772 : 0 : return 1;
11773 : : }
11774 [ # # ]: 0 : if (isinstance) {
11775 : : int lineno;
11776 : : string tag;
11777 : :
11778 [ # # ]: 0 : if (_PyObject_LookupAttr(obj, state->lineno, &tmp) < 0) {
11779 : 0 : return 1;
11780 : : }
11781 [ # # ]: 0 : if (tmp == NULL) {
11782 : 0 : PyErr_SetString(PyExc_TypeError, "required field \"lineno\" missing from TypeIgnore");
11783 : 0 : return 1;
11784 : : }
11785 : : else {
11786 : : int res;
11787 [ # # ]: 0 : if (_Py_EnterRecursiveCall(" while traversing 'TypeIgnore' node")) {
11788 : 0 : goto failed;
11789 : : }
11790 : 0 : res = obj2ast_int(state, tmp, &lineno, arena);
11791 : 0 : _Py_LeaveRecursiveCall();
11792 [ # # ]: 0 : if (res != 0) goto failed;
11793 [ # # ]: 0 : Py_CLEAR(tmp);
11794 : : }
11795 [ # # ]: 0 : if (_PyObject_LookupAttr(obj, state->tag, &tmp) < 0) {
11796 : 0 : return 1;
11797 : : }
11798 [ # # ]: 0 : if (tmp == NULL) {
11799 : 0 : PyErr_SetString(PyExc_TypeError, "required field \"tag\" missing from TypeIgnore");
11800 : 0 : return 1;
11801 : : }
11802 : : else {
11803 : : int res;
11804 [ # # ]: 0 : if (_Py_EnterRecursiveCall(" while traversing 'TypeIgnore' node")) {
11805 : 0 : goto failed;
11806 : : }
11807 : 0 : res = obj2ast_string(state, tmp, &tag, arena);
11808 : 0 : _Py_LeaveRecursiveCall();
11809 [ # # ]: 0 : if (res != 0) goto failed;
11810 [ # # ]: 0 : Py_CLEAR(tmp);
11811 : : }
11812 : 0 : *out = _PyAST_TypeIgnore(lineno, tag, arena);
11813 [ # # ]: 0 : if (*out == NULL) goto failed;
11814 : 0 : return 0;
11815 : : }
11816 : :
11817 : 0 : PyErr_Format(PyExc_TypeError, "expected some sort of type_ignore, but got %R", obj);
11818 : 0 : failed:
11819 : 0 : Py_XDECREF(tmp);
11820 : 0 : return 1;
11821 : : }
11822 : :
11823 : :
11824 : : static int
11825 : 1309 : astmodule_exec(PyObject *m)
11826 : : {
11827 : 1309 : struct ast_state *state = get_ast_state();
11828 [ - + ]: 1309 : if (state == NULL) {
11829 : 0 : return -1;
11830 : : }
11831 [ - + ]: 1309 : if (PyModule_AddObjectRef(m, "AST", state->AST_type) < 0) {
11832 : 0 : return -1;
11833 : : }
11834 [ - + ]: 1309 : if (PyModule_AddIntMacro(m, PyCF_ALLOW_TOP_LEVEL_AWAIT) < 0) {
11835 : 0 : return -1;
11836 : : }
11837 [ - + ]: 1309 : if (PyModule_AddIntMacro(m, PyCF_ONLY_AST) < 0) {
11838 : 0 : return -1;
11839 : : }
11840 [ - + ]: 1309 : if (PyModule_AddIntMacro(m, PyCF_TYPE_COMMENTS) < 0) {
11841 : 0 : return -1;
11842 : : }
11843 [ - + ]: 1309 : if (PyModule_AddObjectRef(m, "mod", state->mod_type) < 0) {
11844 : 0 : return -1;
11845 : : }
11846 [ - + ]: 1309 : if (PyModule_AddObjectRef(m, "Module", state->Module_type) < 0) {
11847 : 0 : return -1;
11848 : : }
11849 [ - + ]: 1309 : if (PyModule_AddObjectRef(m, "Interactive", state->Interactive_type) < 0) {
11850 : 0 : return -1;
11851 : : }
11852 [ - + ]: 1309 : if (PyModule_AddObjectRef(m, "Expression", state->Expression_type) < 0) {
11853 : 0 : return -1;
11854 : : }
11855 [ - + ]: 1309 : if (PyModule_AddObjectRef(m, "FunctionType", state->FunctionType_type) < 0)
11856 : : {
11857 : 0 : return -1;
11858 : : }
11859 [ - + ]: 1309 : if (PyModule_AddObjectRef(m, "stmt", state->stmt_type) < 0) {
11860 : 0 : return -1;
11861 : : }
11862 [ - + ]: 1309 : if (PyModule_AddObjectRef(m, "FunctionDef", state->FunctionDef_type) < 0) {
11863 : 0 : return -1;
11864 : : }
11865 [ - + ]: 1309 : if (PyModule_AddObjectRef(m, "AsyncFunctionDef",
11866 : : state->AsyncFunctionDef_type) < 0) {
11867 : 0 : return -1;
11868 : : }
11869 [ - + ]: 1309 : if (PyModule_AddObjectRef(m, "ClassDef", state->ClassDef_type) < 0) {
11870 : 0 : return -1;
11871 : : }
11872 [ - + ]: 1309 : if (PyModule_AddObjectRef(m, "Return", state->Return_type) < 0) {
11873 : 0 : return -1;
11874 : : }
11875 [ - + ]: 1309 : if (PyModule_AddObjectRef(m, "Delete", state->Delete_type) < 0) {
11876 : 0 : return -1;
11877 : : }
11878 [ - + ]: 1309 : if (PyModule_AddObjectRef(m, "Assign", state->Assign_type) < 0) {
11879 : 0 : return -1;
11880 : : }
11881 [ - + ]: 1309 : if (PyModule_AddObjectRef(m, "AugAssign", state->AugAssign_type) < 0) {
11882 : 0 : return -1;
11883 : : }
11884 [ - + ]: 1309 : if (PyModule_AddObjectRef(m, "AnnAssign", state->AnnAssign_type) < 0) {
11885 : 0 : return -1;
11886 : : }
11887 [ - + ]: 1309 : if (PyModule_AddObjectRef(m, "For", state->For_type) < 0) {
11888 : 0 : return -1;
11889 : : }
11890 [ - + ]: 1309 : if (PyModule_AddObjectRef(m, "AsyncFor", state->AsyncFor_type) < 0) {
11891 : 0 : return -1;
11892 : : }
11893 [ - + ]: 1309 : if (PyModule_AddObjectRef(m, "While", state->While_type) < 0) {
11894 : 0 : return -1;
11895 : : }
11896 [ - + ]: 1309 : if (PyModule_AddObjectRef(m, "If", state->If_type) < 0) {
11897 : 0 : return -1;
11898 : : }
11899 [ - + ]: 1309 : if (PyModule_AddObjectRef(m, "With", state->With_type) < 0) {
11900 : 0 : return -1;
11901 : : }
11902 [ - + ]: 1309 : if (PyModule_AddObjectRef(m, "AsyncWith", state->AsyncWith_type) < 0) {
11903 : 0 : return -1;
11904 : : }
11905 [ - + ]: 1309 : if (PyModule_AddObjectRef(m, "Match", state->Match_type) < 0) {
11906 : 0 : return -1;
11907 : : }
11908 [ - + ]: 1309 : if (PyModule_AddObjectRef(m, "Raise", state->Raise_type) < 0) {
11909 : 0 : return -1;
11910 : : }
11911 [ - + ]: 1309 : if (PyModule_AddObjectRef(m, "Try", state->Try_type) < 0) {
11912 : 0 : return -1;
11913 : : }
11914 [ - + ]: 1309 : if (PyModule_AddObjectRef(m, "TryStar", state->TryStar_type) < 0) {
11915 : 0 : return -1;
11916 : : }
11917 [ - + ]: 1309 : if (PyModule_AddObjectRef(m, "Assert", state->Assert_type) < 0) {
11918 : 0 : return -1;
11919 : : }
11920 [ - + ]: 1309 : if (PyModule_AddObjectRef(m, "Import", state->Import_type) < 0) {
11921 : 0 : return -1;
11922 : : }
11923 [ - + ]: 1309 : if (PyModule_AddObjectRef(m, "ImportFrom", state->ImportFrom_type) < 0) {
11924 : 0 : return -1;
11925 : : }
11926 [ - + ]: 1309 : if (PyModule_AddObjectRef(m, "Global", state->Global_type) < 0) {
11927 : 0 : return -1;
11928 : : }
11929 [ - + ]: 1309 : if (PyModule_AddObjectRef(m, "Nonlocal", state->Nonlocal_type) < 0) {
11930 : 0 : return -1;
11931 : : }
11932 [ - + ]: 1309 : if (PyModule_AddObjectRef(m, "Expr", state->Expr_type) < 0) {
11933 : 0 : return -1;
11934 : : }
11935 [ - + ]: 1309 : if (PyModule_AddObjectRef(m, "Pass", state->Pass_type) < 0) {
11936 : 0 : return -1;
11937 : : }
11938 [ - + ]: 1309 : if (PyModule_AddObjectRef(m, "Break", state->Break_type) < 0) {
11939 : 0 : return -1;
11940 : : }
11941 [ - + ]: 1309 : if (PyModule_AddObjectRef(m, "Continue", state->Continue_type) < 0) {
11942 : 0 : return -1;
11943 : : }
11944 [ - + ]: 1309 : if (PyModule_AddObjectRef(m, "expr", state->expr_type) < 0) {
11945 : 0 : return -1;
11946 : : }
11947 [ - + ]: 1309 : if (PyModule_AddObjectRef(m, "BoolOp", state->BoolOp_type) < 0) {
11948 : 0 : return -1;
11949 : : }
11950 [ - + ]: 1309 : if (PyModule_AddObjectRef(m, "NamedExpr", state->NamedExpr_type) < 0) {
11951 : 0 : return -1;
11952 : : }
11953 [ - + ]: 1309 : if (PyModule_AddObjectRef(m, "BinOp", state->BinOp_type) < 0) {
11954 : 0 : return -1;
11955 : : }
11956 [ - + ]: 1309 : if (PyModule_AddObjectRef(m, "UnaryOp", state->UnaryOp_type) < 0) {
11957 : 0 : return -1;
11958 : : }
11959 [ - + ]: 1309 : if (PyModule_AddObjectRef(m, "Lambda", state->Lambda_type) < 0) {
11960 : 0 : return -1;
11961 : : }
11962 [ - + ]: 1309 : if (PyModule_AddObjectRef(m, "IfExp", state->IfExp_type) < 0) {
11963 : 0 : return -1;
11964 : : }
11965 [ - + ]: 1309 : if (PyModule_AddObjectRef(m, "Dict", state->Dict_type) < 0) {
11966 : 0 : return -1;
11967 : : }
11968 [ - + ]: 1309 : if (PyModule_AddObjectRef(m, "Set", state->Set_type) < 0) {
11969 : 0 : return -1;
11970 : : }
11971 [ - + ]: 1309 : if (PyModule_AddObjectRef(m, "ListComp", state->ListComp_type) < 0) {
11972 : 0 : return -1;
11973 : : }
11974 [ - + ]: 1309 : if (PyModule_AddObjectRef(m, "SetComp", state->SetComp_type) < 0) {
11975 : 0 : return -1;
11976 : : }
11977 [ - + ]: 1309 : if (PyModule_AddObjectRef(m, "DictComp", state->DictComp_type) < 0) {
11978 : 0 : return -1;
11979 : : }
11980 [ - + ]: 1309 : if (PyModule_AddObjectRef(m, "GeneratorExp", state->GeneratorExp_type) < 0)
11981 : : {
11982 : 0 : return -1;
11983 : : }
11984 [ - + ]: 1309 : if (PyModule_AddObjectRef(m, "Await", state->Await_type) < 0) {
11985 : 0 : return -1;
11986 : : }
11987 [ - + ]: 1309 : if (PyModule_AddObjectRef(m, "Yield", state->Yield_type) < 0) {
11988 : 0 : return -1;
11989 : : }
11990 [ - + ]: 1309 : if (PyModule_AddObjectRef(m, "YieldFrom", state->YieldFrom_type) < 0) {
11991 : 0 : return -1;
11992 : : }
11993 [ - + ]: 1309 : if (PyModule_AddObjectRef(m, "Compare", state->Compare_type) < 0) {
11994 : 0 : return -1;
11995 : : }
11996 [ - + ]: 1309 : if (PyModule_AddObjectRef(m, "Call", state->Call_type) < 0) {
11997 : 0 : return -1;
11998 : : }
11999 [ - + ]: 1309 : if (PyModule_AddObjectRef(m, "FormattedValue", state->FormattedValue_type)
12000 : : < 0) {
12001 : 0 : return -1;
12002 : : }
12003 [ - + ]: 1309 : if (PyModule_AddObjectRef(m, "JoinedStr", state->JoinedStr_type) < 0) {
12004 : 0 : return -1;
12005 : : }
12006 [ - + ]: 1309 : if (PyModule_AddObjectRef(m, "Constant", state->Constant_type) < 0) {
12007 : 0 : return -1;
12008 : : }
12009 [ - + ]: 1309 : if (PyModule_AddObjectRef(m, "Attribute", state->Attribute_type) < 0) {
12010 : 0 : return -1;
12011 : : }
12012 [ - + ]: 1309 : if (PyModule_AddObjectRef(m, "Subscript", state->Subscript_type) < 0) {
12013 : 0 : return -1;
12014 : : }
12015 [ - + ]: 1309 : if (PyModule_AddObjectRef(m, "Starred", state->Starred_type) < 0) {
12016 : 0 : return -1;
12017 : : }
12018 [ - + ]: 1309 : if (PyModule_AddObjectRef(m, "Name", state->Name_type) < 0) {
12019 : 0 : return -1;
12020 : : }
12021 [ - + ]: 1309 : if (PyModule_AddObjectRef(m, "List", state->List_type) < 0) {
12022 : 0 : return -1;
12023 : : }
12024 [ - + ]: 1309 : if (PyModule_AddObjectRef(m, "Tuple", state->Tuple_type) < 0) {
12025 : 0 : return -1;
12026 : : }
12027 [ - + ]: 1309 : if (PyModule_AddObjectRef(m, "Slice", state->Slice_type) < 0) {
12028 : 0 : return -1;
12029 : : }
12030 [ - + ]: 1309 : if (PyModule_AddObjectRef(m, "expr_context", state->expr_context_type) < 0)
12031 : : {
12032 : 0 : return -1;
12033 : : }
12034 [ - + ]: 1309 : if (PyModule_AddObjectRef(m, "Load", state->Load_type) < 0) {
12035 : 0 : return -1;
12036 : : }
12037 [ - + ]: 1309 : if (PyModule_AddObjectRef(m, "Store", state->Store_type) < 0) {
12038 : 0 : return -1;
12039 : : }
12040 [ - + ]: 1309 : if (PyModule_AddObjectRef(m, "Del", state->Del_type) < 0) {
12041 : 0 : return -1;
12042 : : }
12043 [ - + ]: 1309 : if (PyModule_AddObjectRef(m, "boolop", state->boolop_type) < 0) {
12044 : 0 : return -1;
12045 : : }
12046 [ - + ]: 1309 : if (PyModule_AddObjectRef(m, "And", state->And_type) < 0) {
12047 : 0 : return -1;
12048 : : }
12049 [ - + ]: 1309 : if (PyModule_AddObjectRef(m, "Or", state->Or_type) < 0) {
12050 : 0 : return -1;
12051 : : }
12052 [ - + ]: 1309 : if (PyModule_AddObjectRef(m, "operator", state->operator_type) < 0) {
12053 : 0 : return -1;
12054 : : }
12055 [ - + ]: 1309 : if (PyModule_AddObjectRef(m, "Add", state->Add_type) < 0) {
12056 : 0 : return -1;
12057 : : }
12058 [ - + ]: 1309 : if (PyModule_AddObjectRef(m, "Sub", state->Sub_type) < 0) {
12059 : 0 : return -1;
12060 : : }
12061 [ - + ]: 1309 : if (PyModule_AddObjectRef(m, "Mult", state->Mult_type) < 0) {
12062 : 0 : return -1;
12063 : : }
12064 [ - + ]: 1309 : if (PyModule_AddObjectRef(m, "MatMult", state->MatMult_type) < 0) {
12065 : 0 : return -1;
12066 : : }
12067 [ - + ]: 1309 : if (PyModule_AddObjectRef(m, "Div", state->Div_type) < 0) {
12068 : 0 : return -1;
12069 : : }
12070 [ - + ]: 1309 : if (PyModule_AddObjectRef(m, "Mod", state->Mod_type) < 0) {
12071 : 0 : return -1;
12072 : : }
12073 [ - + ]: 1309 : if (PyModule_AddObjectRef(m, "Pow", state->Pow_type) < 0) {
12074 : 0 : return -1;
12075 : : }
12076 [ - + ]: 1309 : if (PyModule_AddObjectRef(m, "LShift", state->LShift_type) < 0) {
12077 : 0 : return -1;
12078 : : }
12079 [ - + ]: 1309 : if (PyModule_AddObjectRef(m, "RShift", state->RShift_type) < 0) {
12080 : 0 : return -1;
12081 : : }
12082 [ - + ]: 1309 : if (PyModule_AddObjectRef(m, "BitOr", state->BitOr_type) < 0) {
12083 : 0 : return -1;
12084 : : }
12085 [ - + ]: 1309 : if (PyModule_AddObjectRef(m, "BitXor", state->BitXor_type) < 0) {
12086 : 0 : return -1;
12087 : : }
12088 [ - + ]: 1309 : if (PyModule_AddObjectRef(m, "BitAnd", state->BitAnd_type) < 0) {
12089 : 0 : return -1;
12090 : : }
12091 [ - + ]: 1309 : if (PyModule_AddObjectRef(m, "FloorDiv", state->FloorDiv_type) < 0) {
12092 : 0 : return -1;
12093 : : }
12094 [ - + ]: 1309 : if (PyModule_AddObjectRef(m, "unaryop", state->unaryop_type) < 0) {
12095 : 0 : return -1;
12096 : : }
12097 [ - + ]: 1309 : if (PyModule_AddObjectRef(m, "Invert", state->Invert_type) < 0) {
12098 : 0 : return -1;
12099 : : }
12100 [ - + ]: 1309 : if (PyModule_AddObjectRef(m, "Not", state->Not_type) < 0) {
12101 : 0 : return -1;
12102 : : }
12103 [ - + ]: 1309 : if (PyModule_AddObjectRef(m, "UAdd", state->UAdd_type) < 0) {
12104 : 0 : return -1;
12105 : : }
12106 [ - + ]: 1309 : if (PyModule_AddObjectRef(m, "USub", state->USub_type) < 0) {
12107 : 0 : return -1;
12108 : : }
12109 [ - + ]: 1309 : if (PyModule_AddObjectRef(m, "cmpop", state->cmpop_type) < 0) {
12110 : 0 : return -1;
12111 : : }
12112 [ - + ]: 1309 : if (PyModule_AddObjectRef(m, "Eq", state->Eq_type) < 0) {
12113 : 0 : return -1;
12114 : : }
12115 [ - + ]: 1309 : if (PyModule_AddObjectRef(m, "NotEq", state->NotEq_type) < 0) {
12116 : 0 : return -1;
12117 : : }
12118 [ - + ]: 1309 : if (PyModule_AddObjectRef(m, "Lt", state->Lt_type) < 0) {
12119 : 0 : return -1;
12120 : : }
12121 [ - + ]: 1309 : if (PyModule_AddObjectRef(m, "LtE", state->LtE_type) < 0) {
12122 : 0 : return -1;
12123 : : }
12124 [ - + ]: 1309 : if (PyModule_AddObjectRef(m, "Gt", state->Gt_type) < 0) {
12125 : 0 : return -1;
12126 : : }
12127 [ - + ]: 1309 : if (PyModule_AddObjectRef(m, "GtE", state->GtE_type) < 0) {
12128 : 0 : return -1;
12129 : : }
12130 [ - + ]: 1309 : if (PyModule_AddObjectRef(m, "Is", state->Is_type) < 0) {
12131 : 0 : return -1;
12132 : : }
12133 [ - + ]: 1309 : if (PyModule_AddObjectRef(m, "IsNot", state->IsNot_type) < 0) {
12134 : 0 : return -1;
12135 : : }
12136 [ - + ]: 1309 : if (PyModule_AddObjectRef(m, "In", state->In_type) < 0) {
12137 : 0 : return -1;
12138 : : }
12139 [ - + ]: 1309 : if (PyModule_AddObjectRef(m, "NotIn", state->NotIn_type) < 0) {
12140 : 0 : return -1;
12141 : : }
12142 [ - + ]: 1309 : if (PyModule_AddObjectRef(m, "comprehension", state->comprehension_type) <
12143 : : 0) {
12144 : 0 : return -1;
12145 : : }
12146 [ - + ]: 1309 : if (PyModule_AddObjectRef(m, "excepthandler", state->excepthandler_type) <
12147 : : 0) {
12148 : 0 : return -1;
12149 : : }
12150 [ - + ]: 1309 : if (PyModule_AddObjectRef(m, "ExceptHandler", state->ExceptHandler_type) <
12151 : : 0) {
12152 : 0 : return -1;
12153 : : }
12154 [ - + ]: 1309 : if (PyModule_AddObjectRef(m, "arguments", state->arguments_type) < 0) {
12155 : 0 : return -1;
12156 : : }
12157 [ - + ]: 1309 : if (PyModule_AddObjectRef(m, "arg", state->arg_type) < 0) {
12158 : 0 : return -1;
12159 : : }
12160 [ - + ]: 1309 : if (PyModule_AddObjectRef(m, "keyword", state->keyword_type) < 0) {
12161 : 0 : return -1;
12162 : : }
12163 [ - + ]: 1309 : if (PyModule_AddObjectRef(m, "alias", state->alias_type) < 0) {
12164 : 0 : return -1;
12165 : : }
12166 [ - + ]: 1309 : if (PyModule_AddObjectRef(m, "withitem", state->withitem_type) < 0) {
12167 : 0 : return -1;
12168 : : }
12169 [ - + ]: 1309 : if (PyModule_AddObjectRef(m, "match_case", state->match_case_type) < 0) {
12170 : 0 : return -1;
12171 : : }
12172 [ - + ]: 1309 : if (PyModule_AddObjectRef(m, "pattern", state->pattern_type) < 0) {
12173 : 0 : return -1;
12174 : : }
12175 [ - + ]: 1309 : if (PyModule_AddObjectRef(m, "MatchValue", state->MatchValue_type) < 0) {
12176 : 0 : return -1;
12177 : : }
12178 [ - + ]: 1309 : if (PyModule_AddObjectRef(m, "MatchSingleton", state->MatchSingleton_type)
12179 : : < 0) {
12180 : 0 : return -1;
12181 : : }
12182 [ - + ]: 1309 : if (PyModule_AddObjectRef(m, "MatchSequence", state->MatchSequence_type) <
12183 : : 0) {
12184 : 0 : return -1;
12185 : : }
12186 [ - + ]: 1309 : if (PyModule_AddObjectRef(m, "MatchMapping", state->MatchMapping_type) < 0)
12187 : : {
12188 : 0 : return -1;
12189 : : }
12190 [ - + ]: 1309 : if (PyModule_AddObjectRef(m, "MatchClass", state->MatchClass_type) < 0) {
12191 : 0 : return -1;
12192 : : }
12193 [ - + ]: 1309 : if (PyModule_AddObjectRef(m, "MatchStar", state->MatchStar_type) < 0) {
12194 : 0 : return -1;
12195 : : }
12196 [ - + ]: 1309 : if (PyModule_AddObjectRef(m, "MatchAs", state->MatchAs_type) < 0) {
12197 : 0 : return -1;
12198 : : }
12199 [ - + ]: 1309 : if (PyModule_AddObjectRef(m, "MatchOr", state->MatchOr_type) < 0) {
12200 : 0 : return -1;
12201 : : }
12202 [ - + ]: 1309 : if (PyModule_AddObjectRef(m, "type_ignore", state->type_ignore_type) < 0) {
12203 : 0 : return -1;
12204 : : }
12205 [ - + ]: 1309 : if (PyModule_AddObjectRef(m, "TypeIgnore", state->TypeIgnore_type) < 0) {
12206 : 0 : return -1;
12207 : : }
12208 : 1309 : return 0;
12209 : : }
12210 : :
12211 : : static PyModuleDef_Slot astmodule_slots[] = {
12212 : : {Py_mod_exec, astmodule_exec},
12213 : : {0, NULL}
12214 : : };
12215 : :
12216 : : static struct PyModuleDef _astmodule = {
12217 : : PyModuleDef_HEAD_INIT,
12218 : : .m_name = "_ast",
12219 : : // The _ast module uses a per-interpreter state (PyInterpreterState.ast)
12220 : : .m_size = 0,
12221 : : .m_slots = astmodule_slots,
12222 : : };
12223 : :
12224 : : PyMODINIT_FUNC
12225 : 1309 : PyInit__ast(void)
12226 : : {
12227 : 1309 : return PyModuleDef_Init(&_astmodule);
12228 : : }
12229 : :
12230 : :
12231 : 10350 : PyObject* PyAST_mod2obj(mod_ty t)
12232 : : {
12233 : 10350 : struct ast_state *state = get_ast_state();
12234 [ - + ]: 10350 : if (state == NULL) {
12235 : 0 : return NULL;
12236 : : }
12237 : 10350 : return ast2obj_mod(state, t);
12238 : : }
12239 : :
12240 : : /* mode is 0 for "exec", 1 for "eval" and 2 for "single" input */
12241 : 688 : mod_ty PyAST_obj2mod(PyObject* ast, PyArena* arena, int mode)
12242 : : {
12243 : 688 : const char * const req_name[] = {"Module", "Expression", "Interactive"};
12244 : : int isinstance;
12245 : :
12246 [ - + ]: 688 : if (PySys_Audit("compile", "OO", ast, Py_None) < 0) {
12247 : 0 : return NULL;
12248 : : }
12249 : :
12250 : 688 : struct ast_state *state = get_ast_state();
12251 [ - + ]: 688 : if (state == NULL) {
12252 : 0 : return NULL;
12253 : : }
12254 : :
12255 : : PyObject *req_type[3];
12256 : 688 : req_type[0] = state->Module_type;
12257 : 688 : req_type[1] = state->Expression_type;
12258 : 688 : req_type[2] = state->Interactive_type;
12259 : :
12260 : : assert(0 <= mode && mode <= 2);
12261 : :
12262 : 688 : isinstance = PyObject_IsInstance(ast, req_type[mode]);
12263 [ - + ]: 688 : if (isinstance == -1)
12264 : 0 : return NULL;
12265 [ + + ]: 688 : if (!isinstance) {
12266 : 2 : PyErr_Format(PyExc_TypeError, "expected %s node, got %.400s",
12267 : 2 : req_name[mode], _PyType_Name(Py_TYPE(ast)));
12268 : 2 : return NULL;
12269 : : }
12270 : :
12271 : 686 : mod_ty res = NULL;
12272 [ + + ]: 686 : if (obj2ast_mod(state, ast, &res, arena) != 0)
12273 : 7 : return NULL;
12274 : : else
12275 : 679 : return res;
12276 : : }
12277 : :
12278 : 30299 : int PyAST_Check(PyObject* obj)
12279 : : {
12280 : 30299 : struct ast_state *state = get_ast_state();
12281 [ - + ]: 30299 : if (state == NULL) {
12282 : 0 : return -1;
12283 : : }
12284 : 30299 : return PyObject_IsInstance(obj, state->AST_type);
12285 : : }
12286 : :
12287 : :
|
