Move CiExc_StaticTypeError into ModuleState

Summary:
Move the `CiExc_StaticTypeError` exception type from a file-scope global in
`errors.c` into the `ModuleState` class as a `Ref<>` member. This ensures proper
GC traversal and cleanup.

The `errors.h` header now provides a compatibility macro `#define
CiExc_StaticTypeError Ci_GetStaticTypeError()` so that all existing usage sites
(15+ C/C++ files) continue to work without changes.

A C accessor function `Ci_GetStaticTypeError()` is added to
`module_c_state.h/cpp` following the existing pattern for C-accessible
ModuleState members.

Reviewed By: yoney

Differential Revision: D96614265

fbshipit-source-id: 69adb19b59f6044bd233269e1b53b5569e7d7c1d

Author: alexmalyshev

cinderx/StaticPython/classloader.h

@@ -25,8 +25,6 @@
 extern "C" {
 #endif
 
-extern PyObject* CiExc_StaticTypeError;
-
 #ifndef Py_LIMITED_API
 
 #endif

cinderx/StaticPython/errors.c

@@ -2,14 +2,9 @@
 
 #pragma once
 
-#include "cinderx/python.h"
+#include "cinderx/module_c_state.h"
 
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-extern PyObject* CiExc_StaticTypeError;
-
-#ifdef __cplusplus
-}
-#endif
+// CiExc_StaticTypeError is stored in ModuleState and accessed via a C
+// accessor function. The macro preserves source compatibility with all
+// existing usage sites.
+#define CiExc_StaticTypeError Ci_GetStaticTypeError()

cinderx/StaticPython/errors.h

@@ -1377,11 +1377,15 @@ int _cinderx_exec_impl(PyObject* m) {
   watcher_state.setFuncWatcher(cinderx_func_watcher);
   watcher_state.setTypeWatcher(cinderx_type_watcher);
 
-  CiExc_StaticTypeError =
-      PyErr_NewException("cinderx.StaticTypeError", PyExc_TypeError, nullptr);
-  if (CiExc_StaticTypeError == nullptr) {
+  PyObject* static_type_error = PyErr_NewException(
+      "cinderx.StaticTypeError", PyExc_TypeError, nullptr /* dict */);
+  if (static_type_error == nullptr) {
     return -1;
   }
+  JIT_CHECK(
+      PyType_Check(static_type_error),
+      "Created StaticTypeError but it isn't a type object");
+  state->static_type_error = Ref<PyTypeObject>::steal(static_type_error);
 
   if (PyType_Ready(&PyCachedProperty_Type) < 0) {
     return -1;

cinderx/_cinderx-lib.cpp

@@ -11,6 +11,11 @@ extern "C" {
 vectorcallfunc Ci_PyFunction_Vectorcall;
 #endif
 
+PyObject* Ci_GetStaticTypeError(void) {
+  auto state = cinderx::getModuleState();
+  return state != nullptr ? state->static_type_error.getObj() : nullptr;
+}
+
 int Ci_Watchers_WatchDict(PyObject* dict) {
   return cinderx::getModuleState()->watcher_state.watchDict(dict);
 }

cinderx/module_c_state.cpp

@@ -20,6 +20,9 @@ extern "C" {
 extern vectorcallfunc Ci_PyFunction_Vectorcall;
 #endif
 
+// Get the StaticTypeError exception type.
+PyObject* Ci_GetStaticTypeError(void);
+
 // WatcherState.
 
 int Ci_Watchers_WatchDict(PyObject* dict);

cinderx/module_c_state.h

@@ -13,11 +13,13 @@ ModuleState* s_cinderx_state;
 } // namespace
 
 int ModuleState::traverse(visitproc visit, void* arg) {
+  Py_VISIT(static_type_error);
   Py_VISIT(builtin_next);
   return 0;
 }
 
 int ModuleState::clear() {
+  static_type_error.reset();
   sys_clear_caches.reset();
   builtin_next.reset();
   return 0;

cinderx/module_state.cpp

@@ -55,6 +55,9 @@ struct ModuleState {
   // Type for the custom awaitable returned by CinderX's anext() replacement.
   Ref<PyTypeObject> anext_awaitable_type;
 
+  // The cinderx.StaticTypeError exception type.
+  Ref<PyTypeObject> static_type_error;
+
   // Snapshotted member dicts for standard builtin types (int, str, list, etc.)
   // so the JIT optimizer can look up methods during multithreaded compilation
   // without calling PyType_Lookup (which isn't safe off the main thread).