@@ -79,7 +79,9 @@ def dunder_attr_slot(cl: ClassIR, fn: FuncIR, emitter: Emitter) -> str:
     "__hash__": ("tp_hash", generate_hash_wrapper),
     "__get__": ("tp_descr_get", generate_get_wrapper),
     "__getattr__": ("tp_getattro", dunder_attr_slot),
-    "__setattr__": ("tp_setattro", dunder_attr_slot),
+    # The wrapper is also generated for a class that defines only __delattr__, so fill
+    # the slot based on the wrapper instead of __setattr__.
+    "__setattr____wrapper": ("tp_setattro", native_slot),
 }
 
 AS_MAPPING_SLOT_DEFS: SlotTable = {
 
@@ -429,7 +429,7 @@ def generate_getattr_wrapper(builder: IRBuilder, cdef: ClassDef, getattr: FuncDe
         builder.add(Return(getattr_result, line))
 
 
-def generate_setattr_wrapper(builder: IRBuilder, cdef: ClassDef, setattr: FuncDef) -> None:
+def generate_setattr_wrapper(builder: IRBuilder, cdef: ClassDef, fdef: FuncDef) -> None:
     """
     Generate a wrapper function for __setattr__ that can be put into the tp_setattro slot.
     The wrapper takes two arguments besides self - attribute name and the new value.
@@ -440,16 +440,21 @@ def generate_setattr_wrapper(builder: IRBuilder, cdef: ClassDef, setattr: FuncDe
     When it's NULL, this means that the call to tp_setattro comes from a del statement,
     so it calls __delattr__ instead. If __delattr__ is not overridden in the native class,
     this will call the base implementation in object which doesn't work without __dict__.
+
+    The wrapper is generated for a class that defines __setattr__, and for a class that
+    defines only __delattr__ and inherits __setattr__ from a native class. The argument
+    fdef is the definition of __setattr__ in the first case and of __delattr__ in the second.
     """
-    name = setattr.name + "__wrapper"
+    name = "__setattr____wrapper"
     ir = builder.mapper.type_to_ir[cdef.info]
-    line = setattr.line
+    line = fdef.line
 
-    error_base = f'"__setattr__" not supported in class "{cdef.name}" because '
-    if ir.allow_interpreted_subclasses:
-        builder.error(error_base + "it allows interpreted subclasses", line)
-    if ir.inherits_python:
-        builder.error(error_base + "it inherits from a non-native class", line)
+    if fdef.name == "__setattr__":
+        error_base = f'"__setattr__" not supported in class "{cdef.name}" because '
+        if ir.allow_interpreted_subclasses:
+            builder.error(error_base + "it allows interpreted subclasses", line)
+        if ir.inherits_python:
+            builder.error(error_base + "it inherits from a non-native class", line)
 
     with builder.enter_method(ir, name, c_int_rprimitive, internal=True):
         attr_arg = builder.add_argument("attr", object_rprimitive)
@@ -476,7 +481,7 @@ def generate_setattr_wrapper(builder: IRBuilder, cdef: ClassDef, setattr: FuncDe
         builder.add(Return(Integer(0, c_int_rprimitive), line))
 
         builder.activate_block(call_setattr)
-        builder.gen_method_call(builder.self(), setattr.name, [attr_arg, value_arg], None, line)
+        builder.gen_method_call(builder.self(), "__setattr__", [attr_arg, value_arg], None, line)
         builder.add(Return(Integer(0, c_int_rprimitive), line))
 
 
@@ -578,6 +583,15 @@ def handle_ext_method(builder: IRBuilder, cdef: ClassDef, fdef: FuncDef) -> None
                 + "or inherit from a native class that overrides it.",
                 fdef.line,
             )
+        elif "__setattr__" not in class_ir.method_decls:
+            # The class inherits __setattr__. If that comes from a native class, the class
+            # would also inherit its tp_setattro wrapper, which was generated without this
+            # __delattr__ and may not call it. So generate a wrapper for this class as well.
+            setattr_cls = next(
+                (base for base in class_ir.mro if "__setattr__" in base.method_decls), None
+            )
+            if setattr_cls is not None and setattr_cls.is_ext_class:
+                generate_setattr_wrapper(builder, cdef, fdef)
 
 
 def handle_non_ext_method(
 
@@ -2498,6 +2498,116 @@ class InheritedSetAttr(SetAttr):
     def __delattr__(self, attr: str) -> None:
         pass
 
+[case testDelAttrWithInheritedSetAttr]
+from mypy_extensions import mypyc_attr
+
+class SetAttr:
+    _attributes: dict[str, object]
+
+    def __setattr__(self, key: str, val: object) -> None:
+        self._attributes[key] = val
+
+class DelAttr(SetAttr):
+    def __delattr__(self, key: str) -> None:
+        del self._attributes[key]
+
+@mypyc_attr(native_class=False)
+class NonNative:
+    def __setattr__(self, key: str, val: object) -> None:
+        pass
+
+class InheritsNonNative(NonNative):
+    def __delattr__(self, key: str) -> None:
+        pass
+
+[out]
+def SetAttr.__setattr__(self, key, val):
+    self :: __main__.SetAttr
+    key :: str
+    val :: object
+    r0 :: dict
+    r1 :: i32
+    r2 :: bit
+L0:
+    r0 = self._attributes
+    r1 = CPyDict_SetItem(r0, key, val)
+    r2 = r1 >= 0 :: signed
+    return 1
+def SetAttr.__setattr____wrapper(__mypyc_self__, attr, value):
+    __mypyc_self__ :: __main__.SetAttr
+    attr, value :: object
+    r0 :: bit
+    r1 :: i32
+    r2 :: bit
+    r3 :: str
+    r4 :: None
+L0:
+    r0 = value == 0
+    if r0 goto L1 else goto L2 :: bool
+L1:
+    r1 = CPyObject_GenericSetAttr(__mypyc_self__, attr, 0)
+    r2 = r1 >= 0 :: signed
+    return 0
+L2:
+    r3 = cast(str, attr)
+    r4 = __mypyc_self__.__setattr__(r3, value)
+    return 0
+def DelAttr.__delattr__(self, key):
+    self :: __main__.DelAttr
+    key :: str
+    r0 :: dict
+    r1 :: i32
+    r2 :: bit
+L0:
+    r0 = self._attributes
+    r1 = PyObject_DelItem(r0, key)
+    r2 = r1 >= 0 :: signed
+    return 1
+def DelAttr.__setattr____wrapper(__mypyc_self__, attr, value):
+    __mypyc_self__ :: __main__.DelAttr
+    attr, value :: object
+    r0 :: bit
+    r1 :: str
+    r2 :: None
+    r3 :: str
+    r4 :: None
+L0:
+    r0 = value == 0
+    if r0 goto L1 else goto L2 :: bool
+L1:
+    r1 = cast(str, attr)
+    r2 = __mypyc_self__.__delattr__(r1)
+    return 0
+L2:
+    r3 = cast(str, attr)
+    r4 = __mypyc_self__.__setattr__(r3, value)
+    return 0
+def __setattr___NonNative_obj.__get__(__mypyc_self__, instance, owner):
+    __mypyc_self__, instance, owner, r0 :: object
+    r1 :: bit
+    r2 :: object
+L0:
+    r0 = load_address _Py_NoneStruct
+    r1 = instance == r0
+    if r1 goto L1 else goto L2 :: bool
+L1:
+    return __mypyc_self__
+L2:
+    r2 = PyMethod_New(__mypyc_self__, instance)
+    return r2
+def __setattr___NonNative_obj.__call__(__mypyc_self__, self, key, val):
+    __mypyc_self__ :: __main__.__setattr___NonNative_obj
+    self :: __main__.NonNative
+    key :: str
+    val :: object
+L0:
+    return 1
+def InheritsNonNative.__delattr__(self, key):
+    self :: __main__.InheritsNonNative
+    key :: str
+L0:
+    return 1
+
 [case testSetAttr]
 from typing import ClassVar
 class SetAttr:
 
@@ -6160,6 +6160,103 @@ def test_deletable_attr() -> None:
 
 test_deletable_attr()
 
+[case testDunderDelAttrWithInheritedSetAttr]
+from mypy_extensions import mypyc_attr
+from testutil import assertRaises
+from typing import Any
+
+log: list[str] = []
+
+class SetAttr:
+    _attributes: dict[str, object]
+
+    def __init__(self) -> None:
+        object.__setattr__(self, "_attributes", {})
+
+    def __setattr__(self, key: str, val: object) -> None:
+        self._attributes[key] = val
+
+class SetAttrInherited(SetAttr):
+    pass
+
+class DelAttr(SetAttr):
+    def __delattr__(self, key: str) -> None:
+        log.append("DelAttr")
+        del self._attributes[key]
+
+class DelAttrInherited(DelAttr):
+    pass
+
+class DelAttrOverridden(DelAttr):
+    def __delattr__(self, key: str) -> None:
+        log.append("DelAttrOverridden")
+        super().__delattr__(key)
+
+class DelAttrInSubSubclass(SetAttrInherited):
+    def __delattr__(self, key: str) -> None:
+        log.append("DelAttrInSubSubclass")
+        del self._attributes[key]
+
+class SetAttrOverridden(DelAttr):
+    def __setattr__(self, key: str, val: object) -> None:
+        super().__setattr__(key, val)
+
+@mypyc_attr(native_class=False)
+class NonNative:
+    _attributes: dict[str, object]
+
+    def __init__(self) -> None:
+        object.__setattr__(self, "_attributes", {})
+
+    def __setattr__(self, key: str, val: object) -> None:
+        self._attributes[key] = val
+
+class DelAttrNonNativeBase(NonNative):
+    def __delattr__(self, key: str) -> None:
+        log.append("DelAttrNonNativeBase")
+        del self._attributes[key]
+
+def check_delattr(i: Any, calls: list[str]) -> None:
+    i.one = 1
+    i.two = 2
+    i.three = 3
+    assert i._attributes == {"one": 1, "two": 2, "three": 3}
+
+    log.clear()
+    del i.one
+    assert log == calls
+    assert i._attributes == {"two": 2, "three": 3}
+
+    delattr(i, "two")
+    assert log == calls * 2
+    assert i._attributes == {"three": 3}
+
+    i.__delattr__("three")
+    assert log == calls * 3
+    assert i._attributes == {}
+
+    with assertRaises(KeyError):
+        del i.one
+
+def test_delattr_with_inherited_setattr() -> None:
+    check_delattr(DelAttr(), ["DelAttr"])
+    check_delattr(DelAttrInherited(), ["DelAttr"])
+    check_delattr(DelAttrOverridden(), ["DelAttrOverridden", "DelAttr"])
+    check_delattr(DelAttrInSubSubclass(), ["DelAttrInSubSubclass"])
+    check_delattr(SetAttrOverridden(), ["DelAttr"])
+    check_delattr(DelAttrNonNativeBase(), ["DelAttrNonNativeBase"])
+
+def test_inherited_setattr_without_delattr() -> None:
+    i: Any = SetAttr()
+    i.one = 1
+    with assertRaises(AttributeError):
+        del i.one
+
+    i = SetAttrInherited()
+    i.one = 1
+    with assertRaises(AttributeError):
+        del i.one
+
 [case testBufferCorruptedData_librt_internal]
 from librt.internal import (
     ReadBuffer, read_bool, read_str, read_float, read_int, read_tag, read_bytes