Change DEBUG() macro to LLVM_DEBUG() in clang-tools-extra

[Nicola]

Summary

The DEBUG() macro is too generic so it might clash with other projects.
This is going to be deprecated and replaced by LLVM_DEBUG() as soon as https://reviews.llvm.org/D43624 is submitted.

This is the command I used to do the replacement and formatting:
git grep -l 'DEBUG' | xargs sed -i 's/\bDEBUG\s\?(/LLVM_DEBUG(/g'
git diff -U0 master | ../clang/tools/clang-format/clang-format-diff.py -i -p1 -style LLVM

[Nicola]

Ping? I'm not sure who to add as reviewers as it's generic change.

[rnk]

lgtm

clang-move/ClangMove.cpp

         MovedDecls.push_back(DCT);
       else
         MovedDecls.push_back(FWD);
     }
   } else if (const auto *ND =
                  Result.Nodes.getNodeAs<clang::NamedDecl>("helper_decls")) {
     MovedDecls.push_back(ND);
     HelperDeclarations.push_back(ND);
-    DEBUG(llvm::dbgs() << "Add helper : "
-                       << ND->getNameAsString() << " (" << ND << ")\n");
+    LLVM_DEBUG(llvm::dbgs() << "Add helper : " << ND->getNameAsString() << " ("
+                            << ND << ")\n");
   } else if (const auto *UD =
                  Result.Nodes.getNodeAs<clang::NamedDecl>("using_decl")) {
     MovedDecls.push_back(UD);
   }
 }
 
 std::string ClangMoveTool::makeAbsolutePath(StringRef Path) {
   return MakeAbsolutePath(Context->OriginalRunningDirectory, Path);

     for (const auto *D : UnremovedDeclsInOldHeader)
       UnremovedDecls.push_back(D);
 
     auto UsedDecls = getUsedDecls(RGBuilder.getGraph(), UnremovedDecls);
 
     // We remove the helper declarations which are not used in the old.cc after
     // moving the given declarations.
     for (const auto *D : HelperDeclarations) {
-      DEBUG(llvm::dbgs() << "Check helper is used: "
+      LLVM_DEBUG(llvm::dbgs() << "Check helper is used: "
                               << D->getNameAsString() << " (" << D << ")\n");
       if (!UsedDecls.count(HelperDeclRGBuilder::getOutmostClassOrFunDecl(
               D->getCanonicalDecl()))) {
-        DEBUG(llvm::dbgs() << "Helper removed in old.cc: "
+        LLVM_DEBUG(llvm::dbgs() << "Helper removed in old.cc: "
                                 << D->getNameAsString() << " (" << D << ")\n");
         RemovedDecls.push_back(D);
       }
     }
   }
 
   for (const auto *RemovedDecl : RemovedDecls) {
     const auto &SM = RemovedDecl->getASTContext().getSourceManager();
     auto Range = getFullRange(RemovedDecl);

   // We only move the used helpers (including transively used helpers) and the
   // given symbols being moved.
   for (const auto *D : NewCCDecls) {
     if (llvm::is_contained(HelperDeclarations, D) &&
         !UsedDecls.count(HelperDeclRGBuilder::getOutmostClassOrFunDecl(
             D->getCanonicalDecl())))
       continue;
 
-    DEBUG(llvm::dbgs() << "Helper used in new.cc: " << D->getNameAsString()
+    LLVM_DEBUG(llvm::dbgs() << "Helper used in new.cc: " << D->getNameAsString()
                             << " " << D << "\n");
     ActualNewCCDecls.push_back(D);
   }
 
   if (!Context->Spec.NewHeader.empty()) {
     std::string OldHeaderInclude =
         Context->Spec.NewDependOnOld
             ? "#include \"" + Context->Spec.OldHeader + "\"\n"
             : "";

   if (std::none_of(UnremovedDeclsInOldHeader.begin(),
                    UnremovedDeclsInOldHeader.end(), IsSupportedKind) &&
       !Context->Spec.OldHeader.empty()) {
     auto &SM = RemovedDecls[0]->getASTContext().getSourceManager();
     moveAll(SM, Context->Spec.OldHeader, Context->Spec.NewHeader);
     moveAll(SM, Context->Spec.OldCC, Context->Spec.NewCC);
     return;
   }
-  DEBUG(RGBuilder.getGraph()->dump());
+  LLVM_DEBUG(RGBuilder.getGraph()->dump());
   moveDeclsToNewFiles();
   removeDeclsInOldFiles();
 }
 
 } // namespace move
 } // namespace clang

clang-move/HelperDeclRefGraph.cpp

   //
   //   int MoveClass::F() { int a = helper(); return a; }
   //
   // The matched "dc" of "helper" DeclRefExpr is a VarDecl, we traverse up AST
   // to find the outmost "MoveClass" CXXRecordDecl and use it as Caller.
   if (const auto *FuncRef = Result.Nodes.getNodeAs<DeclRefExpr>("func_ref")) {
     const auto *DC = Result.Nodes.getNodeAs<Decl>("dc");
     assert(DC);
-    DEBUG(llvm::dbgs() << "Find helper function usage: "
+    LLVM_DEBUG(llvm::dbgs() << "Find helper function usage: "
                             << FuncRef->getDecl()->getNameAsString() << " ("
                             << FuncRef->getDecl() << ")\n");
     RG->addEdge(
         getOutmostClassOrFunDecl(DC->getCanonicalDecl()),
         getOutmostClassOrFunDecl(FuncRef->getDecl()->getCanonicalDecl()));
   } else if (const auto *UsedClass =
                  Result.Nodes.getNodeAs<CXXRecordDecl>("used_class")) {
     const auto *DC = Result.Nodes.getNodeAs<Decl>("dc");
     assert(DC);
-    DEBUG(llvm::dbgs() << "Find helper class usage: "
-                       << UsedClass->getNameAsString() << " (" << UsedClass
-                       << ")\n");
+    LLVM_DEBUG(llvm::dbgs()
+               << "Find helper class usage: " << UsedClass->getNameAsString()
+               << " (" << UsedClass << ")\n");
     RG->addEdge(getOutmostClassOrFunDecl(DC->getCanonicalDecl()), UsedClass);
   }
 }
 
 } // namespace move
 } // namespace clang

clang-tidy/ClangTidyOptions.cpp

     : DefaultOptionsProvider(GlobalOptions, DefaultOptions),
       OverrideOptions(OverrideOptions), ConfigHandlers(ConfigHandlers) {}
 
 // FIXME: This method has some common logic with clang::format::getStyle().
 // Consider pulling out common bits to a findParentFileWithName function or
 // similar.
 std::vector<OptionsSource>
 FileOptionsProvider::getRawOptions(StringRef FileName) {
-  DEBUG(llvm::dbgs() << "Getting options for file " << FileName << "...\n");
+  LLVM_DEBUG(llvm::dbgs() << "Getting options for file " << FileName
+                          << "...\n");
 
   std::vector<OptionsSource> RawOptions =
       DefaultOptionsProvider::getRawOptions(FileName);
   OptionsSource CommandLineOptions(OverrideOptions,
                                    OptionsSourceTypeCheckCommandLineOption);
   // Look for a suitable configuration file in all parent directories of the
   // file. Start with the immediate parent directory and move up.
   StringRef Path = llvm::sys::path::parent_path(FileName);
   for (StringRef CurrentPath = Path; !CurrentPath.empty();
        CurrentPath = llvm::sys::path::parent_path(CurrentPath)) {
     llvm::Optional<OptionsSource> Result;
 
     auto Iter = CachedOptions.find(CurrentPath);
     if (Iter != CachedOptions.end())
       Result = Iter->second;
 
     if (!Result)
       Result = tryReadConfigFile(CurrentPath);
 
     if (Result) {
       // Store cached value for all intermediate directories.
       while (Path != CurrentPath) {
-        DEBUG(llvm::dbgs() << "Caching configuration for path " << Path
+        LLVM_DEBUG(llvm::dbgs() << "Caching configuration for path " << Path
                                 << ".\n");
         CachedOptions[Path] = *Result;
         Path = llvm::sys::path::parent_path(Path);
       }
       CachedOptions[Path] = *Result;
 
       RawOptions.push_back(*Result);
       break;
     }

     llvm::errs() << "Error reading configuration from " << Directory
                  << ": directory doesn't exist.\n";
     return llvm::None;
   }
 
   for (const ConfigFileHandler &ConfigHandler : ConfigHandlers) {
     SmallString<128> ConfigFile(Directory);
     llvm::sys::path::append(ConfigFile, ConfigHandler.first);
-    DEBUG(llvm::dbgs() << "Trying " << ConfigFile << "...\n");
+    LLVM_DEBUG(llvm::dbgs() << "Trying " << ConfigFile << "...\n");
 
     bool IsFile = false;
     // Ignore errors from is_regular_file: we only need to know if we can read
     // the file or not.
     llvm::sys::fs::is_regular_file(Twine(ConfigFile), IsFile);
     if (!IsFile)
       continue;
 

clang-tidy/readability/IdentifierNamingCheck.cpp

       return;
 
     std::string KindName = fixupWithCase(StyleNames[SK], CT_LowerCase);
     std::replace(KindName.begin(), KindName.end(), '_', ' ');
 
     std::string Fixup = fixupWithStyle(Name, Style);
     if (StringRef(Fixup).equals(Name)) {
       if (!IgnoreFailedSplit) {
-        DEBUG(llvm::dbgs()
+        LLVM_DEBUG(llvm::dbgs()
                    << Decl->getLocStart().printToString(*Result.SourceManager)
                    << llvm::format(": unable to split words for %s '%s'\n",
                                    KindName.c_str(), Name.str().c_str()));
       }
     } else {
       NamingCheckFailure &Failure = NamingCheckFailures[NamingCheckId(
           Decl->getLocation(), Decl->getNameAsString())];
       SourceRange Range =
           DeclarationNameInfo(Decl->getDeclName(), Decl->getLocation())
               .getSourceRange();
 

 
   std::string KindName =
       fixupWithCase(StyleNames[SK_MacroDefinition], CT_LowerCase);
   std::replace(KindName.begin(), KindName.end(), '_', ' ');
 
   std::string Fixup = fixupWithStyle(Name, Style);
   if (StringRef(Fixup).equals(Name)) {
     if (!IgnoreFailedSplit) {
-      DEBUG(
-          llvm::dbgs() << MacroNameTok.getLocation().printToString(SourceMgr)
-                       << llvm::format(": unable to split words for %s '%s'\n",
-                                       KindName.c_str(), Name.str().c_str()));
+      LLVM_DEBUG(llvm::dbgs()
+                 << MacroNameTok.getLocation().printToString(SourceMgr)
     }
   } else {
     NamingCheckId ID(MI->getDefinitionLoc(), Name);
     NamingCheckFailure &Failure = NamingCheckFailures[ID];
     SourceRange Range(MacroNameTok.getLocation(), MacroNameTok.getEndLoc());
 
     Failure.Fixup = std::move(Fixup);
     Failure.KindName = std::move(KindName);

include-fixer/IncludeFixer.cpp

     clang::SourceLocation Loc, clang::QualType T) {
   // Ignore spurious callbacks from SFINAE contexts.
   if (CI->getSema().isSFINAEContext())
     return false;
 
   clang::ASTContext &context = CI->getASTContext();
   std::string QueryString = QualType(T->getUnqualifiedDesugaredType(), 0)
                                 .getAsString(context.getPrintingPolicy());
-  DEBUG(llvm::dbgs() << "Query missing complete type '" << QueryString << "'");
+  LLVM_DEBUG(llvm::dbgs() << "Query missing complete type '" << QueryString
+                          << "'");
   // Pass an empty range here since we don't add qualifier in this case.
   std::vector<find_all_symbols::SymbolInfo> MatchedSymbols =
       query(QueryString, "", tooling::Range());
 
   if (!MatchedSymbols.empty() && GenerateDiagnostics) {
     TypoCorrection Correction;
     FileID FID = CI->getSourceManager().getFileID(Loc);
     StringRef Code = CI->getSourceManager().getBufferData(FID);

 
     QueryString = ExtendNestedNameSpecifier(Range);
     SymbolRange = CreateToolingRange(Range.getBegin());
   } else {
     QueryString = Typo.getAsString();
     SymbolRange = CreateToolingRange(Typo.getLoc());
   }
 
-  DEBUG(llvm::dbgs() << "TypoScopeQualifiers: " << TypoScopeString << "\n");
+  LLVM_DEBUG(llvm::dbgs() << "TypoScopeQualifiers: " << TypoScopeString
+                          << "\n");
   std::vector<find_all_symbols::SymbolInfo> MatchedSymbols =
       query(QueryString, TypoScopeString, SymbolRange);
 
   if (!MatchedSymbols.empty() && GenerateDiagnostics) {
     TypoCorrection Correction(Typo.getName());
     Correction.setCorrectionRange(SS, Typo);
     FileID FID = SM.getFileID(Typo.getLoc());
     StringRef Code = SM.getBufferData(FID);

   if (!GenerateDiagnostics && !QuerySymbolInfos.empty()) {
     if (ScopedQualifiers == QuerySymbolInfos.front().ScopedQualifiers &&
         Query == QuerySymbolInfos.front().RawIdentifier) {
       QuerySymbolInfos.push_back({Query.str(), ScopedQualifiers, Range});
     }
     return {};
   }
 
-  DEBUG(llvm::dbgs() << "Looking up '" << Query << "' at ");
-  DEBUG(CI->getSourceManager()
+  LLVM_DEBUG(llvm::dbgs() << "Looking up '" << Query << "' at ");
+  LLVM_DEBUG(CI->getSourceManager()
                  .getLocForStartOfFile(CI->getSourceManager().getMainFileID())
                  .getLocWithOffset(Range.getOffset())
                  .print(llvm::dbgs(), CI->getSourceManager()));
-  DEBUG(llvm::dbgs() << " ...");
+  LLVM_DEBUG(llvm::dbgs() << " ...");
   llvm::StringRef FileName = CI->getSourceManager().getFilename(
       CI->getSourceManager().getLocForStartOfFile(
           CI->getSourceManager().getMainFileID()));
 
   QuerySymbolInfos.push_back({Query.str(), ScopedQualifiers, Range});
 
   // Query the symbol based on C++ name Lookup rules.
   // Firstly, lookup the identifier with scoped namespace contexts;

   // It's unsafe to do nested search for the identifier with scoped namespace
   // context, it might treat the identifier as a nested class of the scoped
   // namespace.
   std::vector<find_all_symbols::SymbolInfo> MatchedSymbols =
       SymbolIndexMgr.search(QueryString, /*IsNestedSearch=*/false, FileName);
   if (MatchedSymbols.empty())
     MatchedSymbols =
         SymbolIndexMgr.search(Query, /*IsNestedSearch=*/true, FileName);
-  DEBUG(llvm::dbgs() << "Having found " << MatchedSymbols.size()
+  LLVM_DEBUG(llvm::dbgs() << "Having found " << MatchedSymbols.size()
                           << " symbols\n");
   // We store a copy of MatchedSymbols in a place where it's globally reachable.
   // This is used by the standalone version of the tool.
   this->MatchedSymbols = MatchedSymbols;
   return MatchedSymbols;
 }
 
 llvm::Expected<tooling::Replacements> createIncludeFixerReplacements(
     StringRef Code, const IncludeFixerContext &Context,

include-fixer/SymbolIndexManager.cpp

   std::vector<SymbolAndSignals> MatchedSymbols;
   do {
     std::vector<SymbolAndSignals> Symbols;
     for (const auto &DB : SymbolIndices) {
       auto Res = DB.get()->search(Names.back());
       Symbols.insert(Symbols.end(), Res.begin(), Res.end());
     }
 
-    DEBUG(llvm::dbgs() << "Searching " << Names.back() << "... got "
+    LLVM_DEBUG(llvm::dbgs() << "Searching " << Names.back() << "... got "
                             << Symbols.size() << " results...\n");
 
     for (auto &SymAndSig : Symbols) {
       const SymbolInfo &Symbol = SymAndSig.Symbol;
       // Match the identifier name without qualifier.
       bool IsMatched = true;
       auto SymbolContext = Symbol.getContexts().begin();
       auto IdentiferContext = Names.rbegin() + 1; // Skip identifier name.
       // Match the remaining context names.