gh-117398: Move types to datetime state (#118606)

Move types to the datetime_state structure of the _datetime
extension.

diff --git a/Modules/_datetimemodule.c b/Modules/_datetimemodule.c
index 8164715a66ff09db5ac9f16f3ff8565d211a3fa5..9a66f0358179b5650ade8477e01dfc004b8d8c76 100644 (file)
--- a/Modules/_datetimemodule.c
+++ b/Modules/_datetimemodule.c
@@ -25,24 +25,15 @@
 #  include <winsock2.h>         /* struct timeval */
 #endif
 
-#define PyDate_Check(op) PyObject_TypeCheck(op, &PyDateTime_DateType)
-#define PyDate_CheckExact(op) Py_IS_TYPE(op, &PyDateTime_DateType)
-
-#define PyDateTime_Check(op) PyObject_TypeCheck(op, &PyDateTime_DateTimeType)
-#define PyDateTime_CheckExact(op) Py_IS_TYPE(op, &PyDateTime_DateTimeType)
-
-#define PyTime_Check(op) PyObject_TypeCheck(op, &PyDateTime_TimeType)
-#define PyTime_CheckExact(op) Py_IS_TYPE(op, &PyDateTime_TimeType)
-
-#define PyDelta_Check(op) PyObject_TypeCheck(op, &PyDateTime_DeltaType)
-#define PyDelta_CheckExact(op) Py_IS_TYPE(op, &PyDateTime_DeltaType)
-
-#define PyTZInfo_Check(op) PyObject_TypeCheck(op, &PyDateTime_TZInfoType)
-#define PyTZInfo_CheckExact(op) Py_IS_TYPE(op, &PyDateTime_TZInfoType)
-
-#define PyTimezone_Check(op) PyObject_TypeCheck(op, &PyDateTime_TimeZoneType)
-
 typedef struct {
+    PyTypeObject *date_type;
+    PyTypeObject *datetime_type;
+    PyTypeObject *delta_type;
+    PyTypeObject *isocalendar_date_type;
+    PyTypeObject *time_type;
+    PyTypeObject *tzinfo_type;
+    PyTypeObject *timezone_type;
+
     /* Conversion factors. */
     PyObject *us_per_ms;       // 1_000
     PyObject *us_per_second;   // 1_000_000
@@ -61,7 +52,27 @@ typedef struct {
 
 static datetime_state _datetime_global_state;
 
-#define STATIC_STATE() (&_datetime_global_state)
+static inline datetime_state* get_datetime_state(void)
+{
+    return &_datetime_global_state;
+}
+
+#define PyDate_Check(op) PyObject_TypeCheck(op, get_datetime_state()->date_type)
+#define PyDate_CheckExact(op) Py_IS_TYPE(op, get_datetime_state()->date_type)
+
+#define PyDateTime_Check(op) PyObject_TypeCheck(op, get_datetime_state()->datetime_type)
+#define PyDateTime_CheckExact(op) Py_IS_TYPE(op, get_datetime_state()->datetime_type)
+
+#define PyTime_Check(op) PyObject_TypeCheck(op, get_datetime_state()->time_type)
+#define PyTime_CheckExact(op) Py_IS_TYPE(op, get_datetime_state()->time_type)
+
+#define PyDelta_Check(op) PyObject_TypeCheck(op, get_datetime_state()->delta_type)
+#define PyDelta_CheckExact(op) Py_IS_TYPE(op, get_datetime_state()->delta_type)
+
+#define PyTZInfo_Check(op) PyObject_TypeCheck(op, get_datetime_state()->tzinfo_type)
+#define PyTZInfo_CheckExact(op) Py_IS_TYPE(op, get_datetime_state()->tzinfo_type)
+
+#define PyTimezone_Check(op) PyObject_TypeCheck(op, get_datetime_state()->timezone_type)
 
 /* We require that C int be at least 32 bits, and use int virtually
  * everywhere.  In just a few cases we use a temp long, where a Python
@@ -142,25 +153,16 @@ static datetime_state _datetime_global_state;
  */
 #define MONTH_IS_SANE(M) ((unsigned int)(M) - 1 < 12)
 
-/* Forward declarations. */
-static PyTypeObject PyDateTime_DateType;
-static PyTypeObject PyDateTime_DateTimeType;
-static PyTypeObject PyDateTime_DeltaType;
-static PyTypeObject PyDateTime_IsoCalendarDateType;
-static PyTypeObject PyDateTime_TimeType;
-static PyTypeObject PyDateTime_TZInfoType;
-static PyTypeObject PyDateTime_TimeZoneType;
-
 static int check_tzinfo_subclass(PyObject *p);
 
 /*[clinic input]
 module datetime
-class datetime.datetime "PyDateTime_DateTime *" "&PyDateTime_DateTimeType"
-class datetime.date "PyDateTime_Date *" "&PyDateTime_DateType"
-class datetime.time "PyDateTime_Time *" "&PyDateTime_TimeType"
-class datetime.IsoCalendarDate "PyDateTime_IsoCalendarDate *" "&PyDateTime_IsoCalendarDateType"
+class datetime.datetime "PyDateTime_DateTime *" "get_datetime_state()->datetime_type"
+class datetime.date "PyDateTime_Date *" "get_datetime_state()->date_type"
+class datetime.time "PyDateTime_Time *" "get_datetime_state()->time_type"
+class datetime.IsoCalendarDate "PyDateTime_IsoCalendarDate *" "get_datetime_state()->isocalendar_date_type"
 [clinic start generated code]*/
-/*[clinic end generated code: output=da39a3ee5e6b4b0d input=6f65a48dd22fa40f]*/
+/*[clinic end generated code: output=da39a3ee5e6b4b0d input=c8f3d834a860d50a]*/
 
 #include "clinic/_datetimemodule.c.h"
 
@@ -979,7 +981,7 @@ new_date_ex(int year, int month, int day, PyTypeObject *type)
 }
 
 #define new_date(year, month, day) \
-    new_date_ex(year, month, day, &PyDateTime_DateType)
+    new_date_ex(year, month, day, get_datetime_state()->date_type)
 
 // Forward declaration
 static PyObject *
@@ -989,12 +991,13 @@ new_datetime_ex(int, int, int, int, int, int, int, PyObject *, PyTypeObject *);
 static PyObject *
 new_date_subclass_ex(int year, int month, int day, PyObject *cls)
 {
+    datetime_state *st = get_datetime_state();
     PyObject *result;
     // We have "fast path" constructors for two subclasses: date and datetime
-    if ((PyTypeObject *)cls == &PyDateTime_DateType) {
+    if ((PyTypeObject *)cls == st->date_type) {
         result = new_date_ex(year, month, day, (PyTypeObject *)cls);
     }
-    else if ((PyTypeObject *)cls == &PyDateTime_DateTimeType) {
+    else if ((PyTypeObject *)cls == st->datetime_type) {
         result = new_datetime_ex(year, month, day, 0, 0, 0, 0, Py_None,
                                  (PyTypeObject *)cls);
     }
@@ -1049,7 +1052,7 @@ new_datetime_ex(int year, int month, int day, int hour, int minute,
 
 #define new_datetime(y, m, d, hh, mm, ss, us, tzinfo, fold) \
     new_datetime_ex2(y, m, d, hh, mm, ss, us, tzinfo, fold, \
-                    &PyDateTime_DateTimeType)
+                    get_datetime_state()->datetime_type)
 
 static PyObject *
 call_subclass_fold(PyObject *cls, int fold, const char *format, ...)
@@ -1088,9 +1091,11 @@ Done:
 static PyObject *
 new_datetime_subclass_fold_ex(int year, int month, int day, int hour, int minute,
                               int second, int usecond, PyObject *tzinfo,
-                              int fold, PyObject *cls) {
+                              int fold, PyObject *cls)
+{
+    datetime_state *st = get_datetime_state();
     PyObject* dt;
-    if ((PyTypeObject*)cls == &PyDateTime_DateTimeType) {
+    if ((PyTypeObject*)cls == st->datetime_type) {
         // Use the fast path constructor
         dt = new_datetime(year, month, day, hour, minute, second, usecond,
                           tzinfo, fold);
@@ -1152,14 +1157,15 @@ new_time_ex(int hour, int minute, int second, int usecond,
 }
 
 #define new_time(hh, mm, ss, us, tzinfo, fold)                       \
-    new_time_ex2(hh, mm, ss, us, tzinfo, fold, &PyDateTime_TimeType)
+    new_time_ex2(hh, mm, ss, us, tzinfo, fold, get_datetime_state()->time_type)
 
 static PyObject *
 new_time_subclass_fold_ex(int hour, int minute, int second, int usecond,
                           PyObject *tzinfo, int fold, PyObject *cls)
 {
     PyObject *t;
-    if ((PyTypeObject*)cls == &PyDateTime_TimeType) {
+    datetime_state *st = get_datetime_state();
+    if ((PyTypeObject*)cls == st->time_type) {
         // Use the fast path constructor
         t = new_time(hour, minute, second, usecond, tzinfo, fold);
     }
@@ -1203,7 +1209,7 @@ new_delta_ex(int days, int seconds, int microseconds, int normalize,
 }
 
 #define new_delta(d, s, us, normalize)  \
-    new_delta_ex(d, s, us, normalize, &PyDateTime_DeltaType)
+    new_delta_ex(d, s, us, normalize, get_datetime_state()->delta_type)
 
 
 typedef struct
@@ -1221,7 +1227,8 @@ static PyObject *
 create_timezone(PyObject *offset, PyObject *name)
 {
     PyDateTime_TimeZone *self;
-    PyTypeObject *type = &PyDateTime_TimeZoneType;
+    datetime_state *st = get_datetime_state();
+    PyTypeObject *type = st->timezone_type;
 
     assert(offset != NULL);
     assert(PyDelta_Check(offset));
@@ -1246,7 +1253,7 @@ new_timezone(PyObject *offset, PyObject *name)
     assert(name == NULL || PyUnicode_Check(name));
 
     if (name == NULL && delta_bool((PyDateTime_Delta *)offset) == 0) {
-        datetime_state *st = STATIC_STATE();
+        datetime_state *st = get_datetime_state();
         return Py_NewRef(st->utc);
     }
     if ((GET_TD_DAYS(offset) == -1 &&
@@ -1460,7 +1467,7 @@ tzinfo_from_isoformat_results(int rv, int tzoffset, int tz_useconds)
     if (rv == 1) {
         // Create a timezone from offset in seconds (0 returns UTC)
         if (tzoffset == 0) {
-            datetime_state *st = STATIC_STATE();
+            datetime_state *st = get_datetime_state();
             return Py_NewRef(st->utc);
         }
 
@@ -1893,7 +1900,7 @@ delta_to_microseconds(PyDateTime_Delta *self)
     x1 = PyLong_FromLong(GET_TD_DAYS(self));
     if (x1 == NULL)
         goto Done;
-    datetime_state *st = STATIC_STATE();
+    datetime_state *st = get_datetime_state();
     x2 = PyNumber_Multiply(x1, st->seconds_per_day);        /* days in seconds */
     if (x2 == NULL)
         goto Done;
@@ -1966,7 +1973,7 @@ microseconds_to_delta_ex(PyObject *pyus, PyTypeObject *type)
     PyObject *num = NULL;
     PyObject *result = NULL;
 
-    datetime_state *st = STATIC_STATE();
+    datetime_state *st = get_datetime_state();
     tuple = checked_divmod(pyus, st->us_per_second);
     if (tuple == NULL) {
         goto Done;
@@ -2019,7 +2026,7 @@ BadDivmod:
 }
 
 #define microseconds_to_delta(pymicros) \
-    microseconds_to_delta_ex(pymicros, &PyDateTime_DeltaType)
+    microseconds_to_delta_ex(pymicros, get_datetime_state()->delta_type)
 
 static PyObject *
 multiply_int_timedelta(PyObject *intobj, PyDateTime_Delta *delta)
@@ -2585,7 +2592,7 @@ delta_new(PyTypeObject *type, PyObject *args, PyObject *kw)
         y = accum("microseconds", x, us, _PyLong_GetOne(), &leftover_us);
         CLEANUP;
     }
-    datetime_state *st = STATIC_STATE();
+    datetime_state *st = get_datetime_state();
     if (ms) {
         y = accum("milliseconds", x, ms, st->us_per_ms, &leftover_us);
         CLEANUP;
@@ -2762,7 +2769,7 @@ delta_total_seconds(PyObject *self, PyObject *Py_UNUSED(ignored))
     if (total_microseconds == NULL)
         return NULL;
 
-    datetime_state *st = STATIC_STATE();
+    datetime_state *st = get_datetime_state();
     total_seconds = PyNumber_TrueDivide(total_microseconds, st->us_per_second);
 
     Py_DECREF(total_microseconds);
@@ -3475,8 +3482,9 @@ date_isocalendar(PyDateTime_Date *self, PyObject *Py_UNUSED(ignored))
         week = 0;
     }
 
-    PyObject* v = iso_calendar_date_new_impl(&PyDateTime_IsoCalendarDateType,
-                    year, week + 1, day + 1);
+    datetime_state *st = get_datetime_state();
+    PyObject *v = iso_calendar_date_new_impl(st->isocalendar_date_type,
+                                             year, week + 1, day + 1);
     if (v == NULL) {
         return NULL;
     }
@@ -3945,8 +3953,9 @@ timezone_new(PyTypeObject *type, PyObject *args, PyObject *kw)
 {
     PyObject *offset;
     PyObject *name = NULL;
+    datetime_state *st = get_datetime_state();
     if (PyArg_ParseTupleAndKeywords(args, kw, "O!|U:timezone", timezone_kws,
-                                    &PyDateTime_DeltaType, &offset, &name))
+                                    st->delta_type, &offset, &name))
         return new_timezone(offset, name);
 
     return NULL;
@@ -3999,7 +4008,7 @@ timezone_repr(PyDateTime_TimeZone *self)
        to use Py_TYPE(self)->tp_name here. */
     const char *type_name = Py_TYPE(self)->tp_name;
 
-    datetime_state *st = STATIC_STATE();
+    datetime_state *st = get_datetime_state();
     if (((PyObject *)self) == st->utc) {
         return PyUnicode_FromFormat("%s.utc", type_name);
     }
@@ -4022,7 +4031,7 @@ timezone_str(PyDateTime_TimeZone *self)
     if (self->name != NULL) {
         return Py_NewRef(self->name);
     }
-    datetime_state *st = STATIC_STATE();
+    datetime_state *st = get_datetime_state();
     if ((PyObject *)self == st->utc ||
            (GET_TD_DAYS(self->offset) == 0 &&
             GET_TD_SECONDS(self->offset) == 0 &&
@@ -4686,7 +4695,8 @@ time_fromisoformat(PyObject *cls, PyObject *tstr) {
     }
 
     PyObject *t;
-    if ( (PyTypeObject *)cls == &PyDateTime_TimeType ) {
+    datetime_state *st = get_datetime_state();
+    if ( (PyTypeObject *)cls == st->time_type) {
         t = new_time(hour, minute, second, microsecond, tzinfo, 0);
     } else {
         t = PyObject_CallFunction(cls, "iiiiO",
@@ -5284,9 +5294,10 @@ datetime_combine(PyObject *cls, PyObject *args, PyObject *kw)
     PyObject *tzinfo = NULL;
     PyObject *result = NULL;
 
+    datetime_state *st = get_datetime_state();
     if (PyArg_ParseTupleAndKeywords(args, kw, "O!O!|O:combine", keywords,
-                                    &PyDateTime_DateType, &date,
-                                    &PyDateTime_TimeType, &time, &tzinfo)) {
+                                    st->date_type, &date,
+                                    st->time_type, &time, &tzinfo)) {
         if (tzinfo == NULL) {
             if (HASTZINFO(time))
                 tzinfo = ((PyDateTime_Time *)time)->tzinfo;
@@ -6116,6 +6127,7 @@ local_timezone_from_timestamp(time_t timestamp)
     delta = new_delta(0, local_time_tm.tm_gmtoff, 0, 1);
 #else /* HAVE_STRUCT_TM_TM_ZONE */
     {
+        datetime_state *st = get_datetime_state();
         PyObject *local_time, *utc_time;
         struct tm utc_time_tm;
         char buf[100];
@@ -6170,10 +6182,11 @@ local_timezone(PyDateTime_DateTime *utc_time)
     PyObject *one_second;
     PyObject *seconds;
 
-    datetime_state *st = STATIC_STATE();
+    datetime_state *st = get_datetime_state();
     delta = datetime_subtract((PyObject *)utc_time, st->epoch);
     if (delta == NULL)
         return NULL;
+
     one_second = new_delta(0, 1, 0, 0);
     if (one_second == NULL) {
         Py_DECREF(delta);
@@ -6283,7 +6296,7 @@ datetime_astimezone(PyDateTime_DateTime *self, PyObject *args, PyObject *kw)
     if (result == NULL)
         return NULL;
 
-    datetime_state *st = STATIC_STATE();
+    datetime_state *st = get_datetime_state();
     /* Make sure result is aware and UTC. */
     if (!HASTZINFO(result)) {
         temp = (PyObject *)result;
@@ -6408,7 +6421,7 @@ datetime_timestamp(PyDateTime_DateTime *self, PyObject *Py_UNUSED(ignored))
     PyObject *result;
 
     if (HASTZINFO(self) && self->tzinfo != Py_None) {
-        datetime_state *st = STATIC_STATE();
+        datetime_state *st = get_datetime_state();
         PyObject *delta;
         delta = datetime_subtract((PyObject *)self, st->epoch);
         if (delta == NULL)
@@ -6712,16 +6725,18 @@ static PyMethodDef module_methods[] = {
 static inline PyDateTime_CAPI *
 get_datetime_capi(void)
 {
+    datetime_state *st = get_datetime_state();
+
     PyDateTime_CAPI *capi = PyMem_Malloc(sizeof(PyDateTime_CAPI));
     if (capi == NULL) {
         PyErr_NoMemory();
         return NULL;
     }
-    capi->DateType = &PyDateTime_DateType;
-    capi->DateTimeType = &PyDateTime_DateTimeType;
-    capi->TimeType = &PyDateTime_TimeType;
-    capi->DeltaType = &PyDateTime_DeltaType;
-    capi->TZInfoType = &PyDateTime_TZInfoType;
+    capi->DateType = st->date_type;
+    capi->DateTimeType = st->datetime_type;
+    capi->TimeType = st->time_type;
+    capi->DeltaType = st->delta_type;
+    capi->TZInfoType = st->tzinfo_type;
     capi->Date_FromDate = new_date_ex;
     capi->DateTime_FromDateAndTime = new_datetime_ex;
     capi->Time_FromTime = new_time_ex;
@@ -6733,7 +6748,6 @@ get_datetime_capi(void)
     capi->Time_FromTimeAndFold = new_time_ex2;
     // Make sure this function is called after utc has
     // been initialized.
-    datetime_state *st = STATIC_STATE();
     assert(st->utc != NULL);
     capi->TimeZone_UTC = st->utc; // borrowed ref
     return capi;
@@ -6749,7 +6763,7 @@ datetime_destructor(PyObject *op)
 static int
 datetime_clear(PyObject *module)
 {
-    datetime_state *st = STATIC_STATE();
+    datetime_state *st = get_datetime_state();
 
     Py_CLEAR(st->us_per_ms);
     Py_CLEAR(st->us_per_second);
@@ -6778,6 +6792,14 @@ create_timezone_from_delta(int days, int sec, int ms, int normalize)
 static int
 init_state(datetime_state *st)
 {
+    st->date_type = &PyDateTime_DateType;
+    st->datetime_type = &PyDateTime_DateTimeType;
+    st->delta_type = &PyDateTime_DeltaType;
+    st->isocalendar_date_type = &PyDateTime_IsoCalendarDateType;
+    st->time_type = &PyDateTime_TimeType;
+    st->tzinfo_type = &PyDateTime_TZInfoType;
+    st->timezone_type = &PyDateTime_TimeZoneType;
+
     st->us_per_ms = PyLong_FromLong(1000);
     if (st->us_per_ms == NULL) {
         return -1;
@@ -6854,6 +6876,11 @@ _datetime_exec(PyObject *module)
         goto error;
     }
 
+    datetime_state *st = get_datetime_state();
+    if (init_state(st) < 0) {
+        goto error;
+    }
+
 #define DATETIME_ADD_MACRO(dict, c, value_expr)         \
     do {                                                \
         PyObject *value = (value_expr);                 \
@@ -6868,39 +6895,34 @@ _datetime_exec(PyObject *module)
     } while(0)
 
     /* timedelta values */
-    PyObject *d = PyDateTime_DeltaType.tp_dict;
+    PyObject *d = st->delta_type->tp_dict;
     DATETIME_ADD_MACRO(d, "resolution", new_delta(0, 0, 1, 0));
     DATETIME_ADD_MACRO(d, "min", new_delta(-MAX_DELTA_DAYS, 0, 0, 0));
     DATETIME_ADD_MACRO(d, "max",
                        new_delta(MAX_DELTA_DAYS, 24*3600-1, 1000000-1, 0));
 
     /* date values */
-    d = PyDateTime_DateType.tp_dict;
+    d = st->date_type->tp_dict;
     DATETIME_ADD_MACRO(d, "min", new_date(1, 1, 1));
     DATETIME_ADD_MACRO(d, "max", new_date(MAXYEAR, 12, 31));
     DATETIME_ADD_MACRO(d, "resolution", new_delta(1, 0, 0, 0));
 
     /* time values */
-    d = PyDateTime_TimeType.tp_dict;
+    d = st->time_type->tp_dict;
     DATETIME_ADD_MACRO(d, "min", new_time(0, 0, 0, 0, Py_None, 0));
     DATETIME_ADD_MACRO(d, "max", new_time(23, 59, 59, 999999, Py_None, 0));
     DATETIME_ADD_MACRO(d, "resolution", new_delta(0, 0, 1, 0));
 
     /* datetime values */
-    d = PyDateTime_DateTimeType.tp_dict;
+    d = st->datetime_type->tp_dict;
     DATETIME_ADD_MACRO(d, "min",
                        new_datetime(1, 1, 1, 0, 0, 0, 0, Py_None, 0));
     DATETIME_ADD_MACRO(d, "max", new_datetime(MAXYEAR, 12, 31, 23, 59, 59,
                                               999999, Py_None, 0));
     DATETIME_ADD_MACRO(d, "resolution", new_delta(0, 0, 1, 0));
 
-    datetime_state *st = STATIC_STATE();
-    if (init_state(st) < 0) {
-        goto error;
-    }
-
     /* timezone values */
-    d = PyDateTime_TimeZoneType.tp_dict;
+    d = st->timezone_type->tp_dict;
     if (PyDict_SetItemString(d, "utc", st->utc) < 0) {
         goto error;
     }