2 files changed, 31 insertions, 16 deletions

diff --git a/clang-tools-extra/clang-tidy/cppcoreguidelines/MacroUsageCheck.cpp b/clang-tools-extra/clang-tidy/cppcoreguidelines/MacroUsageCheck.cpp
index 47f563ba6ef..8b893c7c4ab 100644
--- a/clang-tools-extra/clang-tidy/cppcoreguidelines/MacroUsageCheck.cpp
+++ b/clang-tools-extra/clang-tidy/cppcoreguidelines/MacroUsageCheck.cpp
@@ -31,32 +31,41 @@ bool isCapsOnly(StringRef Name) {
 
 class MacroUsageCallbacks : public PPCallbacks {
 public:
-  MacroUsageCallbacks(MacroUsageCheck *Check, StringRef RegExp, bool CapsOnly)
-      : Check(Check), RegExp(RegExp), CheckCapsOnly(CapsOnly) {}
+  MacroUsageCallbacks(MacroUsageCheck *Check, const SourceManager &SM,
+                      StringRef RegExp, bool CapsOnly, bool IgnoreCommandLine)
+      : Check(Check), SM(SM), RegExp(RegExp), CheckCapsOnly(CapsOnly),
+        IgnoreCommandLineMacros(IgnoreCommandLine) {}
   void MacroDefined(const Token &MacroNameTok,
                     const MacroDirective *MD) override {
     if (MD->getMacroInfo()->isUsedForHeaderGuard() ||
         MD->getMacroInfo()->getNumTokens() == 0)
       return;
 
+    if (IgnoreCommandLineMacros &&
+        SM.isWrittenInCommandLineFile(MD->getLocation()))
+      return;
+
     StringRef MacroName = MacroNameTok.getIdentifierInfo()->getName();
     if (!CheckCapsOnly && !llvm::Regex(RegExp).match(MacroName))
-      Check->warnMacro(MD);
+      Check->warnMacro(MD, MacroName);
 
     if (CheckCapsOnly && !isCapsOnly(MacroName))
-      Check->warnNaming(MD);
+      Check->warnNaming(MD, MacroName);
   }
 
 private:
   MacroUsageCheck *Check;
+  const SourceManager &SM;
   StringRef RegExp;
   bool CheckCapsOnly;
+  bool IgnoreCommandLineMacros;
 };
 } // namespace
 
 void MacroUsageCheck::storeOptions(ClangTidyOptions::OptionMap &Opts) {
   Options.store(Opts, "AllowedRegexp", AllowedRegexp);
   Options.store(Opts, "CheckCapsOnly", CheckCapsOnly);
+  Options.store(Opts, "IgnoreCommandLineMacros", IgnoreCommandLineMacros);
 }
 
 void MacroUsageCheck::registerPPCallbacks(CompilerInstance &Compiler) {
@@ -64,31 +73,34 @@ void MacroUsageCheck::registerPPCallbacks(CompilerInstance &Compiler) {
     return;
 
   Compiler.getPreprocessor().addPPCallbacks(
-      llvm::make_unique<MacroUsageCallbacks>(this, AllowedRegexp,
-                                             CheckCapsOnly));
+      llvm::make_unique<MacroUsageCallbacks>(this, Compiler.getSourceManager(),
+                                             AllowedRegexp, CheckCapsOnly,
+                                             IgnoreCommandLineMacros));
 }
 
-void MacroUsageCheck::warnMacro(const MacroDirective *MD) {
+void MacroUsageCheck::warnMacro(const MacroDirective *MD, StringRef MacroName) {
   StringRef Message =
-      "macro used to declare a constant; consider using a 'constexpr' "
+      "macro '%0' used to declare a constant; consider using a 'constexpr' "
       "constant";
 
   /// A variadic macro is function-like at the same time. Therefore variadic
   /// macros are checked first and will be excluded for the function-like
   /// diagnostic.
   if (MD->getMacroInfo()->isVariadic())
-    Message = "variadic macro used; consider using a 'constexpr' "
+    Message = "variadic macro '%0' used; consider using a 'constexpr' "
               "variadic template function";
   else if (MD->getMacroInfo()->isFunctionLike())
-    Message = "function-like macro used; consider a 'constexpr' template "
+    Message = "function-like macro '%0' used; consider a 'constexpr' template "
               "function";
 
-  diag(MD->getLocation(), Message);
+  diag(MD->getLocation(), Message) << MacroName;
 }
 
-void MacroUsageCheck::warnNaming(const MacroDirective *MD) {
+void MacroUsageCheck::warnNaming(const MacroDirective *MD,
+                                 StringRef MacroName) {
   diag(MD->getLocation(), "macro definition does not define the macro name "
-                          "using all uppercase characters");
+                          "'%0' using all uppercase characters")
+      << MacroName;
 }
 
 } // namespace cppcoreguidelines
diff --git a/clang-tools-extra/clang-tidy/cppcoreguidelines/MacroUsageCheck.h b/clang-tools-extra/clang-tidy/cppcoreguidelines/MacroUsageCheck.h
index ff33310e6e5..a39d55a21d5 100644
--- a/clang-tools-extra/clang-tidy/cppcoreguidelines/MacroUsageCheck.h
+++ b/clang-tools-extra/clang-tidy/cppcoreguidelines/MacroUsageCheck.h
@@ -28,17 +28,20 @@ public:
   MacroUsageCheck(StringRef Name, ClangTidyContext *Context)
       : ClangTidyCheck(Name, Context),
         AllowedRegexp(Options.get("AllowedRegexp", "^DEBUG_*")),
-        CheckCapsOnly(Options.get("CheckCapsOnly", 0)) {}
+        CheckCapsOnly(Options.get("CheckCapsOnly", 0)),
+        IgnoreCommandLineMacros(Options.get("IgnoreCommandLineMacros", 1)) {}
   void storeOptions(ClangTidyOptions::OptionMap &Opts) override;
   void registerPPCallbacks(CompilerInstance &Compiler) override;
-  void warnMacro(const MacroDirective *MD);
-  void warnNaming(const MacroDirective *MD);
+  void warnMacro(const MacroDirective *MD, StringRef MacroName);
+  void warnNaming(const MacroDirective *MD, StringRef MacroName);
 
 private:
   /// A regular expression that defines how allowed macros must look like.
   std::string AllowedRegexp;
   /// Control if only the check shall only test on CAPS_ONLY macros.
   bool CheckCapsOnly;
+  /// Should the macros without a valid location be diagnosed?
+  bool IgnoreCommandLineMacros;
 };
 
 } // namespace cppcoreguidelines