refactor(ast, ast_tools): use full method path for generated derives trait calls.

crates/oxc_regular_expression/src/generated/derive_content_eq.rs

@@ -1,96 +1,109 @@
 // Auto-generated code, DO NOT EDIT DIRECTLY!
 // To edit this generated file you have to edit `tasks/ast_tools/src/derives/content_eq.rs`
 
+#![allow(clippy::match_like_matches_macro)]
+
 use oxc_span::cmp::ContentEq;
 
 #[allow(clippy::wildcard_imports)]
 use crate::ast::*;
 
 impl<'a> ContentEq for RegularExpression<'a> {
     fn content_eq(&self, other: &Self) -> bool {
-        self.pattern.content_eq(&other.pattern) && self.flags.content_eq(&other.flags)
+        ContentEq::content_eq(&self.pattern, &other.pattern)
+            && ContentEq::content_eq(&self.flags, &other.flags)
     }
 }
 
 impl ContentEq for Flags {
     fn content_eq(&self, other: &Self) -> bool {
-        self.global.content_eq(&other.global)
-            && self.ignore_case.content_eq(&other.ignore_case)
-            && self.multiline.content_eq(&other.multiline)
-            && self.unicode.content_eq(&other.unicode)
-            && self.sticky.content_eq(&other.sticky)
-            && self.dot_all.content_eq(&other.dot_all)
-            && self.has_indices.content_eq(&other.has_indices)
-            && self.unicode_sets.content_eq(&other.unicode_sets)
+        ContentEq::content_eq(&self.global, &other.global)
+            && ContentEq::content_eq(&self.ignore_case, &other.ignore_case)
+            && ContentEq::content_eq(&self.multiline, &other.multiline)
+            && ContentEq::content_eq(&self.unicode, &other.unicode)
+            && ContentEq::content_eq(&self.sticky, &other.sticky)
+            && ContentEq::content_eq(&self.dot_all, &other.dot_all)
+            && ContentEq::content_eq(&self.has_indices, &other.has_indices)
+            && ContentEq::content_eq(&self.unicode_sets, &other.unicode_sets)
     }
 }
 
 impl<'a> ContentEq for Pattern<'a> {
     fn content_eq(&self, other: &Self) -> bool {
-        self.body.content_eq(&other.body)
+        ContentEq::content_eq(&self.body, &other.body)
     }
 }
 
 impl<'a> ContentEq for Disjunction<'a> {
     fn content_eq(&self, other: &Self) -> bool {
-        self.body.content_eq(&other.body)
+        ContentEq::content_eq(&self.body, &other.body)
     }
 }
 
 impl<'a> ContentEq for Alternative<'a> {
     fn content_eq(&self, other: &Self) -> bool {
-        self.body.content_eq(&other.body)
+        ContentEq::content_eq(&self.body, &other.body)
     }
 }
 
 impl<'a> ContentEq for Term<'a> {
     fn content_eq(&self, other: &Self) -> bool {
         match self {
-            Self::BoundaryAssertion(it) => {
-                matches!(other, Self::BoundaryAssertion(other) if it.content_eq(other))
-            }
-            Self::LookAroundAssertion(it) => {
-                matches!(other, Self::LookAroundAssertion(other) if it.content_eq(other))
-            }
-            Self::Quantifier(it) => {
-                matches!(other, Self::Quantifier(other) if it.content_eq(other))
-            }
-            Self::Character(it) => {
-                matches!(other, Self::Character(other) if it.content_eq(other))
-            }
-            Self::Dot(it) => matches!(other, Self::Dot(other) if it.content_eq(other)),
-            Self::CharacterClassEscape(it) => {
-                matches!(
-                    other, Self::CharacterClassEscape(other) if it.content_eq(other)
-                )
-            }
-            Self::UnicodePropertyEscape(it) => {
-                matches!(
-                    other, Self::UnicodePropertyEscape(other) if it.content_eq(other)
-                )
-            }
-            Self::CharacterClass(it) => {
-                matches!(other, Self::CharacterClass(other) if it.content_eq(other))
-            }
-            Self::CapturingGroup(it) => {
-                matches!(other, Self::CapturingGroup(other) if it.content_eq(other))
-            }
-            Self::IgnoreGroup(it) => {
-                matches!(other, Self::IgnoreGroup(other) if it.content_eq(other))
-            }
-            Self::IndexedReference(it) => {
-                matches!(other, Self::IndexedReference(other) if it.content_eq(other))
-            }
-            Self::NamedReference(it) => {
-                matches!(other, Self::NamedReference(other) if it.content_eq(other))
-            }
+            Self::BoundaryAssertion(it) => match other {
+                Self::BoundaryAssertion(other) if ContentEq::content_eq(it, other) => true,
+                _ => false,
+            },
+            Self::LookAroundAssertion(it) => match other {
+                Self::LookAroundAssertion(other) if ContentEq::content_eq(it, other) => true,
+                _ => false,
+            },
+            Self::Quantifier(it) => match other {
+                Self::Quantifier(other) if ContentEq::content_eq(it, other) => true,
+                _ => false,
+            },
+            Self::Character(it) => match other {
+                Self::Character(other) if ContentEq::content_eq(it, other) => true,
+                _ => false,
+            },
+            Self::Dot(it) => match other {
+                Self::Dot(other) if ContentEq::content_eq(it, other) => true,
+                _ => false,
+            },
+            Self::CharacterClassEscape(it) => match other {
+                Self::CharacterClassEscape(other) if ContentEq::content_eq(it, other) => true,
+                _ => false,
+            },
+            Self::UnicodePropertyEscape(it) => match other {
+                Self::UnicodePropertyEscape(other) if ContentEq::content_eq(it, other) => true,
+                _ => false,
+            },
+            Self::CharacterClass(it) => match other {
+                Self::CharacterClass(other) if ContentEq::content_eq(it, other) => true,
+                _ => false,
+            },
+            Self::CapturingGroup(it) => match other {
+                Self::CapturingGroup(other) if ContentEq::content_eq(it, other) => true,
+                _ => false,
+            },
+            Self::IgnoreGroup(it) => match other {
+                Self::IgnoreGroup(other) if ContentEq::content_eq(it, other) => true,
+                _ => false,
+            },
+            Self::IndexedReference(it) => match other {
+                Self::IndexedReference(other) if ContentEq::content_eq(it, other) => true,
+                _ => false,
+            },
+            Self::NamedReference(it) => match other {
+                Self::NamedReference(other) if ContentEq::content_eq(it, other) => true,
+                _ => false,
+            },
         }
     }
 }
 
 impl ContentEq for BoundaryAssertion {
     fn content_eq(&self, other: &Self) -> bool {
-        self.kind.content_eq(&other.kind)
+        ContentEq::content_eq(&self.kind, &other.kind)
     }
 }
 
@@ -102,7 +115,8 @@ impl ContentEq for BoundaryAssertionKind {
 
 impl<'a> ContentEq for LookAroundAssertion<'a> {
     fn content_eq(&self, other: &Self) -> bool {
-        self.kind.content_eq(&other.kind) && self.body.content_eq(&other.body)
+        ContentEq::content_eq(&self.kind, &other.kind)
+            && ContentEq::content_eq(&self.body, &other.body)
     }
 }
 
@@ -114,16 +128,17 @@ impl ContentEq for LookAroundAssertionKind {
 
 impl<'a> ContentEq for Quantifier<'a> {
     fn content_eq(&self, other: &Self) -> bool {
-        self.min.content_eq(&other.min)
-            && self.max.content_eq(&other.max)
-            && self.greedy.content_eq(&other.greedy)
-            && self.body.content_eq(&other.body)
+        ContentEq::content_eq(&self.min, &other.min)
+            && ContentEq::content_eq(&self.max, &other.max)
+            && ContentEq::content_eq(&self.greedy, &other.greedy)
+            && ContentEq::content_eq(&self.body, &other.body)
     }
 }
 
 impl ContentEq for Character {
     fn content_eq(&self, other: &Self) -> bool {
-        self.kind.content_eq(&other.kind) && self.value.content_eq(&other.value)
+        ContentEq::content_eq(&self.kind, &other.kind)
+            && ContentEq::content_eq(&self.value, &other.value)
     }
 }
 
@@ -135,7 +150,7 @@ impl ContentEq for CharacterKind {
 
 impl ContentEq for CharacterClassEscape {
     fn content_eq(&self, other: &Self) -> bool {
-        self.kind.content_eq(&other.kind)
+        ContentEq::content_eq(&self.kind, &other.kind)
     }
 }
 
@@ -147,10 +162,10 @@ impl ContentEq for CharacterClassEscapeKind {
 
 impl<'a> ContentEq for UnicodePropertyEscape<'a> {
     fn content_eq(&self, other: &Self) -> bool {
-        self.negative.content_eq(&other.negative)
-            && self.strings.content_eq(&other.strings)
-            && self.name.content_eq(&other.name)
-            && self.value.content_eq(&other.value)
+        ContentEq::content_eq(&self.negative, &other.negative)
+            && ContentEq::content_eq(&self.strings, &other.strings)
+            && ContentEq::content_eq(&self.name, &other.name)
+            && ContentEq::content_eq(&self.value, &other.value)
     }
 }
 
@@ -162,9 +177,9 @@ impl ContentEq for Dot {
 
 impl<'a> ContentEq for CharacterClass<'a> {
     fn content_eq(&self, other: &Self) -> bool {
-        self.negative.content_eq(&other.negative)
-            && self.kind.content_eq(&other.kind)
-            && self.body.content_eq(&other.body)
+        ContentEq::content_eq(&self.negative, &other.negative)
+            && ContentEq::content_eq(&self.kind, &other.kind)
+            && ContentEq::content_eq(&self.body, &other.body)
     }
 }
 
@@ -177,84 +192,85 @@ impl ContentEq for CharacterClassContentsKind {
 impl<'a> ContentEq for CharacterClassContents<'a> {
     fn content_eq(&self, other: &Self) -> bool {
         match self {
-            Self::CharacterClassRange(it) => {
-                matches!(other, Self::CharacterClassRange(other) if it.content_eq(other))
-            }
-            Self::CharacterClassEscape(it) => {
-                matches!(
-                    other, Self::CharacterClassEscape(other) if it.content_eq(other)
-                )
-            }
-            Self::UnicodePropertyEscape(it) => {
-                matches!(
-                    other, Self::UnicodePropertyEscape(other) if it.content_eq(other)
-                )
-            }
-            Self::Character(it) => {
-                matches!(other, Self::Character(other) if it.content_eq(other))
-            }
-            Self::NestedCharacterClass(it) => {
-                matches!(
-                    other, Self::NestedCharacterClass(other) if it.content_eq(other)
-                )
-            }
-            Self::ClassStringDisjunction(it) => {
-                matches!(
-                    other, Self::ClassStringDisjunction(other) if it.content_eq(other)
-                )
-            }
+            Self::CharacterClassRange(it) => match other {
+                Self::CharacterClassRange(other) if ContentEq::content_eq(it, other) => true,
+                _ => false,
+            },
+            Self::CharacterClassEscape(it) => match other {
+                Self::CharacterClassEscape(other) if ContentEq::content_eq(it, other) => true,
+                _ => false,
+            },
+            Self::UnicodePropertyEscape(it) => match other {
+                Self::UnicodePropertyEscape(other) if ContentEq::content_eq(it, other) => true,
+                _ => false,
+            },
+            Self::Character(it) => match other {
+                Self::Character(other) if ContentEq::content_eq(it, other) => true,
+                _ => false,
+            },
+            Self::NestedCharacterClass(it) => match other {
+                Self::NestedCharacterClass(other) if ContentEq::content_eq(it, other) => true,
+                _ => false,
+            },
+            Self::ClassStringDisjunction(it) => match other {
+                Self::ClassStringDisjunction(other) if ContentEq::content_eq(it, other) => true,
+                _ => false,
+            },
         }
     }
 }
 
 impl ContentEq for CharacterClassRange {
     fn content_eq(&self, other: &Self) -> bool {
-        self.min.content_eq(&other.min) && self.max.content_eq(&other.max)
+        ContentEq::content_eq(&self.min, &other.min) && ContentEq::content_eq(&self.max, &other.max)
     }
 }
 
 impl<'a> ContentEq for ClassStringDisjunction<'a> {
     fn content_eq(&self, other: &Self) -> bool {
-        self.strings.content_eq(&other.strings) && self.body.content_eq(&other.body)
+        ContentEq::content_eq(&self.strings, &other.strings)
+            && ContentEq::content_eq(&self.body, &other.body)
     }
 }
 
 impl<'a> ContentEq for ClassString<'a> {
     fn content_eq(&self, other: &Self) -> bool {
-        self.strings.content_eq(&other.strings) && self.body.content_eq(&other.body)
+        ContentEq::content_eq(&self.strings, &other.strings)
+            && ContentEq::content_eq(&self.body, &other.body)
     }
 }
 
 impl<'a> ContentEq for CapturingGroup<'a> {
     fn content_eq(&self, other: &Self) -> bool {
-        self.name.content_eq(&other.name) && self.body.content_eq(&other.body)
+        ContentEq::content_eq(&self.name, &other.name)
+            && ContentEq::content_eq(&self.body, &other.body)
     }
 }
 
 impl<'a> ContentEq for IgnoreGroup<'a> {
     fn content_eq(&self, other: &Self) -> bool {
-        self.enabling_modifiers.content_eq(&other.enabling_modifiers)
-            && self.disabling_modifiers.content_eq(&other.disabling_modifiers)
-            && self.body.content_eq(&other.body)
+        ContentEq::content_eq(&self.enabling_modifiers, &other.enabling_modifiers)
+            && ContentEq::content_eq(&self.disabling_modifiers, &other.disabling_modifiers)
+            && ContentEq::content_eq(&self.body, &other.body)
     }
 }
 
 impl ContentEq for ModifierFlags {
     fn content_eq(&self, other: &Self) -> bool {
-        self.ignore_case.content_eq(&other.ignore_case)
-            && self.sticky.content_eq(&other.sticky)
-            && self.multiline.content_eq(&other.multiline)
+        ContentEq::content_eq(&self.ignore_case, &other.ignore_case)
+            && ContentEq::content_eq(&self.sticky, &other.sticky)
+            && ContentEq::content_eq(&self.multiline, &other.multiline)
     }
 }
 
 impl ContentEq for IndexedReference {
     fn content_eq(&self, other: &Self) -> bool {
-        self.index.content_eq(&other.index)
+        ContentEq::content_eq(&self.index, &other.index)
     }
 }
 
 impl<'a> ContentEq for NamedReference<'a> {
     fn content_eq(&self, other: &Self) -> bool {
-        self.name.content_eq(&other.name)
+        ContentEq::content_eq(&self.name, &other.name)
     }
 }