[clang-tidy] Correct union & macros handling in modernize-use-equals-default

[PiotrZSL]

Summary

To this moment this check were ignoring only inline
union special members, From now also out-of-line
special members going to be ignored. Also extended
support for IgnoreMacros to cover also macros used
inside a body, or used preprocesor directives.

Fixes:

• https://github.com/llvm/llvm-project/issues/28300
• https://github.com/llvm/llvm-project/issues/40554

[alexander-shaposhnikov]

LG

clang-tools-extra/clang-tidy/modernize/UseEqualsDefaultCheck.cpp

void UseEqualsDefaultCheck::registerMatchers(MatchFinder *Finder) {
   const LangOptions &LangOpts = getLangOpts();
   auto IsPublicOrOutOfLineUntilCPP20 =
       LangOpts.CPlusPlus20
           ? cxxConstructorDecl()
           : cxxConstructorDecl(anyOf(isOutOfLine(), isPublic()));
 
   // Destructor.
   Finder->addMatcher(
-      cxxDestructorDecl(unless(hasParent(IsUnionLikeClass)), isDefinition())
+      cxxDestructorDecl(isDefinition(), unless(ofClass(IsUnionLikeClass)))
           .bind(SpecialFunction),
       this);
+  // Constructor.
   Finder->addMatcher(
       cxxConstructorDecl(
-          unless(
-              hasParent(decl(anyOf(IsUnionLikeClass, functionTemplateDecl())))),
-          isDefinition(),
+          isDefinition(), unless(ofClass(IsUnionLikeClass)),
+          unless(hasParent(functionTemplateDecl())),
           anyOf(
               // Default constructor.
-              allOf(unless(hasAnyConstructorInitializer(isWritten())),
-                    unless(isVariadic()), parameterCountIs(0),
-                    IsPublicOrOutOfLineUntilCPP20),
+              allOf(parameterCountIs(0),
+                    unless(hasAnyConstructorInitializer(isWritten())),
+                    unless(isVariadic()), IsPublicOrOutOfLineUntilCPP20),
               // Copy constructor.
               allOf(isCopyConstructor(),
                     // Discard constructors that can be used as a copy
                     // constructor because all the other arguments have
                     // default values.
                     parameterCountIs(1))))
           .bind(SpecialFunction),
       this);
   // Copy-assignment operator.
   Finder->addMatcher(
-      cxxMethodDecl(unless(hasParent(
-                        decl(anyOf(IsUnionLikeClass, functionTemplateDecl())))),
-                    isDefinition(), isCopyAssignmentOperator(),
+      cxxMethodDecl(isDefinition(), isCopyAssignmentOperator(),
+                    unless(ofClass(IsUnionLikeClass)),
+                    unless(hasParent(functionTemplateDecl())),
                     // isCopyAssignmentOperator() allows the parameter to be
                     // passed by value, and in this case it cannot be
                     // defaulted.
                     hasParameter(0, hasType(lValueReferenceType())),
                     // isCopyAssignmentOperator() allows non lvalue reference
                     // return types, and in this case it cannot be defaulted.
                     returns(qualType(hasCanonicalType(
                         allOf(lValueReferenceType(pointee(type())),
void UseEqualsDefaultCheck::check(const MatchFinder::MatchResult &Result) {
   const auto *Body = dyn_cast<CompoundStmt>(SpecialFunctionDecl->getBody());
   if (!Body)
     return;
 
   // If there is code inside the body, don't warn.
   if (!SpecialFunctionDecl->isCopyAssignmentOperator() && !Body->body_empty())
     return;
 
+  // If body contain any preprocesor derictives, don't warn.
+  if (IgnoreMacros && utils::lexer::rangeContainsExpansionsOrDirectives(
+                          Body->getSourceRange(), *Result.SourceManager,
+                          Result.Context->getLangOpts()))
+    return;
+
   // If there are comments inside the body, don't do the change.
   bool ApplyFix = SpecialFunctionDecl->isCopyAssignmentOperator() ||
                   bodyEmpty(Result.Context, Body);
 
   std::vector<FixItHint> RemoveInitializers;
   unsigned MemberType;
   if (const auto *Ctor = dyn_cast<CXXConstructorDecl>(SpecialFunctionDecl)) {
     if (Ctor->getNumParams() == 0) {

clang-tools-extra/docs/ReleaseNotes.rst

- Deprecated check-local options `HeaderFileExtensions`
   <clang-tidy/checks/misc/unused-using-decls>` check.
   Global options of the same name should be used instead.
 
 - In :doc:`modernize-use-default-member-init
   <clang-tidy/checks/modernize/use-default-member-init>` count template
   constructors toward hand written constructors so that they are skipped if more
   than one exists.
 
+- Fixed false positive in :doc:`modernize-use-equals-default
+  <clang-tidy/checks/modernize/use-equals-default>` check for special member
+  functions containing macros or preprocessor directives, and out-of-line special
+  member functions in unions.
+
 - Fixed reading `HungarianNotation.CString.*` options in
   :doc:`readability-identifier-naming
   <clang-tidy/checks/readability/identifier-naming>` check.
 
 - Renamed `HungarianNotation.CString` options `CharPrinter` and
   `WideCharPrinter` to `CharPointer` and `WideCharPointer` respectively in
   :doc:`readability-identifier-naming
   <clang-tidy/checks/readability/identifier-naming>` check.

clang-tools-extra/docs/clang-tidy/checks/modernize/use-equals-default.rst

 .. note::
   Move-constructor and move-assignment operator are not supported yet.
 
 Options
 -------
 
 .. option:: IgnoreMacros
 
-   If set to `true`, the check will not give warnings inside macros. Default
-   is `true`.
+   If set to `true`, the check will not give warnings inside macros and will
+   ignore special members with bodies contain macros or preprocessor directives.
+   Default is `true`.

clang-tools-extra/test/clang-tidy/checkers/modernize/use-equals-default.cpp

 union NU {
   NU() {}
   // CHECK-FIXES: NU() {}
   ~NU() {}
   // CHECK-FIXES: ~NU() {}
   NE Field;
 };
 
+// Skip unions with out-of-line constructor/destructor.
+union NUO {
+  NUO();
+  ~NUO();
+  NE Field;
+};
+
+NUO::NUO() {}
+// CHECK-FIXES: NUO::NUO() {}
+NUO::~NUO() {}
+// CHECK-FIXES: NUO::~NUO() {}
+
 // Skip structs/classes containing anonymous unions.
 struct SU {
   SU() {}
   // CHECK-FIXES: SU() {}
   ~SU() {}
   // CHECK-FIXES: ~SU() {}
   union {
     NE Field;

 
 #define STRUCT_WITH_DEFAULT(_base, _type) \
   struct _type {                          \
     _type() {}                            \
     _base value;                          \
   };
 
 STRUCT_WITH_DEFAULT(unsigned char, InMacro)
+
+#define ZERO_VALUE 0
+struct PreprocesorDependentTest
+{
+  void something();
+
+  PreprocesorDependentTest() {
+#if ZERO_VALUE
+    something();
+#endif
+  }
+
+  ~PreprocesorDependentTest() {
+#if ZERO_VALUE
+    something();
+#endif
+  }
+};