Fix defstruct with bases using a StructMeta subclass - #1164

diff --git a/src/msgspec/_core.c b/src/msgspec/_core.c
index 5f15701..485b361 100644
--- a/src/msgspec/_core.c
+++ b/src/msgspec/_core.c
@@ -6902,6 +6902,50 @@ error:
 }
 
 
+/* Set `namespace["__module__"]` from the calling frame's globals, if not
+ * already present. This mirrors the inference `type.__new__` performs, but
+ * must happen before calling the metaclass: if the metaclass defines
+ * `__new__` in Python, `type.__new__` would otherwise see that frame and
+ * infer the metaclass's module rather than the caller's. Returns 0 on
+ * success, -1 with an exception set on error. */
+static int
+structmeta_infer_module(PyObject *namespace) {
+    PyObject *module_key = NULL, *name_key = NULL, *globals, *module;
+    int contains, status = -1;
+
+    module_key = PyUnicode_InternFromString("__module__");
+    if (module_key == NULL) goto done;
+    contains = PyDict_Contains(namespace, module_key);
+    if (contains != 0) {
+        status = contains < 0 ? -1 : 0;
+        goto done;
+    }
+
+    /* Borrowed reference; NULL without an exception if there's no frame */
+    globals = PyEval_GetGlobals();
+    if (globals == NULL) {
+        status = 0;
+        goto done;
+    }
+    name_key = PyUnicode_InternFromString("__name__");
+    if (name_key == NULL) goto done;
+    module = PyDict_GetItemWithError(globals, name_key);
+    if (module == NULL) {
+        status = PyErr_Occurred() ? -1 : 0;
+        goto done;
+    }
+    /* Hold a strong reference to the borrowed `__name__` while inserting */
+    Py_INCREF(module);
+    status = PyDict_SetItem(namespace, module_key, module);
+    Py_DECREF(module);
+
+done:
+    Py_XDECREF(module_key);
+    Py_XDECREF(name_key);
+    return status;
+}
+
+
 PyDoc_STRVAR(msgspec_defstruct__doc__,
 "defstruct(name, fields, *, bases=None, module=None, namespace=None, "
 "tag_field=None, tag=None, rename=None, omit_defaults=False, "
@@ -7005,6 +7049,9 @@ msgspec_defstruct(PyObject *self, PyObject *args, PyObject *kwargs)
         }
         if (PyDict_SetItemString(namespace, "__module__", module) < 0) goto cleanup;
     }
+    else if (structmeta_infer_module(namespace) < 0) {
+        goto cleanup;
+    }
 
     /* Handle bases */
     if (bases == NULL || bases == Py_None) {
diff --git a/tests/unit/test_struct.py b/tests/unit/test_struct.py
index fb5143c..e6e886a 100644
--- a/tests/unit/test_struct.py
+++ b/tests/unit/test_struct.py
@@ -2461,6 +2461,98 @@ class TestDefStruct:
         Test = defstruct("Test", [], module=None)
         assert Test.__module__ == "tests.unit.test_struct"
 
+    def test_defstruct_module_with_python_metaclass_new(self, monkeypatch):
+        # Infer the module from defstruct's caller, not a Python metaclass hook.
+        meta_globals = {
+            "__name__": "_defstruct_meta_mod",
+            "StructMeta": msgspec.StructMeta,
+        }
+        exec(
+            "class CustomMeta(StructMeta):\n"
+            "    def __new__(mcls, name, bases, ns, **kw):\n"
+            "        return super().__new__(mcls, name, bases, ns, **kw)\n",
+            meta_globals,
+        )
+        CustomMeta = meta_globals["CustomMeta"]
+
+        class Base(Struct, metaclass=CustomMeta):
+            pass
+
+        class Static(Base):
+            pass
+
+        assert Static.__module__ == __name__
+        Test = defstruct("Test", [], bases=(Base,))
+        assert Test.__module__ == __name__
+        Test = defstruct("Test", [], bases=(Base,), module=None)
+        assert Test.__module__ == __name__
+        Test = defstruct("Test", [], bases=(Base,), module="testmod")
+        assert Test.__module__ == "testmod"
+        Test = defstruct("Test", [], bases=(Base,), namespace={"__module__": "nsmod"})
+        assert Test.__module__ == "nsmod"
+        Test = defstruct(
+            "Test",
+            [],
+            bases=(Base,),
+            module="testmod",
+            namespace={"__module__": "nsmod"},
+        )
+        assert Test.__module__ == "testmod"
+
+        Point = defstruct("DefStructPicklePoint", ["x", "y"], bases=(Base,))
+        monkeypatch.setattr(
+            sys.modules[__name__], "DefStructPicklePoint", Point, raising=False
+        )
+        point = Point(1, 2)
+        assert pickle.loads(pickle.dumps(point)) == point
+
+    @pytest.mark.parametrize("module_value", [None, 123, "nsmod"])
+    @pytest.mark.parametrize("module_options", [{}, {"module": None}])
+    def test_defstruct_module_namespace_precedence(self, module_value, module_options):
+        namespace = {"__module__": module_value}
+        Test = defstruct("Test", [], namespace=namespace, **module_options)
+
+        class Static(Struct):
+            __module__ = module_value
+
+        assert Test.__module__ == Static.__module__
+        assert namespace == {"__module__": module_value}
+
+    @pytest.mark.parametrize("custom_meta", [False, True])
+    def test_defstruct_module_missing_globals_name(self, custom_meta):
+        class CustomMeta(msgspec.StructMeta):
+            def __new__(mcls, name, bases, namespace, **kwargs):
+                return super().__new__(mcls, name, bases, namespace, **kwargs)
+
+        class CustomBase(Struct, metaclass=CustomMeta):
+            pass
+
+        scope = {"Base": CustomBase if custom_meta else Struct, "defstruct": defstruct}
+        exec(
+            "Expected = type(Base)('Expected', (Base,), {})\n"
+            "Actual = defstruct('Actual', [], bases=(Base,))\n",
+            scope,
+        )
+        assert "__name__" not in scope
+        missing = object()
+        assert getattr(scope["Actual"], "__module__", missing) == getattr(
+            scope["Expected"], "__module__", missing
+        )
+
+    def test_defstruct_module_namespace_lookup_error(self):
+        error = RuntimeError("module namespace lookup failed")
+
+        class RaisingKey:
+            def __hash__(self):
+                return hash("__module__")
+
+            def __eq__(self, other):
+                raise error
+
+        with pytest.raises(RuntimeError) as raised:
+            defstruct("Test", [], namespace={RaisingKey(): "value"})
+        assert raised.value is error
+
     def test_defstruct_namespace(self):
         Test = defstruct(
             "Test", ["x", "y"], namespace={"add": lambda self: self.x + self.y}