Merge branch 'master' into revert-23107-revert-13893-fix-issue-37193revert-23107-revert-13893-fix-issue-37193

1 files changed, 141 insertions, 223 deletions

diff --git a/Python/Python-ast.c b/Python/Python-ast.c
index f04addbe20..debd3e3542 100644
--- a/Python/Python-ast.c
+++ b/Python/Python-ast.c
@@ -261,10 +261,10 @@ get_ast_state(void)
 #include "Python-ast.h"
 #include "structmember.h"
 
-void _PyAST_Fini(PyThreadState *tstate)
+void _PyAST_Fini(PyInterpreterState *interp)
 {
 #ifdef Py_BUILD_CORE
-    struct ast_state *state = &tstate->interp->ast;
+    struct ast_state *state = &interp->ast;
 #else
     struct ast_state *state = &global_ast_state;
 #endif
@@ -483,7 +483,11 @@ void _PyAST_Fini(PyThreadState *tstate)
     Py_CLEAR(state->vararg);
     Py_CLEAR(state->withitem_type);
 
+#if defined(Py_BUILD_CORE) && !defined(NDEBUG)
+    state->initialized = -1;
+#else
     state->initialized = 0;
+#endif
 }
 
 static int init_identifiers(struct ast_state *state)
@@ -1227,13 +1231,27 @@ static int add_ast_fields(struct ast_state *state)
 }
 
 
-static int init_types(struct ast_state *state)
+
+static int
+init_types(struct ast_state *state)
 {
-    if (state->initialized) return 1;
-    if (init_identifiers(state) < 0) return 0;
+    // init_types() must not be called after _PyAST_Fini()
+    // has been called
+    assert(state->initialized >= 0);
+
+    if (state->initialized) {
+        return 1;
+    }
+    if (init_identifiers(state) < 0) {
+        return 0;
+    }
     state->AST_type = PyType_FromSpec(&AST_type_spec);
-    if (!state->AST_type) return 0;
-    if (add_ast_fields(state) < 0) return 0;
+    if (!state->AST_type) {
+        return 0;
+    }
+    if (add_ast_fields(state) < 0) {
+        return 0;
+    }
     state->mod_type = make_type(state, "mod", state->AST_type, NULL, 0,
         "mod = Module(stmt* body, type_ignore* type_ignores)\n"
         "    | Interactive(stmt* body)\n"
@@ -1902,6 +1920,7 @@ static int init_types(struct ast_state *state)
                                        TypeIgnore_fields, 2,
         "TypeIgnore(int lineno, string tag)");
     if (!state->TypeIgnore_type) return 0;
+
     state->initialized = 1;
     return 1;
 }
@@ -9699,10 +9718,9 @@ astmodule_exec(PyObject *m)
     if (state == NULL) {
         return -1;
     }
-    if (PyModule_AddObject(m, "AST", state->AST_type) < 0) {
+    if (PyModule_AddObjectRef(m, "AST", state->AST_type) < 0) {
         return -1;
     }
-    Py_INCREF(state->AST_type);
     if (PyModule_AddIntMacro(m, PyCF_ALLOW_TOP_LEVEL_AWAIT) < 0) {
         return -1;
     }
@@ -9712,432 +9730,332 @@ astmodule_exec(PyObject *m)
     if (PyModule_AddIntMacro(m, PyCF_TYPE_COMMENTS) < 0) {
         return -1;
     }
-    if (PyModule_AddObject(m, "mod", state->mod_type) < 0) {
+    if (PyModule_AddObjectRef(m, "mod", state->mod_type) < 0) {
         return -1;
     }
-    Py_INCREF(state->mod_type);
-    if (PyModule_AddObject(m, "Module", state->Module_type) < 0) {
+    if (PyModule_AddObjectRef(m, "Module", state->Module_type) < 0) {
         return -1;
     }
-    Py_INCREF(state->Module_type);
-    if (PyModule_AddObject(m, "Interactive", state->Interactive_type) < 0) {
+    if (PyModule_AddObjectRef(m, "Interactive", state->Interactive_type) < 0) {
         return -1;
     }
-    Py_INCREF(state->Interactive_type);
-    if (PyModule_AddObject(m, "Expression", state->Expression_type) < 0) {
+    if (PyModule_AddObjectRef(m, "Expression", state->Expression_type) < 0) {
         return -1;
     }
-    Py_INCREF(state->Expression_type);
-    if (PyModule_AddObject(m, "FunctionType", state->FunctionType_type) < 0) {
+    if (PyModule_AddObjectRef(m, "FunctionType", state->FunctionType_type) < 0)
+        {
         return -1;
     }
-    Py_INCREF(state->FunctionType_type);
-    if (PyModule_AddObject(m, "stmt", state->stmt_type) < 0) {
+    if (PyModule_AddObjectRef(m, "stmt", state->stmt_type) < 0) {
         return -1;
     }
-    Py_INCREF(state->stmt_type);
-    if (PyModule_AddObject(m, "FunctionDef", state->FunctionDef_type) < 0) {
+    if (PyModule_AddObjectRef(m, "FunctionDef", state->FunctionDef_type) < 0) {
         return -1;
     }
-    Py_INCREF(state->FunctionDef_type);
-    if (PyModule_AddObject(m, "AsyncFunctionDef", state->AsyncFunctionDef_type)
-        < 0) {
+    if (PyModule_AddObjectRef(m, "AsyncFunctionDef",
+        state->AsyncFunctionDef_type) < 0) {
         return -1;
     }
-    Py_INCREF(state->AsyncFunctionDef_type);
-    if (PyModule_AddObject(m, "ClassDef", state->ClassDef_type) < 0) {
+    if (PyModule_AddObjectRef(m, "ClassDef", state->ClassDef_type) < 0) {
         return -1;
     }
-    Py_INCREF(state->ClassDef_type);
-    if (PyModule_AddObject(m, "Return", state->Return_type) < 0) {
+    if (PyModule_AddObjectRef(m, "Return", state->Return_type) < 0) {
         return -1;
     }
-    Py_INCREF(state->Return_type);
-    if (PyModule_AddObject(m, "Delete", state->Delete_type) < 0) {
+    if (PyModule_AddObjectRef(m, "Delete", state->Delete_type) < 0) {
         return -1;
     }
-    Py_INCREF(state->Delete_type);
-    if (PyModule_AddObject(m, "Assign", state->Assign_type) < 0) {
+    if (PyModule_AddObjectRef(m, "Assign", state->Assign_type) < 0) {
         return -1;
     }
-    Py_INCREF(state->Assign_type);
-    if (PyModule_AddObject(m, "AugAssign", state->AugAssign_type) < 0) {
+    if (PyModule_AddObjectRef(m, "AugAssign", state->AugAssign_type) < 0) {
         return -1;
     }
-    Py_INCREF(state->AugAssign_type);
-    if (PyModule_AddObject(m, "AnnAssign", state->AnnAssign_type) < 0) {
+    if (PyModule_AddObjectRef(m, "AnnAssign", state->AnnAssign_type) < 0) {
         return -1;
     }
-    Py_INCREF(state->AnnAssign_type);
-    if (PyModule_AddObject(m, "For", state->For_type) < 0) {
+    if (PyModule_AddObjectRef(m, "For", state->For_type) < 0) {
         return -1;
     }
-    Py_INCREF(state->For_type);
-    if (PyModule_AddObject(m, "AsyncFor", state->AsyncFor_type) < 0) {
+    if (PyModule_AddObjectRef(m, "AsyncFor", state->AsyncFor_type) < 0) {
         return -1;
     }
-    Py_INCREF(state->AsyncFor_type);
-    if (PyModule_AddObject(m, "While", state->While_type) < 0) {
+    if (PyModule_AddObjectRef(m, "While", state->While_type) < 0) {
         return -1;
     }
-    Py_INCREF(state->While_type);
-    if (PyModule_AddObject(m, "If", state->If_type) < 0) {
+    if (PyModule_AddObjectRef(m, "If", state->If_type) < 0) {
         return -1;
     }
-    Py_INCREF(state->If_type);
-    if (PyModule_AddObject(m, "With", state->With_type) < 0) {
+    if (PyModule_AddObjectRef(m, "With", state->With_type) < 0) {
         return -1;
     }
-    Py_INCREF(state->With_type);
-    if (PyModule_AddObject(m, "AsyncWith", state->AsyncWith_type) < 0) {
+    if (PyModule_AddObjectRef(m, "AsyncWith", state->AsyncWith_type) < 0) {
         return -1;
     }
-    Py_INCREF(state->AsyncWith_type);
-    if (PyModule_AddObject(m, "Raise", state->Raise_type) < 0) {
+    if (PyModule_AddObjectRef(m, "Raise", state->Raise_type) < 0) {
         return -1;
     }
-    Py_INCREF(state->Raise_type);
-    if (PyModule_AddObject(m, "Try", state->Try_type) < 0) {
+    if (PyModule_AddObjectRef(m, "Try", state->Try_type) < 0) {
         return -1;
     }
-    Py_INCREF(state->Try_type);
-    if (PyModule_AddObject(m, "Assert", state->Assert_type) < 0) {
+    if (PyModule_AddObjectRef(m, "Assert", state->Assert_type) < 0) {
         return -1;
     }
-    Py_INCREF(state->Assert_type);
-    if (PyModule_AddObject(m, "Import", state->Import_type) < 0) {
+    if (PyModule_AddObjectRef(m, "Import", state->Import_type) < 0) {
         return -1;
     }
-    Py_INCREF(state->Import_type);
-    if (PyModule_AddObject(m, "ImportFrom", state->ImportFrom_type) < 0) {
+    if (PyModule_AddObjectRef(m, "ImportFrom", state->ImportFrom_type) < 0) {
         return -1;
     }
-    Py_INCREF(state->ImportFrom_type);
-    if (PyModule_AddObject(m, "Global", state->Global_type) < 0) {
+    if (PyModule_AddObjectRef(m, "Global", state->Global_type) < 0) {
         return -1;
     }
-    Py_INCREF(state->Global_type);
-    if (PyModule_AddObject(m, "Nonlocal", state->Nonlocal_type) < 0) {
+    if (PyModule_AddObjectRef(m, "Nonlocal", state->Nonlocal_type) < 0) {
         return -1;
     }
-    Py_INCREF(state->Nonlocal_type);
-    if (PyModule_AddObject(m, "Expr", state->Expr_type) < 0) {
+    if (PyModule_AddObjectRef(m, "Expr", state->Expr_type) < 0) {
         return -1;
     }
-    Py_INCREF(state->Expr_type);
-    if (PyModule_AddObject(m, "Pass", state->Pass_type) < 0) {
+    if (PyModule_AddObjectRef(m, "Pass", state->Pass_type) < 0) {
         return -1;
     }
-    Py_INCREF(state->Pass_type);
-    if (PyModule_AddObject(m, "Break", state->Break_type) < 0) {
+    if (PyModule_AddObjectRef(m, "Break", state->Break_type) < 0) {
         return -1;
     }
-    Py_INCREF(state->Break_type);
-    if (PyModule_AddObject(m, "Continue", state->Continue_type) < 0) {
+    if (PyModule_AddObjectRef(m, "Continue", state->Continue_type) < 0) {
         return -1;
     }
-    Py_INCREF(state->Continue_type);
-    if (PyModule_AddObject(m, "expr", state->expr_type) < 0) {
+    if (PyModule_AddObjectRef(m, "expr", state->expr_type) < 0) {
         return -1;
     }
-    Py_INCREF(state->expr_type);
-    if (PyModule_AddObject(m, "BoolOp", state->BoolOp_type) < 0) {
+    if (PyModule_AddObjectRef(m, "BoolOp", state->BoolOp_type) < 0) {
         return -1;
     }
-    Py_INCREF(state->BoolOp_type);
-    if (PyModule_AddObject(m, "NamedExpr", state->NamedExpr_type) < 0) {
+    if (PyModule_AddObjectRef(m, "NamedExpr", state->NamedExpr_type) < 0) {
         return -1;
     }
-    Py_INCREF(state->NamedExpr_type);
-    if (PyModule_AddObject(m, "BinOp", state->BinOp_type) < 0) {
+    if (PyModule_AddObjectRef(m, "BinOp", state->BinOp_type) < 0) {
         return -1;
     }
-    Py_INCREF(state->BinOp_type);
-    if (PyModule_AddObject(m, "UnaryOp", state->UnaryOp_type) < 0) {
+    if (PyModule_AddObjectRef(m, "UnaryOp", state->UnaryOp_type) < 0) {
         return -1;
     }
-    Py_INCREF(state->UnaryOp_type);
-    if (PyModule_AddObject(m, "Lambda", state->Lambda_type) < 0) {
+    if (PyModule_AddObjectRef(m, "Lambda", state->Lambda_type) < 0) {
         return -1;
     }
-    Py_INCREF(state->Lambda_type);
-    if (PyModule_AddObject(m, "IfExp", state->IfExp_type) < 0) {
+    if (PyModule_AddObjectRef(m, "IfExp", state->IfExp_type) < 0) {
         return -1;
     }
-    Py_INCREF(state->IfExp_type);
-    if (PyModule_AddObject(m, "Dict", state->Dict_type) < 0) {
+    if (PyModule_AddObjectRef(m, "Dict", state->Dict_type) < 0) {
         return -1;
     }
-    Py_INCREF(state->Dict_type);
-    if (PyModule_AddObject(m, "Set", state->Set_type) < 0) {
+    if (PyModule_AddObjectRef(m, "Set", state->Set_type) < 0) {
         return -1;
     }
-    Py_INCREF(state->Set_type);
-    if (PyModule_AddObject(m, "ListComp", state->ListComp_type) < 0) {
+    if (PyModule_AddObjectRef(m, "ListComp", state->ListComp_type) < 0) {
         return -1;
     }
-    Py_INCREF(state->ListComp_type);
-    if (PyModule_AddObject(m, "SetComp", state->SetComp_type) < 0) {
+    if (PyModule_AddObjectRef(m, "SetComp", state->SetComp_type) < 0) {
         return -1;
     }
-    Py_INCREF(state->SetComp_type);
-    if (PyModule_AddObject(m, "DictComp", state->DictComp_type) < 0) {
+    if (PyModule_AddObjectRef(m, "DictComp", state->DictComp_type) < 0) {
         return -1;
     }
-    Py_INCREF(state->DictComp_type);
-    if (PyModule_AddObject(m, "GeneratorExp", state->GeneratorExp_type) < 0) {
+    if (PyModule_AddObjectRef(m, "GeneratorExp", state->GeneratorExp_type) < 0)
+        {
         return -1;
     }
-    Py_INCREF(state->GeneratorExp_type);
-    if (PyModule_AddObject(m, "Await", state->Await_type) < 0) {
+    if (PyModule_AddObjectRef(m, "Await", state->Await_type) < 0) {
         return -1;
     }
-    Py_INCREF(state->Await_type);
-    if (PyModule_AddObject(m, "Yield", state->Yield_type) < 0) {
+    if (PyModule_AddObjectRef(m, "Yield", state->Yield_type) < 0) {
         return -1;
     }
-    Py_INCREF(state->Yield_type);
-    if (PyModule_AddObject(m, "YieldFrom", state->YieldFrom_type) < 0) {
+    if (PyModule_AddObjectRef(m, "YieldFrom", state->YieldFrom_type) < 0) {
         return -1;
     }
-    Py_INCREF(state->YieldFrom_type);
-    if (PyModule_AddObject(m, "Compare", state->Compare_type) < 0) {
+    if (PyModule_AddObjectRef(m, "Compare", state->Compare_type) < 0) {
         return -1;
     }
-    Py_INCREF(state->Compare_type);
-    if (PyModule_AddObject(m, "Call", state->Call_type) < 0) {
+    if (PyModule_AddObjectRef(m, "Call", state->Call_type) < 0) {
         return -1;
     }
-    Py_INCREF(state->Call_type);
-    if (PyModule_AddObject(m, "FormattedValue", state->FormattedValue_type) <
-        0) {
+    if (PyModule_AddObjectRef(m, "FormattedValue", state->FormattedValue_type)
+        < 0) {
         return -1;
     }
-    Py_INCREF(state->FormattedValue_type);
-    if (PyModule_AddObject(m, "JoinedStr", state->JoinedStr_type) < 0) {
+    if (PyModule_AddObjectRef(m, "JoinedStr", state->JoinedStr_type) < 0) {
         return -1;
     }
-    Py_INCREF(state->JoinedStr_type);
-    if (PyModule_AddObject(m, "Constant", state->Constant_type) < 0) {
+    if (PyModule_AddObjectRef(m, "Constant", state->Constant_type) < 0) {
         return -1;
     }
-    Py_INCREF(state->Constant_type);
-    if (PyModule_AddObject(m, "Attribute", state->Attribute_type) < 0) {
+    if (PyModule_AddObjectRef(m, "Attribute", state->Attribute_type) < 0) {
         return -1;
     }
-    Py_INCREF(state->Attribute_type);
-    if (PyModule_AddObject(m, "Subscript", state->Subscript_type) < 0) {
+    if (PyModule_AddObjectRef(m, "Subscript", state->Subscript_type) < 0) {
         return -1;
     }
-    Py_INCREF(state->Subscript_type);
-    if (PyModule_AddObject(m, "Starred", state->Starred_type) < 0) {
+    if (PyModule_AddObjectRef(m, "Starred", state->Starred_type) < 0) {
         return -1;
     }
-    Py_INCREF(state->Starred_type);
-    if (PyModule_AddObject(m, "Name", state->Name_type) < 0) {
+    if (PyModule_AddObjectRef(m, "Name", state->Name_type) < 0) {
         return -1;
     }
-    Py_INCREF(state->Name_type);
-    if (PyModule_AddObject(m, "List", state->List_type) < 0) {
+    if (PyModule_AddObjectRef(m, "List", state->List_type) < 0) {
         return -1;
     }
-    Py_INCREF(state->List_type);
-    if (PyModule_AddObject(m, "Tuple", state->Tuple_type) < 0) {
+    if (PyModule_AddObjectRef(m, "Tuple", state->Tuple_type) < 0) {
         return -1;
     }
-    Py_INCREF(state->Tuple_type);
-    if (PyModule_AddObject(m, "Slice", state->Slice_type) < 0) {
+    if (PyModule_AddObjectRef(m, "Slice", state->Slice_type) < 0) {
         return -1;
     }
-    Py_INCREF(state->Slice_type);
-    if (PyModule_AddObject(m, "expr_context", state->expr_context_type) < 0) {
+    if (PyModule_AddObjectRef(m, "expr_context", state->expr_context_type) < 0)
+        {
         return -1;
     }
-    Py_INCREF(state->expr_context_type);
-    if (PyModule_AddObject(m, "Load", state->Load_type) < 0) {
+    if (PyModule_AddObjectRef(m, "Load", state->Load_type) < 0) {
         return -1;
     }
-    Py_INCREF(state->Load_type);
-    if (PyModule_AddObject(m, "Store", state->Store_type) < 0) {
+    if (PyModule_AddObjectRef(m, "Store", state->Store_type) < 0) {
         return -1;
     }
-    Py_INCREF(state->Store_type);
-    if (PyModule_AddObject(m, "Del", state->Del_type) < 0) {
+    if (PyModule_AddObjectRef(m, "Del", state->Del_type) < 0) {
         return -1;
     }
-    Py_INCREF(state->Del_type);
-    if (PyModule_AddObject(m, "boolop", state->boolop_type) < 0) {
+    if (PyModule_AddObjectRef(m, "boolop", state->boolop_type) < 0) {
         return -1;
     }
-    Py_INCREF(state->boolop_type);
-    if (PyModule_AddObject(m, "And", state->And_type) < 0) {
+    if (PyModule_AddObjectRef(m, "And", state->And_type) < 0) {
         return -1;
     }
-    Py_INCREF(state->And_type);
-    if (PyModule_AddObject(m, "Or", state->Or_type) < 0) {
+    if (PyModule_AddObjectRef(m, "Or", state->Or_type) < 0) {
         return -1;
     }
-    Py_INCREF(state->Or_type);
-    if (PyModule_AddObject(m, "operator", state->operator_type) < 0) {
+    if (PyModule_AddObjectRef(m, "operator", state->operator_type) < 0) {
         return -1;
     }
-    Py_INCREF(state->operator_type);
-    if (PyModule_AddObject(m, "Add", state->Add_type) < 0) {
+    if (PyModule_AddObjectRef(m, "Add", state->Add_type) < 0) {
         return -1;
     }
-    Py_INCREF(state->Add_type);
-    if (PyModule_AddObject(m, "Sub", state->Sub_type) < 0) {
+    if (PyModule_AddObjectRef(m, "Sub", state->Sub_type) < 0) {
         return -1;
     }
-    Py_INCREF(state->Sub_type);
-    if (PyModule_AddObject(m, "Mult", state->Mult_type) < 0) {
+    if (PyModule_AddObjectRef(m, "Mult", state->Mult_type) < 0) {
         return -1;
     }
-    Py_INCREF(state->Mult_type);
-    if (PyModule_AddObject(m, "MatMult", state->MatMult_type) < 0) {
+    if (PyModule_AddObjectRef(m, "MatMult", state->MatMult_type) < 0) {
         return -1;
     }
-    Py_INCREF(state->MatMult_type);
-    if (PyModule_AddObject(m, "Div", state->Div_type) < 0) {
+    if (PyModule_AddObjectRef(m, "Div", state->Div_type) < 0) {
         return -1;
     }
-    Py_INCREF(state->Div_type);
-    if (PyModule_AddObject(m, "Mod", state->Mod_type) < 0) {
+    if (PyModule_AddObjectRef(m, "Mod", state->Mod_type) < 0) {
         return -1;
     }
-    Py_INCREF(state->Mod_type);
-    if (PyModule_AddObject(m, "Pow", state->Pow_type) < 0) {
+    if (PyModule_AddObjectRef(m, "Pow", state->Pow_type) < 0) {
         return -1;
     }
-    Py_INCREF(state->Pow_type);
-    if (PyModule_AddObject(m, "LShift", state->LShift_type) < 0) {
+    if (PyModule_AddObjectRef(m, "LShift", state->LShift_type) < 0) {
         return -1;
     }
-    Py_INCREF(state->LShift_type);
-    if (PyModule_AddObject(m, "RShift", state->RShift_type) < 0) {
+    if (PyModule_AddObjectRef(m, "RShift", state->RShift_type) < 0) {
         return -1;
     }
-    Py_INCREF(state->RShift_type);
-    if (PyModule_AddObject(m, "BitOr", state->BitOr_type) < 0) {
+    if (PyModule_AddObjectRef(m, "BitOr", state->BitOr_type) < 0) {
         return -1;
     }
-    Py_INCREF(state->BitOr_type);
-    if (PyModule_AddObject(m, "BitXor", state->BitXor_type) < 0) {
+    if (PyModule_AddObjectRef(m, "BitXor", state->BitXor_type) < 0) {
         return -1;
     }
-    Py_INCREF(state->BitXor_type);
-    if (PyModule_AddObject(m, "BitAnd", state->BitAnd_type) < 0) {
+    if (PyModule_AddObjectRef(m, "BitAnd", state->BitAnd_type) < 0) {
         return -1;
     }
-    Py_INCREF(state->BitAnd_type);
-    if (PyModule_AddObject(m, "FloorDiv", state->FloorDiv_type) < 0) {
+    if (PyModule_AddObjectRef(m, "FloorDiv", state->FloorDiv_type) < 0) {
         return -1;
     }
-    Py_INCREF(state->FloorDiv_type);
-    if (PyModule_AddObject(m, "unaryop", state->unaryop_type) < 0) {
+    if (PyModule_AddObjectRef(m, "unaryop", state->unaryop_type) < 0) {
         return -1;
     }
-    Py_INCREF(state->unaryop_type);
-    if (PyModule_AddObject(m, "Invert", state->Invert_type) < 0) {
+    if (PyModule_AddObjectRef(m, "Invert", state->Invert_type) < 0) {
         return -1;
     }
-    Py_INCREF(state->Invert_type);
-    if (PyModule_AddObject(m, "Not", state->Not_type) < 0) {
+    if (PyModule_AddObjectRef(m, "Not", state->Not_type) < 0) {
         return -1;
     }
-    Py_INCREF(state->Not_type);
-    if (PyModule_AddObject(m, "UAdd", state->UAdd_type) < 0) {
+    if (PyModule_AddObjectRef(m, "UAdd", state->UAdd_type) < 0) {
         return -1;
     }
-    Py_INCREF(state->UAdd_type);
-    if (PyModule_AddObject(m, "USub", state->USub_type) < 0) {
+    if (PyModule_AddObjectRef(m, "USub", state->USub_type) < 0) {
         return -1;
     }
-    Py_INCREF(state->USub_type);
-    if (PyModule_AddObject(m, "cmpop", state->cmpop_type) < 0) {
+    if (PyModule_AddObjectRef(m, "cmpop", state->cmpop_type) < 0) {
         return -1;
     }
-    Py_INCREF(state->cmpop_type);
-    if (PyModule_AddObject(m, "Eq", state->Eq_type) < 0) {
+    if (PyModule_AddObjectRef(m, "Eq", state->Eq_type) < 0) {
         return -1;
     }
-    Py_INCREF(state->Eq_type);
-    if (PyModule_AddObject(m, "NotEq", state->NotEq_type) < 0) {
+    if (PyModule_AddObjectRef(m, "NotEq", state->NotEq_type) < 0) {
         return -1;
     }
-    Py_INCREF(state->NotEq_type);
-    if (PyModule_AddObject(m, "Lt", state->Lt_type) < 0) {
+    if (PyModule_AddObjectRef(m, "Lt", state->Lt_type) < 0) {
         return -1;
     }
-    Py_INCREF(state->Lt_type);
-    if (PyModule_AddObject(m, "LtE", state->LtE_type) < 0) {
+    if (PyModule_AddObjectRef(m, "LtE", state->LtE_type) < 0) {
         return -1;
     }
-    Py_INCREF(state->LtE_type);
-    if (PyModule_AddObject(m, "Gt", state->Gt_type) < 0) {
+    if (PyModule_AddObjectRef(m, "Gt", state->Gt_type) < 0) {
         return -1;
     }
-    Py_INCREF(state->Gt_type);
-    if (PyModule_AddObject(m, "GtE", state->GtE_type) < 0) {
+    if (PyModule_AddObjectRef(m, "GtE", state->GtE_type) < 0) {
         return -1;
     }
-    Py_INCREF(state->GtE_type);
-    if (PyModule_AddObject(m, "Is", state->Is_type) < 0) {
+    if (PyModule_AddObjectRef(m, "Is", state->Is_type) < 0) {
         return -1;
     }
-    Py_INCREF(state->Is_type);
-    if (PyModule_AddObject(m, "IsNot", state->IsNot_type) < 0) {
+    if (PyModule_AddObjectRef(m, "IsNot", state->IsNot_type) < 0) {
         return -1;
     }
-    Py_INCREF(state->IsNot_type);
-    if (PyModule_AddObject(m, "In", state->In_type) < 0) {
+    if (PyModule_AddObjectRef(m, "In", state->In_type) < 0) {
         return -1;
     }
-    Py_INCREF(state->In_type);
-    if (PyModule_AddObject(m, "NotIn", state->NotIn_type) < 0) {
+    if (PyModule_AddObjectRef(m, "NotIn", state->NotIn_type) < 0) {
         return -1;
     }
-    Py_INCREF(state->NotIn_type);
-    if (PyModule_AddObject(m, "comprehension", state->comprehension_type) < 0) {
+    if (PyModule_AddObjectRef(m, "comprehension", state->comprehension_type) <
+        0) {
         return -1;
     }
-    Py_INCREF(state->comprehension_type);
-    if (PyModule_AddObject(m, "excepthandler", state->excepthandler_type) < 0) {
+    if (PyModule_AddObjectRef(m, "excepthandler", state->excepthandler_type) <
+        0) {
         return -1;
     }
-    Py_INCREF(state->excepthandler_type);
-    if (PyModule_AddObject(m, "ExceptHandler", state->ExceptHandler_type) < 0) {
+    if (PyModule_AddObjectRef(m, "ExceptHandler", state->ExceptHandler_type) <
+        0) {
         return -1;
     }
-    Py_INCREF(state->ExceptHandler_type);
-    if (PyModule_AddObject(m, "arguments", state->arguments_type) < 0) {
+    if (PyModule_AddObjectRef(m, "arguments", state->arguments_type) < 0) {
         return -1;
     }
-    Py_INCREF(state->arguments_type);
-    if (PyModule_AddObject(m, "arg", state->arg_type) < 0) {
+    if (PyModule_AddObjectRef(m, "arg", state->arg_type) < 0) {
         return -1;
     }
-    Py_INCREF(state->arg_type);
-    if (PyModule_AddObject(m, "keyword", state->keyword_type) < 0) {
+    if (PyModule_AddObjectRef(m, "keyword", state->keyword_type) < 0) {
         return -1;
     }
-    Py_INCREF(state->keyword_type);
-    if (PyModule_AddObject(m, "alias", state->alias_type) < 0) {
+    if (PyModule_AddObjectRef(m, "alias", state->alias_type) < 0) {
         return -1;
     }
-    Py_INCREF(state->alias_type);
-    if (PyModule_AddObject(m, "withitem", state->withitem_type) < 0) {
+    if (PyModule_AddObjectRef(m, "withitem", state->withitem_type) < 0) {
         return -1;
     }
-    Py_INCREF(state->withitem_type);
-    if (PyModule_AddObject(m, "type_ignore", state->type_ignore_type) < 0) {
+    if (PyModule_AddObjectRef(m, "type_ignore", state->type_ignore_type) < 0) {
         return -1;
     }
-    Py_INCREF(state->type_ignore_type);
-    if (PyModule_AddObject(m, "TypeIgnore", state->TypeIgnore_type) < 0) {
+    if (PyModule_AddObjectRef(m, "TypeIgnore", state->TypeIgnore_type) < 0) {
         return -1;
     }
-    Py_INCREF(state->TypeIgnore_type);
     return 0;
 }