[clang-tidy] Change the namespace for llvm checkers from 'llvm' to 'llvm_check'

[hintonda]

Summary

Change the namespace for llvm checkers from 'llvm' to
'llvm_check', and modify add_new_check.py and rename_check.py to
support the new namespace. Checker, file, and directory names remain
unchanged.

Used new version of rename_check.py to make the change in existing
llvm checkers, but had to fix LLVMTidyModule.cpp and
LLVMModuleTest.cpp by hand.

The changes to rename_check.py are idempotent, so if accidentally
run multiple times, it won't do anything.

[hintonda]

• Remove leftover comments, etc.

[hintonda]

• Add missing 'clang'.

[Eugene.Zelenko]

Please use check for consistency with rest of Clang-tidy.

[hintonda]

In D60629#1464945, @Eugene.Zelenko wrote:

Please use check for consistency with rest of Clang-tidy.

Thanks for taking a look — I’ll Fix that on the next upload. So are you okay with llvm_check? I sorta like it, but happy to use anything other than llvm, which caused the initial problem.

[aaron.ballman]

No opposition from me regarding llvm_check, though I think llvm_tidy might also be a reasonable option. I'm a bit less keen on llvm_checker as the name, but not strongly opposed.

clang-tools-extra/clang-tidy/add_new_check.py

382 ↗

(On Diff #194941)

I thought we were going with llvm_check?

[hintonda]

clang-tools-extra/clang-tidy/add_new_check.py

382 ↗

(On Diff #194941)

Just typo on my part. I the options mentioned before where things like llvm_project or llvm_proj, etc. I just settled on llvm_check because it sounded better -- then actually typed checker.

I'll fix it this afternoon.

[hintonda]

• Change llvm_checker to llvm_check.

[alexfh]

clang-tools-extra/clang-tidy/add_new_check.py

381 ↗

(On Diff #195278)

We don't have the clang module. No need to check for it here. If we ever add one (which I doubt), we can modify this script again. But for now let's remove this to avoid confusion.

clang-tools-extra/clang-tidy/rename_check.py

268 ↗

(On Diff #195278)

--?

Anyways, we don't have (or plan to have) a module named clang.

[hintonda]

clang-tools-extra/clang-tidy/add_new_check.py

381 ↗

(On Diff #195278)

No problem. Or we could outlaw it...

clang-tools-extra/clang-tidy/rename_check.py

268 ↗

(On Diff #195278)

Thanks for catching that...

[hintonda]

• Remove clang module check.

[alexfh]

clang-tools-extra/clang-tidy/add_new_check.py

381 ↗

(On Diff #195581)

I'd add an explanation: # Map module names to namespace names that don't conflict with widely used top-level namespaces.

And again, no need to mention clang here.

382 ↗

(On Diff #194941)

I have another suggestion re: the color of this bike shed, namely: llvm_checks. But I don't feel strongly about this.

clang-tools-extra/clang-tidy/rename_check.py

218 ↗

(On Diff #195581)

s/_Check/_CHECK/, maybe?

267 ↗

(On Diff #195581)

I believe, we should first construct the new namespace name (using exactly the same code as in add_new_check.py) and then check if it differs from the old one.

[hintonda]

clang-tools-extra/clang-tidy/rename_check.py

218 ↗

(On Diff #195581)

Not sure it matters, but args.old_check_name is all lower case, so we have to uppercase the entire string.

[hintonda]

• Address comments.

[alexfh]

clang-tools-extra/clang-tidy/rename_check.py

271 ↗

(On Diff #196011)

Why new_namespace == 'llvm_check' is needed? Can we figure out old_namespace and use the condition new_namespace != old_namespace instead?

[hintonda]

• Remove unnecessary comparison.

[hintonda]

• Change check back to previous version which is much clearer.
• Apply namespace change to new check.

[hintonda]

clang-tools-extra/clang-tidy/rename_check.py

267 ↗

(On Diff #195581)

Changed this back to the original check which was clearer and easier for the reader to grok.

We are checking two distinct things here, so be explicit. First, we check to see if the modules changed, e.g., from say from 'google' to 'modernize', then we check to see if the new module is 'llvm' and needs special handling.

Then, and only then, do we need to set the new_namespace variable, and we condition that on whether or not the new module name is 'llvm'.

[hintonda]

Ping. Is this the direction you'd like to go? Or would you prefer something else? thanks... don

[hintonda]

ping...

[aaron.ballman]

This LGTM, but you may want to wait a day or so to see if @alexfh has any remaining concerns.

[hintonda]

In D60629#1494908, @aaron.ballman wrote:

This LGTM, but you may want to wait a day or so to see if @alexfh has any remaining concerns.

Will do, thanks Aaron...

clang-tidy/add_new_check.py

for line in lines:
           f.write('  ' + cpp_file + '\n')
           file_added = True
       f.write(line)
 
   return True
 
 
 # Adds a header for the new check.
-def write_header(module_path, module, check_name, check_name_camel):
+def write_header(module_path, module, namespace, check_name, check_name_camel):
   check_name_dashes = module + '-' + check_name
   filename = os.path.join(module_path, check_name_camel) + '.h'
   print('Creating %s...' % filename)
   with open(filename, 'w') as f:
     header_guard = ('LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_' + module.upper() + '_'
                     + check_name_camel.upper() + '_H')
     f.write('//===--- ')
     f.write(os.path.basename(filename))

 
 #ifndef %(header_guard)s
 #define %(header_guard)s
 
 #include "../ClangTidyCheck.h"
 
 namespace clang {
 namespace tidy {
-namespace %(module)s {
+namespace %(namespace)s {
 
 /// FIXME: Write a short description.
 ///
 /// For the user-facing documentation see:
 /// http://clang.llvm.org/extra/clang-tidy/checks/%(check_name_dashes)s.html
 class %(check_name)s : public ClangTidyCheck {
 public:
   %(check_name)s(StringRef Name, ClangTidyContext *Context)
       : ClangTidyCheck(Name, Context) {}
   void registerMatchers(ast_matchers::MatchFinder *Finder) override;
   void check(const ast_matchers::MatchFinder::MatchResult &Result) override;
 };
 
-} // namespace %(module)s
+} // namespace %(namespace)s
 } // namespace tidy
 } // namespace clang
 
 #endif // %(header_guard)s
 """ % {'header_guard': header_guard,
        'check_name': check_name_camel,
        'check_name_dashes': check_name_dashes,
-       'module': module})
+       'module': module,
+       'namespace': namespace})
 
 
 # Adds the implementation of the new check.
-def write_implementation(module_path, module, check_name_camel):
+def write_implementation(module_path, module, namespace, check_name_camel):
   filename = os.path.join(module_path, check_name_camel) + '.cpp'
   print('Creating %s...' % filename)
   with open(filename, 'w') as f:
     f.write('//===--- ')
     f.write(os.path.basename(filename))
     f.write(' - clang-tidy ')
     f.write('-' * max(0, 51 - len(os.path.basename(filename))))
     f.write('-===//')
     f.write("""
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "%(check_name)s.h"
 #include "clang/AST/ASTContext.h"
 #include "clang/ASTMatchers/ASTMatchFinder.h"
 
 using namespace clang::ast_matchers;
 
 namespace clang {
 namespace tidy {
-namespace %(module)s {
+namespace %(namespace)s {
 
 void %(check_name)s::registerMatchers(MatchFinder *Finder) {
   // FIXME: Add matchers.
   Finder->addMatcher(functionDecl().bind("x"), this);
 }
 
 void %(check_name)s::check(const MatchFinder::MatchResult &Result) {
   // FIXME: Add callback implementation.
   const auto *MatchedDecl = Result.Nodes.getNodeAs<FunctionDecl>("x");
   if (MatchedDecl->getName().startswith("awesome_"))
     return;
   diag(MatchedDecl->getLocation(), "function %%0 is insufficiently awesome")
       << MatchedDecl;
   diag(MatchedDecl->getLocation(), "insert 'awesome'", DiagnosticIDs::Note)
       << FixItHint::CreateInsertion(MatchedDecl->getLocation(), "awesome_");
 }
 
-} // namespace %(module)s
+} // namespace %(namespace)s
 } // namespace tidy
 } // namespace clang
 """ % {'check_name': check_name_camel,
-       'module': module})
+       'module': module,
+       'namespace': namespace})
 
 
 # Modifies the module to include the new check.
 def adapt_module(module_path, module, check_name, check_name_camel):
   modulecpp = list(filter(
       lambda p: p.lower() == module.lower() + 'tidymodule.cpp',
       os.listdir(module_path)))[0]
   filename = os.path.join(module_path, modulecpp)
if check_name.startswith(module):
     return
   check_name_camel = ''.join(map(lambda elem: elem.capitalize(),
                                  check_name.split('-'))) + 'Check'
   clang_tidy_path = os.path.dirname(sys.argv[0])
   module_path = os.path.join(clang_tidy_path, module)
 
   if not adapt_cmake(module_path, check_name_camel):
     return
-  write_header(module_path, module, check_name, check_name_camel)
-  write_implementation(module_path, module, check_name_camel)
+
+  # Map module names to namespace names that don't conflict with widely used top-level namespaces.
+  if module == 'llvm':
+    namespace = module + '_check'
+  else:
+    namespace = module
+
+  write_header(module_path, module, namespace, check_name, check_name_camel)
+  write_implementation(module_path, module, namespace, check_name_camel)
   adapt_module(module_path, module, check_name, check_name_camel)
   add_release_notes(module_path, module, check_name)
   test_extension = language_to_extension.get(args.language)
   write_test(module_path, module, check_name, test_extension)
   write_docs(module_path, module, check_name)
   update_checks_list(clang_tidy_path)
   print('Done. Now it\'s your turn!')
 
 
 if __name__ == '__main__':
   main()

clang-tidy/llvm/HeaderGuardCheck.h

 //===--- HeaderGuardCheck.h - clang-tidy ------------------------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
-#ifndef LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_LLVM_HEADER_GUARD_CHECK_H
-#define LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_LLVM_HEADER_GUARD_CHECK_H
+#ifndef LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_LLVM_HEADERGUARDCHECK_H
+#define LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_LLVM_HEADERGUARDCHECK_H
 
 #include "../utils/HeaderGuard.h"
 
 namespace clang {
 namespace tidy {
-namespace llvm {
+namespace llvm_check {
 
 /// Finds and fixes header guards that do not adhere to LLVM style.
 /// For the user-facing documentation see:
 /// http://clang.llvm.org/extra/clang-tidy/checks/llvm-header-guard.html
 /// The check supports these options:
 ///   - `HeaderFileExtensions`: a comma-separated list of filename extensions of
 ///     header files (The filename extension should not contain "." prefix).
 ///     ",h,hh,hpp,hxx" by default.
 ///     For extension-less header files, using an empty string or leaving an
 ///     empty string between "," if there are other filename extensions.
 class LLVMHeaderGuardCheck : public utils::HeaderGuardCheck {
 public:
   LLVMHeaderGuardCheck(StringRef Name, ClangTidyContext *Context);
 
   bool shouldSuggestEndifComment(StringRef Filename) override { return false; }
   std::string getHeaderGuard(StringRef Filename, StringRef OldGuard) override;
 };
 
-} // namespace llvm
+} // namespace llvm_check
 } // namespace tidy
 } // namespace clang
 
-#endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_LLVM_HEADER_GUARD_CHECK_H
+#endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_LLVM_HEADERGUARDCHECK_H

clang-tidy/llvm/HeaderGuardCheck.cpp

 //===--- HeaderGuardCheck.cpp - clang-tidy --------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "HeaderGuardCheck.h"
 
 namespace clang {
 namespace tidy {
-namespace llvm {
+namespace llvm_check {
 
 LLVMHeaderGuardCheck::LLVMHeaderGuardCheck(StringRef Name,
                                            ClangTidyContext *Context)
     : HeaderGuardCheck(Name, Context) {}
 
 std::string LLVMHeaderGuardCheck::getHeaderGuard(StringRef Filename,
                                                  StringRef OldGuard) {
   std::string Guard = tooling::getAbsolutePath(Filename);
std::string LLVMHeaderGuardCheck::getHeaderGuard(StringRef Filename,
 
   // The prevalent style in clang is LLVM_CLANG_FOO_BAR_H
   if (StringRef(Guard).startswith("clang"))
     Guard = "LLVM_" + Guard;
 
   return StringRef(Guard).upper();
 }
 
-} // namespace llvm
+} // namespace llvm_check
 } // namespace tidy
 } // namespace clang

clang-tidy/llvm/IncludeOrderCheck.h

 //===--- IncludeOrderCheck.h - clang-tidy -----------------------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
-#ifndef LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_LLVM_INCLUDE_ORDER_CHECK_H
-#define LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_LLVM_INCLUDE_ORDER_CHECK_H
+#ifndef LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_LLVM_INCLUDEORDERCHECK_H
+#define LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_LLVM_INCLUDEORDERCHECK_H
 
 #include "../ClangTidyCheck.h"
 
 namespace clang {
 namespace tidy {
-namespace llvm {
+namespace llvm_check {
 
 /// Checks the correct order of `#includes`.
 ///
 /// See http://llvm.org/docs/CodingStandards.html#include-style
 class IncludeOrderCheck : public ClangTidyCheck {
 public:
   IncludeOrderCheck(StringRef Name, ClangTidyContext *Context)
       : ClangTidyCheck(Name, Context) {}
   void registerPPCallbacks(const SourceManager &SM, Preprocessor *PP,
                            Preprocessor *ModuleExpanderPP) override;
 };
 
-} // namespace llvm
+} // namespace llvm_check
 } // namespace tidy
 } // namespace clang
 
-#endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_LLVM_INCLUDE_ORDER_CHECK_H
+#endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_LLVM_INCLUDEORDERCHECK_H

clang-tidy/llvm/IncludeOrderCheck.cpp

 #include "clang/Frontend/CompilerInstance.h"
 #include "clang/Lex/PPCallbacks.h"
 #include "clang/Lex/Preprocessor.h"
 
 #include <map>
 
 namespace clang {
 namespace tidy {
-namespace llvm {
+namespace llvm_check {
 
 namespace {
 class IncludeOrderPPCallbacks : public PPCallbacks {
 public:
   explicit IncludeOrderPPCallbacks(ClangTidyCheck &Check,
                                    const SourceManager &SM)
       : LookForMainModule(true), Check(Check), SM(SM) {}
 
for (unsigned BI = 0, BE = Blocks.size() - 1; BI != BE; ++BI) {
         D << FixItHint::CreateReplacement(ToRange, FixedName);
       }
     }
   }
 
   IncludeDirectives.clear();
 }
 
-} // namespace llvm
+} // namespace llvm_check
 } // namespace tidy
 } // namespace clang

clang-tidy/llvm/LLVMTidyModule.cpp

 #include "../readability/NamespaceCommentCheck.h"
 #include "HeaderGuardCheck.h"
 #include "IncludeOrderCheck.h"
 #include "PreferIsaOrDynCastInConditionalsCheck.h"
 #include "TwineLocalCheck.h"
 
 namespace clang {
 namespace tidy {
-namespace llvm {
+namespace llvm_check {
 
 class LLVMModule : public ClangTidyModule {
 public:
   void addCheckFactories(ClangTidyCheckFactories &CheckFactories) override {
     CheckFactories.registerCheck<LLVMHeaderGuardCheck>("llvm-header-guard");
     CheckFactories.registerCheck<IncludeOrderCheck>("llvm-include-order");
     CheckFactories.registerCheck<readability::NamespaceCommentCheck>(
         "llvm-namespace-comment");
     CheckFactories.registerCheck<PreferIsaOrDynCastInConditionalsCheck>(
         "llvm-prefer-isa-or-dyn-cast-in-conditionals");
     CheckFactories.registerCheck<TwineLocalCheck>("llvm-twine-local");
   }
 };
 
 // Register the LLVMTidyModule using this statically initialized variable.
 static ClangTidyModuleRegistry::Add<LLVMModule> X("llvm-module",
                                                   "Adds LLVM lint checks.");
 
-} // namespace llvm
+} // namespace llvm_check
 
 // This anchor is used to force the linker to link in the generated object file
 // and thus register the LLVMModule.
 volatile int LLVMModuleAnchorSource = 0;
 
 } // namespace tidy
 } // namespace clang

clang-tidy/llvm/PreferIsaOrDynCastInConditionalsCheck.h

 //===--- PreferIsaOrDynCastInConditionalsCheck.h - clang-tidy ---*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
-#ifndef LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_LLVM_AVOIDCASTINCONDITIONALCHECK_H
-#define LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_LLVM_AVOIDCASTINCONDITIONALCHECK_H
+#ifndef LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_LLVM_PREFERISAORDYNCASTINCONDITIONALSCHECK_H
+#define LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_LLVM_PREFERISAORDYNCASTINCONDITIONALSCHECK_H
 
 #include "../ClangTidyCheck.h"
 
 namespace clang {
 namespace tidy {
-namespace llvm {
+namespace llvm_check {
 
 /// \brief Looks at conditionals and finds and replaces cases of ``cast<>``, which will
 /// assert rather than return a null pointer, and ``dyn_cast<>`` where
 /// the return value is not captured.  Additionally, finds and replaces cases that match the
 /// pattern ``var && isa<X>(var)``, where ``var`` is evaluated twice.
 ///
 /// Finds cases like these:
 /// \code

 public:
   PreferIsaOrDynCastInConditionalsCheck(StringRef Name,
                                         ClangTidyContext *Context)
       : ClangTidyCheck(Name, Context) {}
   void registerMatchers(ast_matchers::MatchFinder *Finder) override;
   void check(const ast_matchers::MatchFinder::MatchResult &Result) override;
 };
 
-} // namespace llvm
+} // namespace llvm_check
 } // namespace tidy
 } // namespace clang
 
-#endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_LLVM_AVOIDCASTINCONDITIONALCHECK_H
+#endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_LLVM_PREFERISAORDYNCASTINCONDITIONALSCHECK_H

clang-tidy/llvm/PreferIsaOrDynCastInConditionalsCheck.cpp

 using namespace clang::ast_matchers;
 
 namespace clang {
 namespace ast_matchers {
 AST_MATCHER(Expr, isMacroID) { return Node.getExprLoc().isMacroID(); }
 } // namespace ast_matchers
 
 namespace tidy {
-namespace llvm {
+namespace llvm_check {
 
 void PreferIsaOrDynCastInConditionalsCheck::registerMatchers(
     MatchFinder *Finder) {
   if (!getLangOpts().CPlusPlus)
     return;
 
   auto Condition = hasCondition(implicitCastExpr(has(
       callExpr(
diag(MatchedDecl->getBeginLoc(),
          "isa_and_nonnull<> is preferred over an explicit test for null "
          "followed by calling isa<>")
         << FixItHint::CreateReplacement(SourceRange(MatchedDecl->getBeginLoc(),
                                                     MatchedDecl->getEndLoc()),
                                         Replacement);
   }
 }
 
-} // namespace llvm
+} // namespace llvm_check
 } // namespace tidy
 } // namespace clang

clang-tidy/llvm/TwineLocalCheck.h

 //===--- TwineLocalCheck.h - clang-tidy -------------------------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
-#ifndef LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_LLVM_TWINE_LOCAL_CHECK_H
-#define LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_LLVM_TWINE_LOCAL_CHECK_H
+#ifndef LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_LLVM_TWINELOCALCHECK_H
+#define LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_LLVM_TWINELOCALCHECK_H
 
 #include "../ClangTidyCheck.h"
 
 namespace clang {
 namespace tidy {
-namespace llvm {
+namespace llvm_check {
 
 /// Looks for local `Twine` variables which are prone to use after frees and
 /// should be generally avoided.
 class TwineLocalCheck : public ClangTidyCheck {
 public:
   TwineLocalCheck(StringRef Name, ClangTidyContext *Context)
       : ClangTidyCheck(Name, Context) {}
   void registerMatchers(ast_matchers::MatchFinder *Finder) override;
   void check(const ast_matchers::MatchFinder::MatchResult &Result) override;
 };
 
-} // namespace llvm
+} // namespace llvm_check
 } // namespace tidy
 } // namespace clang
 
-#endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_LLVM_TWINE_LOCAL_CHECK_H
+#endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_LLVM_TWINELOCALCHECK_H

clang-tidy/llvm/TwineLocalCheck.cpp

 #include "clang/AST/ASTContext.h"
 #include "clang/ASTMatchers/ASTMatchers.h"
 #include "clang/Lex/Lexer.h"
 
 using namespace clang::ast_matchers;
 
 namespace clang {
 namespace tidy {
-namespace llvm {
+namespace llvm_check {
 
 void TwineLocalCheck::registerMatchers(MatchFinder *Finder) {
   auto TwineType =
       qualType(hasDeclaration(recordDecl(hasName("::llvm::Twine"))));
   Finder->addMatcher(varDecl(hasType(TwineType)).bind("variable"), this);
 }
 
 void TwineLocalCheck::check(const MatchFinder::MatchResult &Result) {
if (VD->getType()->getCanonicalTypeUnqualified() ==
       // Just an implicit conversion. Insert the real type.
       Diag << FixItHint::CreateReplacement(
           TypeRange,
           C->getType().getAsString(Result.Context->getPrintingPolicy()));
     }
   }
 }
 
-} // namespace llvm
+} // namespace llvm_check
 } // namespace tidy
 } // namespace clang

clang-tidy/rename_check.py

 #!/usr/bin/env python
 #
 #===- rename_check.py - clang-tidy check renamer -------------*- python -*--===#
 #
 # Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 # See https://llvm.org/LICENSE.txt for license information.
 # SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 #
 #===------------------------------------------------------------------------===#
 
 import argparse
 import glob
 import os
 import re
 
 
+def replaceInFileRegex(fileName, sFrom, sTo):
+  if sFrom == sTo:
+    return
+  txt = None
+  with open(fileName, "r") as f:
+    txt = f.read()
+
+  txt = re.sub(sFrom, sTo, txt)
+  print("Replacing '%s' -> '%s' in '%s'..." % (sFrom, sTo, fileName))
+  with open(fileName, "w") as f:
+    f.write(txt)
+
 def replaceInFile(fileName, sFrom, sTo):
   if sFrom == sTo:
     return
   txt = None
   with open(fileName, "r") as f:
     txt = f.read()
 
   if sFrom not in txt:
def main():
 
   new_check_name_camel = (''.join(map(lambda elem: elem.capitalize(),
                                       args.new_check_name.split('-')[1:])) +
                           'Check')
 
   clang_tidy_path = os.path.dirname(__file__)
 
   header_guard_variants = [
+      (args.old_check_name.replace('-', '_')).upper() + '_CHECK',
+      (old_module + '_' + check_name_camel).upper(),
       (old_module + '_' + new_check_name_camel).upper(),
       args.old_check_name.replace('-', '_').upper()]
   header_guard_new = (new_module + '_' + new_check_name_camel).upper()
 
   old_module_path = os.path.join(clang_tidy_path, old_module)
   new_module_path = os.path.join(clang_tidy_path, new_module)
 
+  if (args.old_check_name != args.new_check_name):
     # Remove the check from the old module.
     cmake_lists = os.path.join(old_module_path, 'CMakeLists.txt')
     check_found = deleteMatchingLines(cmake_lists, '\\b' + check_name_camel)
     if not check_found:
       print("Check name '%s' not found in %s. Exiting." %
             (check_name_camel, cmake_lists))
       return 1
 
     modulecpp = filter(
         lambda p: p.lower() == old_module.lower() + 'tidymodule.cpp',
         os.listdir(old_module_path))[0]
     deleteMatchingLines(os.path.join(old_module_path, modulecpp),
                       '\\b' + check_name_camel + '|\\b' + args.old_check_name)
 
   for filename in getListOfFiles(clang_tidy_path):
     originalName = filename
     filename = fileRename(filename, args.old_check_name,
                           args.new_check_name)
     filename = fileRename(filename, check_name_camel, new_check_name_camel)
     replaceInFile(filename, generateCommentLineHeader(originalName),
for filename in getListOfFiles(clang_tidy_path):
 
     replaceInFile(filename, args.old_check_name, args.new_check_name)
     replaceInFile(filename, old_module + '::' + check_name_camel,
                   new_module + '::' + new_check_name_camel)
     replaceInFile(filename, old_module + '/' + check_name_camel,
                   new_module + '/' + new_check_name_camel)
     replaceInFile(filename, check_name_camel, new_check_name_camel)
 
-  if old_module != new_module:
+  if old_module != new_module or new_module == 'llvm':
+    if new_module == 'llvm':
+      new_namespace = new_module + '_check'
+    else:
+      new_namespace = new_module
     check_implementation_files = glob.glob(
         os.path.join(old_module_path, new_check_name_camel + '*'))
     for filename in check_implementation_files:
       # Move check implementation to the directory of the new module.
       filename = fileRename(filename, old_module_path, new_module_path)
-      replaceInFile(filename, 'namespace ' + old_module,
-                    'namespace ' + new_module)
+      replaceInFileRegex(filename, 'namespace ' + old_module + '[^ \n]*',
+                         'namespace ' + new_namespace)
+
+  if (args.old_check_name == args.new_check_name):
+    return
 
   # Add check to the new module.
   adapt_cmake(new_module_path, new_check_name_camel)
   adapt_module(new_module_path, new_module, args.new_check_name,
                new_check_name_camel)
 
   os.system(os.path.join(clang_tidy_path, 'add_new_check.py')
             + ' --update-docs')
   add_release_notes(clang_tidy_path, args.old_check_name, args.new_check_name)
 
 if __name__ == '__main__':
   main()

unittests/clang-tidy/LLVMModuleTest.cpp

 #include "ClangTidyTest.h"
 #include "llvm/HeaderGuardCheck.h"
 #include "llvm/IncludeOrderCheck.h"
 #include "gtest/gtest.h"
 
-using namespace clang::tidy::llvm;
+using namespace clang::tidy::llvm_check;
 
 namespace clang {
 namespace tidy {
 namespace test {
 
 // FIXME: It seems this might be incompatible to dos path. Investigating.
 #if !defined(_WIN32)
 static std::string runHeaderGuardCheck(StringRef Code, const Twine &Filename,