diff --git a/crates/ruff_linter/src/rules/ruff/rules/dataclass_enum.rs b/crates/ruff_linter/src/rules/ruff/rules/dataclass_enum.rs
index ba2eab89148ad..da0f65d59deb3 100644
--- a/crates/ruff_linter/src/rules/ruff/rules/dataclass_enum.rs
+++ b/crates/ruff_linter/src/rules/ruff/rules/dataclass_enum.rs
@@ -63,7 +63,7 @@ impl AlwaysFixableViolation for DataclassEnum {
 pub(crate) fn dataclass_enum(checker: &mut Checker, class_def: &StmtClassDef) {
     let semantic = checker.semantic();
 
-    let Some(DataclassKind::Stdlib { decorator }) = dataclass_kind(class_def, semantic) else {
+    let Some((DataclassKind::Stdlib, decorator)) = dataclass_kind(class_def, semantic) else {
         return;
     };
 
diff --git a/crates/ruff_linter/src/rules/ruff/rules/function_call_in_dataclass_default.rs b/crates/ruff_linter/src/rules/ruff/rules/function_call_in_dataclass_default.rs
index 0c6a6beab78e0..b3dd673f488ae 100644
--- a/crates/ruff_linter/src/rules/ruff/rules/function_call_in_dataclass_default.rs
+++ b/crates/ruff_linter/src/rules/ruff/rules/function_call_in_dataclass_default.rs
@@ -77,19 +77,18 @@ pub(crate) fn function_call_in_dataclass_default(
 ) {
     let semantic = checker.semantic();
 
-    let Some(dataclass_kind) = dataclass_kind(class_def, semantic) else {
+    let Some((dataclass_kind, _)) = dataclass_kind(class_def, semantic) else {
         return;
     };
-    let decorator = dataclass_kind.decorator();
 
     if dataclass_kind.is_attrs() && checker.settings.preview.is_disabled() {
         return;
     }
 
     let attrs_auto_attribs = match dataclass_kind {
-        DataclassKind::Stdlib { .. } => None,
+        DataclassKind::Stdlib => None,
 
-        DataclassKind::Attrs { auto_attribs, .. } => match auto_attribs {
+        DataclassKind::Attrs(auto_attribs) => match auto_attribs {
             AttrsAutoAttribs::Unknown => return,
 
             AttrsAutoAttribs::None => {
@@ -105,11 +104,8 @@ pub(crate) fn function_call_in_dataclass_default(
     };
 
     let dataclass_kind = match attrs_auto_attribs {
-        None => DataclassKind::Stdlib { decorator },
-        Some(auto_attribs) => DataclassKind::Attrs {
-            auto_attribs,
-            decorator,
-        },
+        None => DataclassKind::Stdlib,
+        Some(auto_attribs) => DataclassKind::Attrs(auto_attribs),
     };
 
     let extend_immutable_calls: Vec<QualifiedName> = checker
diff --git a/crates/ruff_linter/src/rules/ruff/rules/helpers.rs b/crates/ruff_linter/src/rules/ruff/rules/helpers.rs
index eed2702df63b1..e02f500c6ed5f 100644
--- a/crates/ruff_linter/src/rules/ruff/rules/helpers.rs
+++ b/crates/ruff_linter/src/rules/ruff/rules/helpers.rs
@@ -49,8 +49,8 @@ pub(super) fn is_dataclass_field(
     dataclass_kind: DataclassKind,
 ) -> bool {
     match dataclass_kind {
-        DataclassKind::Attrs { .. } => is_attrs_field(func, semantic),
-        DataclassKind::Stdlib { .. } => is_stdlib_dataclass_field(func, semantic),
+        DataclassKind::Attrs(..) => is_attrs_field(func, semantic),
+        DataclassKind::Stdlib => is_stdlib_dataclass_field(func, semantic),
     }
 }
 
@@ -93,23 +93,21 @@ pub(super) enum AttrsAutoAttribs {
 }
 
 /// Enumeration of various kinds of dataclasses recognised by Ruff
-#[derive(Debug, Copy, Clone, PartialEq, is_macro::Is)]
-pub(super) enum DataclassKind<'a> {
+#[derive(Debug, Copy, Clone, PartialEq, Eq)]
+pub(super) enum DataclassKind {
     /// dataclasses created by the stdlib `dataclasses` module
-    Stdlib { decorator: &'a ast::Decorator },
+    Stdlib,
     /// dataclasses created by the third-party `attrs` library
-    Attrs {
-        auto_attribs: AttrsAutoAttribs,
-        decorator: &'a ast::Decorator,
-    },
+    Attrs(AttrsAutoAttribs),
 }
 
-impl<'a> DataclassKind<'a> {
-    pub(crate) fn decorator(self) -> &'a ast::Decorator {
-        match self {
-            Self::Stdlib { decorator } => decorator,
-            Self::Attrs { decorator, .. } => decorator,
-        }
+impl DataclassKind {
+    pub(super) const fn is_stdlib(self) -> bool {
+        matches!(self, DataclassKind::Stdlib)
+    }
+
+    pub(super) const fn is_attrs(self) -> bool {
+        matches!(self, DataclassKind::Attrs(..))
     }
 }
 
@@ -118,7 +116,7 @@ impl<'a> DataclassKind<'a> {
 pub(super) fn dataclass_kind<'a>(
     class_def: &'a ast::StmtClassDef,
     semantic: &SemanticModel,
-) -> Option<DataclassKind<'a>> {
+) -> Option<(DataclassKind, &'a ast::Decorator)> {
     if !(semantic.seen_module(Modules::DATACLASSES) || semantic.seen_module(Modules::ATTRS)) {
         return None;
     }
@@ -143,17 +141,11 @@ pub(super) fn dataclass_kind<'a>(
                         AttrsAutoAttribs::None
                     };
 
-                    return Some(DataclassKind::Attrs {
-                        auto_attribs,
-                        decorator,
-                    });
+                    return Some((DataclassKind::Attrs(auto_attribs), decorator));
                 };
 
                 let Some(auto_attribs) = arguments.find_keyword("auto_attribs") else {
-                    return Some(DataclassKind::Attrs {
-                        auto_attribs: AttrsAutoAttribs::None,
-                        decorator,
-                    });
+                    return Some((DataclassKind::Attrs(AttrsAutoAttribs::None), decorator));
                 };
 
                 let auto_attribs = match Truthiness::from_expr(&auto_attribs.value, |id| {
@@ -171,12 +163,9 @@ pub(super) fn dataclass_kind<'a>(
                     Truthiness::Unknown => AttrsAutoAttribs::Unknown,
                 };
 
-                return Some(DataclassKind::Attrs {
-                    auto_attribs,
-                    decorator,
-                });
+                return Some((DataclassKind::Attrs(auto_attribs), decorator));
             }
-            ["dataclasses", "dataclass"] => return Some(DataclassKind::Stdlib { decorator }),
+            ["dataclasses", "dataclass"] => return Some((DataclassKind::Stdlib, decorator)),
             _ => continue,
         }
     }
diff --git a/crates/ruff_linter/src/rules/ruff/rules/mutable_class_default.rs b/crates/ruff_linter/src/rules/ruff/rules/mutable_class_default.rs
index e4408c85bbd50..7b8fad19a1a01 100644
--- a/crates/ruff_linter/src/rules/ruff/rules/mutable_class_default.rs
+++ b/crates/ruff_linter/src/rules/ruff/rules/mutable_class_default.rs
@@ -66,7 +66,8 @@ pub(crate) fn mutable_class_default(checker: &mut Checker, class_def: &ast::Stmt
                     && !is_final_annotation(annotation, checker.semantic())
                     && !is_immutable_annotation(annotation, checker.semantic(), &[])
                 {
-                    if let Some(dataclass_kind) = dataclass_kind(class_def, checker.semantic()) {
+                    if let Some((dataclass_kind, _)) = dataclass_kind(class_def, checker.semantic())
+                    {
                         if dataclass_kind.is_stdlib() || checker.settings.preview.is_enabled() {
                             continue;
                         }
diff --git a/crates/ruff_linter/src/rules/ruff/rules/mutable_dataclass_default.rs b/crates/ruff_linter/src/rules/ruff/rules/mutable_dataclass_default.rs
index 00300421dba16..c06ff28d39932 100644
--- a/crates/ruff_linter/src/rules/ruff/rules/mutable_dataclass_default.rs
+++ b/crates/ruff_linter/src/rules/ruff/rules/mutable_dataclass_default.rs
@@ -68,7 +68,7 @@ impl Violation for MutableDataclassDefault {
 pub(crate) fn mutable_dataclass_default(checker: &mut Checker, class_def: &ast::StmtClassDef) {
     let semantic = checker.semantic();
 
-    let Some(dataclass_kind) = dataclass_kind(class_def, semantic) else {
+    let Some((dataclass_kind, _)) = dataclass_kind(class_def, semantic) else {
         return;
     };
 
diff --git a/crates/ruff_linter/src/rules/ruff/rules/post_init_default.rs b/crates/ruff_linter/src/rules/ruff/rules/post_init_default.rs
index bff8ee8621245..06cfb062f054f 100644
--- a/crates/ruff_linter/src/rules/ruff/rules/post_init_default.rs
+++ b/crates/ruff_linter/src/rules/ruff/rules/post_init_default.rs
@@ -93,7 +93,7 @@ pub(crate) fn post_init_default(checker: &mut Checker, function_def: &ast::StmtF
         ScopeKind::Class(class_def) => {
             if !matches!(
                 dataclass_kind(class_def, checker.semantic()),
-                Some(DataclassKind::Stdlib { .. })
+                Some((DataclassKind::Stdlib, _))
             ) {
                 return;
             }