clang-tidy: add IgnoreMacros option to modernize-use-default-member-init

[vmiklos]

Summary

And also enable it by default to be consistent with e.g.
modernize-use-using.

This helps e.g. when running this check on cppunit client code where the
macro is provided by the system, so there is no easy way to modify it.

[malcolm.parsons]

Should this option be shared?

[vmiklos]

In D32945#748135, @malcolm.parsons wrote:

Should this option be shared?

If the alternative is to make this a general clang-tidy option where all but these two checks ignore it, I think that's more confusing to the users. Or do you have an example option in mind that's shared only between a few checks?

[malcolm.parsons]

In D32945#748166, @vmiklos wrote:

In D32945#748135, @malcolm.parsons wrote:

Should this option be shared?

If the alternative is to make this a general clang-tidy option where all but these two checks ignore it, I think that's more confusing to the users. Or do you have an example option in mind that's shared only between a few checks?

See uses of OptionsView::getLocalOrGlobal().

[vmiklos]

In D32945#748225, @malcolm.parsons wrote:

See uses of OptionsView::getLocalOrGlobal().

Ah, I see. Then yes, I think it makes sense; e.g. for the above cppunit case ideally I want to avoid any kind of warning from macros, since none of them can be easily fixed in system headers. (And the other way around, if system headers are not a problem, then all kind of warnings inside macros are probably interesting.) The updated patch uses getLocalOrGlobal() for the new option.

[malcolm.parsons]

In D32945#748250, @vmiklos wrote:

The updated patch uses getLocalOrGlobal() for the new option.

Please change modernize-use-using to match.

[vmiklos]

In D32945#748604, @malcolm.parsons wrote:

Please change modernize-use-using to match.

Done.

[malcolm.parsons]

LGTM!

clang-tidy/modernize/UseDefaultMemberInitCheck.h

 
 private:
   void checkDefaultInit(const ast_matchers::MatchFinder::MatchResult &Result,
                         const CXXCtorInitializer *Init);
   void checkExistingInit(const ast_matchers::MatchFinder::MatchResult &Result,
                          const CXXCtorInitializer *Init);
 
   const bool UseAssignment;
+  const bool IgnoreMacros;
 };
 
 } // namespace modernize
 } // namespace tidy
 } // namespace clang
 
 #endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_MODERNIZE_USE_DEFAULT_MEMBER_INIT_H

clang-tidy/modernize/UseDefaultMemberInitCheck.cpp

static bool sameValue(const Expr *E1, const Expr *E2) {
   default:
     return false;
   }
 }
 
 UseDefaultMemberInitCheck::UseDefaultMemberInitCheck(StringRef Name,
                                                      ClangTidyContext *Context)
     : ClangTidyCheck(Name, Context),
-      UseAssignment(Options.get("UseAssignment", 0) != 0) {}
+      UseAssignment(Options.get("UseAssignment", 0) != 0),
+      IgnoreMacros(Options.get("IgnoreMacros", 1) != 0) {}
 
 void UseDefaultMemberInitCheck::storeOptions(
     ClangTidyOptions::OptionMap &Opts) {
   Options.store(Opts, "UseAssignment", UseAssignment);
+  Options.store(Opts, "IgnoreMacros", IgnoreMacros);
 }
 
 void UseDefaultMemberInitCheck::registerMatchers(MatchFinder *Finder) {
   if (!getLangOpts().CPlusPlus11)
     return;
 
   auto Init =
       anyOf(stringLiteral(), characterLiteral(), integerLiteral(),
void UseDefaultMemberInitCheck::check(const MatchFinder::MatchResult &Result) {
   else
     llvm_unreachable("Bad Callback. No node provided.");
 }
 
 void UseDefaultMemberInitCheck::checkDefaultInit(
     const MatchFinder::MatchResult &Result, const CXXCtorInitializer *Init) {
   const FieldDecl *Field = Init->getMember();
 
+  SourceLocation StartLoc = Field->getLocStart();
+  if (StartLoc.isMacroID() && IgnoreMacros)
+    return;
+
   SourceLocation FieldEnd =
       Lexer::getLocForEndOfToken(Field->getSourceRange().getEnd(), 0,
                                  *Result.SourceManager, getLangOpts());
   SourceLocation LParenEnd = Lexer::getLocForEndOfToken(
       Init->getLParenLoc(), 0, *Result.SourceManager, getLangOpts());
   CharSourceRange InitRange =
       CharSourceRange::getCharRange(LParenEnd, Init->getRParenLoc());
 

docs/clang-tidy/checks/modernize-use-default-member-init.rst

 .. code-block:: c++
 
   struct A {
     A() {}
     A(int i) : i(i) {}
     int i = 5;
     double j = 10.0;
   };
+
+.. option:: IgnoreMacros
+
+   If this option is set to non-zero (default is `1`), the check will not warn
+   about members declared inside macros.

test/clang-tidy/modernize-use-default-member-init-macros.cpp

+// RUN: %check_clang_tidy %s modernize-use-default-member-init %t -- \
+// RUN:   -config="{CheckOptions: [{key: modernize-use-default-member-init.IgnoreMacros, value: 0}]}" \
+// RUN:   -- -std=c++11
+
+#define MACRO() \
+  struct S { \
+    void *P; \
+    S() : P(nullptr) {} \
+  };
+
+MACRO();
+// CHECK-MESSAGES: :[[@LINE-1]]:1: warning: use default member initializer for 'P'
+
+struct S2 {
+  void *P;
+  // CHECK-MESSAGES: :[[@LINE-1]]:9: warning: use default member initializer for 'P'
+  S2() : P(nullptr) {}
+};

test/clang-tidy/modernize-use-default-member-init.cpp

 template <typename T>
 struct NegativeTemplateExisting {
   NegativeTemplateExisting(int) : t(0) {}
   T t{};
 };
 
 NegativeTemplateExisting<int> ntei(0);
 NegativeTemplateExisting<double> nted(0);
+
+// This resulted in a warning by default.
+#define MACRO() \
+  struct MacroS { \
+    void *P; \
+    MacroS() : P(nullptr) {} \
+  };
+
+MACRO();