[clang-tidy] Rename llvm checkers to llvm-project

[hintonda]

Summary

Rename llvm checkers to llvm-project, and namespace from llvm to llvm_project.

Includes renaming llvm directory, many files with llvm- in the name, and updating code and docs.

[alexfh]

The change looks fine, but I don't understand the description of this revision. Could you clarify which checkers you're talking about and which bug you observe?

[aaron.ballman]

clang-tools-extra/clang-tidy/utils/HeaderFileExtensionsUtils.h

21 ↗

(On Diff #193362)

I do not like that we're removing the namespace qualifier here. I would prefer to leave it as ::llvm::SmallSet<::llvm::StringRef, 5> if there is a namespace clash.

[hintonda]

In D60151#1453099, @alexfh wrote:

The change looks fine, but I don't understand the description of this revision. Could you clarify which checkers you're talking about and which bug you observe?

Sorry for not being clearer in my original description.

The error can be triggered by opening up a new llvm namespace under clang::tidy prior to referencing llvm::SmallSet, which would happened if a new llvm checker that gets included in LLVMTidyModule.cpp before HeaderGuardCheck.h -- HeaderGuardCheck.h includes HeaderFileExternsions.h prior to opening the new llvm namespace. Here's the error message you'd get:

llvm-project/clang-tools-extra/clang-tidy/llvm/../utils/../utils/HeaderFileExtensionsUtils.h:24:9: error: no template named 'SmallSet' in namespace 'clang::tidy::llvm'; did you mean '::llvm::SmallSet'?
typedef llvm::SmallSet<llvm::StringRef, 5> HeaderFileExtensionsSet;
        ^~~~~~~~~~~~~~
        ::llvm::SmallSet
llvm-project/llvm/include/llvm/ADT/SmallSet.h:134:7: note: '::llvm::SmallSet' declared here
class SmallSet {
      ^
llvm-project/clang-tools-extra/clang-tidy/llvm/../utils/../utils/HeaderFileExtensionsUtils.h:24:30: error: no member named 'StringRef' in namespace 'clang::tidy::llvm'
typedef llvm::SmallSet<llvm::StringRef, 5> HeaderFileExtensionsSet;
                       ~~~~~~^
2 errors generated.

Here's the one line contrived change needed to demonstrate the error produced above, which is the same effect of including an llvm checker header before including this file:

--- a/clang-tools-extra/clang-tidy/utils/HeaderFileExtensionsUtils.h
+++ b/clang-tools-extra/clang-tidy/utils/HeaderFileExtensionsUtils.h
@@ -16,6 +16,7 @@

 namespace clang {
 namespace tidy {
+namespace llvm {}
 namespace utils {

 typedef llvm::SmallSet<llvm::StringRef, 5> HeaderFileExtensionsSet;

[hintonda]

clang-tools-extra/clang-tidy/utils/HeaderFileExtensionsUtils.h

21 ↗

(On Diff #193362)

Other than aesthetics, the reason I don't like the idea of fully scoping these types, at least without a comment, is that the error is triggered by some other code gets included first, and has nothing to do with this code -- there's nothing actually wrong with the original code. So it could/would be confusing for a reader later on wondering why you needed to fully scope these types, and not others.

[aaron.ballman]

clang-tools-extra/clang-tidy/utils/HeaderFileExtensionsUtils.h

21 ↗

(On Diff #193362)

I would argue that the original code is wrong to not use fully-qualified namespace specifiers. The issue is that we have two different namespaces named llvm and have gotten away with poor namespace hygiene by accident. Either we should rename the clang-tidy llvm namespace to something that does not conflict, or we should consistently use fully-qualified namespace specifiers when in clang-tidy and needing to refer to an llvm namespace explicitly.

I think this patch goes in the wrong direction by making it easier to limp along with poor namespace hygiene.

[hintonda]

clang-tools-extra/clang-tidy/utils/HeaderFileExtensionsUtils.h

21 ↗

(On Diff #193362)

By fully qualified, do you mean appending the global namespace, :: to everything? I actually like using llvm::, but ::llvm:: is odd and needs explanation.

I'd be happy to abandon this change and instead rename the clang::tidy::llvm to clang::tidy::something_else, if that's what the community would prefer.

[alexfh]

clang-tools-extra/clang-tidy/utils/HeaderFileExtensionsUtils.h

21 ↗

(On Diff #193362)

Aaron, you have a very good point. We also have a more recent example of a good namespace hygiene in clang-tidy code: the abseil module is not called absl mainly to "avoid collisions with a well-known top-level namespace" (https://google.github.io/styleguide/cppguide.html#Namespace_Names).

If we can rename the llvm module to something reasonable ("llvm_project"?) without breaking the naming invariants (used by the add_new_check.py script, for example), it would be a much better solution.

[aaron.ballman]

clang-tools-extra/clang-tidy/utils/HeaderFileExtensionsUtils.h

21 ↗

(On Diff #193362)

By fully qualified, do you mean appending the global namespace, :: to everything? I actually like using llvm::, but ::llvm:: is odd and needs explanation.

I mean that within clang-tidy, anywhere we write llvm:: today, we write ::llvm:: instead when we're talking about the global llvm namespace as opposed to the clang-tidy llvm namespace.

I'd be happy to abandon this change and instead rename the clang::tidy::llvm to clang::tidy::something_else, if that's what the community would prefer.

That's my personal preference. I'm fine with the suggestion from @alexfh of using llvm_project instead, but we could also go with llvm_proj, llvm_code, llvm_tidy, etc.

[hintonda]

clang-tools-extra/clang-tidy/utils/HeaderFileExtensionsUtils.h

21 ↗

(On Diff #193362)

Looks like a consensus. I'll work up a patch and get back to you. Thanks again.

[hintonda]

• Rename llvm directory to llvm_project.
• Change llvm- to llvm-project-.
• Rename files.

[alexfh]

In D60151#1454105, @hintonda wrote:

• Rename llvm directory to llvm_project.
• Change llvm- to llvm-project-.
• Rename files.

Awesome! Thanks for doing this. Could you ensure that the add_new_check.py script still works?

[hintonda]

In D60151#1454741, @alexfh wrote:

In D60151#1454105, @hintonda wrote:

• Rename llvm directory to llvm_project.
• Change llvm- to llvm-project-.
• Rename files.

Awesome! Thanks for doing this. Could you ensure that the add_new_check.py script still works?

Thanks for mentioning this. Found a missing rename discovered by add_new_check.py which I'll checkin shortly. However, I'm not sure how best to solve a rename issue.

In rename_check.py, module names can't be hyphenated, e.g.:

190:  old_module = args.old_check_name.split('-')[0]
191:  new_module = args.new_check_name.split('-')[0]

If we keep this pattern, then "llvm-project" won't work. It would need to be something like "llvmproject" or something else. Please let me know your preference.

[aaron.ballman]

In D60151#1454802, @hintonda wrote:

In D60151#1454741, @alexfh wrote:

In D60151#1454105, @hintonda wrote:

• Rename llvm directory to llvm_project.
• Change llvm- to llvm-project-.
• Rename files.

Awesome! Thanks for doing this. Could you ensure that the add_new_check.py script still works?

Thanks for mentioning this. Found a missing rename discovered by add_new_check.py which I'll checkin shortly. However, I'm not sure how best to solve a rename issue.

In rename_check.py, module names can't be hyphenated, e.g.:

190:  old_module = args.old_check_name.split('-')[0]
191:  new_module = args.new_check_name.split('-')[0]

If we keep this pattern, then "llvm-project" won't work. It would need to be something like "llvmproject" or something else. Please let me know your preference.

Hmm, that's unfortunate behavior. I guess my preference would be to go with llvm_project, but it's not a strong preference.

[MyDeveloperDay]

are we supporting "-llvm-*" in existing .clang-tidy files?

If people selectively turn checkers off, won't all of a sudden everyone start getting llvm-project checks and fixes turned back on?

https://github.com/search?q=-llvm-%2A&type=Code

maybe we need to add something like:

llvm-header-guard (redirects to llvm-project-header-guard) <llvm-header-guard>
llvm-header-include-order (redirects to llvm-project-include-order) <llvm-include-order>
llvm-header-namespace-comment(redirects to llvm-project-namespace-comment) <llvm-namespace-comment>
llvm-header-twine-local(redirects to llvm-project-twine-local) <llvm-twine-local>

[hintonda]

In D60151#1462850, @MyDeveloperDay wrote:

are we supporting "-llvm-*" in existing .clang-tidy files?

If people selectively turn checkers off, won't all of a sudden everyone start getting llvm-project checks and fixes turned back on?

https://github.com/search?q=-llvm-%2A&type=Code

maybe we need to add something like:

llvm-header-guard (redirects to llvm-project-header-guard) <llvm-header-guard>
llvm-header-include-order (redirects to llvm-project-include-order) <llvm-include-order>
llvm-header-namespace-comment(redirects to llvm-project-namespace-comment) <llvm-namespace-comment>
llvm-header-twine-local(redirects to llvm-project-twine-local) <llvm-twine-local>

I suppose we could keep the names and directory structure and just change the namespace. That would just be a special case in the scripts. Haven't looked into it yet, but will do so as soon as I can.

[lebedev.ri]

In D60151#1462976, @hintonda wrote:

In D60151#1462850, @MyDeveloperDay wrote:

are we supporting "-llvm-*" in existing .clang-tidy files?

If people selectively turn checkers off, won't all of a sudden everyone start getting llvm-project checks and fixes turned back on?

https://github.com/search?q=-llvm-%2A&type=Code

maybe we need to add something like:

llvm-header-guard (redirects to llvm-project-header-guard) <llvm-header-guard>
llvm-header-include-order (redirects to llvm-project-include-order) <llvm-include-order>
llvm-header-namespace-comment(redirects to llvm-project-namespace-comment) <llvm-namespace-comment>
llvm-header-twine-local(redirects to llvm-project-twine-local) <llvm-twine-local>

I suppose we could keep the names and directory structure and just change the namespace. That would just be a special case in the scripts. Haven't looked into it yet, but will do so as soon as I can.

Isn't that matching done on strings? I.e. is there difference between -llvm-* and -ll* ?

[MyDeveloperDay]

I suppose we could keep the names and directory structure and just change the namespace. That would just be a special case in the scripts. Haven't looked into it yet, but will do so as soon as I can.

Isn't that matching done on strings? I.e. is there difference between -llvm-* and -ll* ?

it would be if they only do it to -llm-* (which could possibly catch most cases)

but what if someone is doing

-llvm-header-guard

We wouldn't catch those..

This is a snippet of a .clang-tidy file from a project I work on, we turn off specific checks by fully qualifying the checker

....
llvm-*,
-llvm-header-guard,
-llvm-include-order,
misc-*,
modernize-*,
...

[hintonda]

In D60151#1463484, @MyDeveloperDay wrote:

I suppose we could keep the names and directory structure and just change the namespace. That would just be a special case in the scripts. Haven't looked into it yet, but will do so as soon as I can.

Isn't that matching done on strings? I.e. is there difference between -llvm-* and -ll* ?

it would be if they only do it to -llm-* (which could possibly catch most cases)

but what if someone is doing

-llvm-header-guard

We wouldn't catch those..

This is a snippet of a .clang-tidy file from a project I work on, we turn off specific checks by fully qualifying the checker

....
llvm-*,
-llvm-header-guard,
-llvm-include-order,
misc-*,
modernize-*,
...

You make a great point. I'll look into just changing the namespace name. I wasn't really comfortable with all the code churn it involved anyway, but once I got started, I figured I'd finish it. The duplicate llvm namespace is the issue, not other names. Thanks for the feedback...

[hintonda]

Replaced by D60629.

clang-tools-extra/clang-tidy/CMakeLists.txt

 add_subdirectory(abseil)
 add_subdirectory(boost)
 add_subdirectory(bugprone)
 add_subdirectory(cert)
 add_subdirectory(cppcoreguidelines)
 add_subdirectory(fuchsia)
 add_subdirectory(google)
 add_subdirectory(hicpp)
-add_subdirectory(llvm)
+add_subdirectory(llvm_project)
 add_subdirectory(misc)
 add_subdirectory(modernize)
 if(CLANG_ENABLE_STATIC_ANALYZER)
   add_subdirectory(mpi)
 endif()
 add_subdirectory(objc)
 add_subdirectory(openmp)
 add_subdirectory(performance)
 add_subdirectory(plugin)
 add_subdirectory(portability)
 add_subdirectory(readability)
 add_subdirectory(tool)
 add_subdirectory(utils)
 add_subdirectory(zircon)

clang-tools-extra/clang-tidy/llvm_project/CMakeLists.txt

 set(LLVM_LINK_COMPONENTS support)
 
 add_clang_library(clangTidyLLVMModule
   HeaderGuardCheck.cpp
   IncludeOrderCheck.cpp
-  LLVMTidyModule.cpp
+  LLVMProjectTidyModule.cpp
   TwineLocalCheck.cpp
 
   LINK_LIBS
   clangAST
   clangASTMatchers
   clangBasic
   clangLex
   clangTidy
   clangTidyReadabilityModule
   clangTidyUtils
   clangTooling
   )

clang-tools-extra/clang-tidy/llvm_project/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_PROJECT_HEADER_GUARD_CHECK_H
+#define LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_LLVM_PROJECT_HEADER_GUARD_CHECK_H
 
 #include "../utils/HeaderGuard.h"
 
 namespace clang {
 namespace tidy {
-namespace llvm {
+namespace llvm_project {
 
 /// 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
+/// http://clang.llvm.org/extra/clang-tidy/checks/llvm-project-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_project
 } // namespace tidy
 } // namespace clang
 
-#endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_LLVM_HEADER_GUARD_CHECK_H
+#endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_LLVM_PROJECT_HEADER_GUARD_CHECK_H

clang-tools-extra/clang-tidy/llvm_project/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_project {
 
 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_project
 } // namespace tidy
 } // namespace clang

clang-tools-extra/clang-tidy/llvm_project/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_PROJECT_INCLUDE_ORDER_CHECK_H
+#define LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_LLVM_PROJECT_INCLUDE_ORDER_CHECK_H
 
 #include "../ClangTidyCheck.h"
 
 namespace clang {
 namespace tidy {
-namespace llvm {
+namespace llvm_project {
 
 /// 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_project
 } // namespace tidy
 } // namespace clang
 
-#endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_LLVM_INCLUDE_ORDER_CHECK_H
+#endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_LLVM_PROJECT_INCLUDE_ORDER_CHECK_H

clang-tools-extra/clang-tidy/llvm_project/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_project {
 
 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_project
 } // namespace tidy
 } // namespace clang

clang-tools-extra/clang-tidy/llvm_project/LLVMProjectTidyModule.cpp

 #include "../ClangTidyModuleRegistry.h"
 #include "../readability/NamespaceCommentCheck.h"
 #include "HeaderGuardCheck.h"
 #include "IncludeOrderCheck.h"
 #include "TwineLocalCheck.h"
 
 namespace clang {
 namespace tidy {
-namespace llvm {
+namespace llvm_project {
 
 class LLVMModule : public ClangTidyModule {
 public:
   void addCheckFactories(ClangTidyCheckFactories &CheckFactories) override {
-    CheckFactories.registerCheck<LLVMHeaderGuardCheck>("llvm-header-guard");
-    CheckFactories.registerCheck<IncludeOrderCheck>("llvm-include-order");
+    CheckFactories.registerCheck<LLVMHeaderGuardCheck>("llvm-project-header-guard");
+    CheckFactories.registerCheck<IncludeOrderCheck>("llvm-project-include-order");
     CheckFactories.registerCheck<readability::NamespaceCommentCheck>(
-        "llvm-namespace-comment");
-    CheckFactories.registerCheck<TwineLocalCheck>("llvm-twine-local");
+        "llvm-project-namespace-comment");
+    CheckFactories.registerCheck<TwineLocalCheck>("llvm-project-twine-local");
   }
 };
 
 // Register the LLVMTidyModule using this statically initialized variable.
-static ClangTidyModuleRegistry::Add<LLVMModule> X("llvm-module",
+static ClangTidyModuleRegistry::Add<LLVMModule> X("llvm-project-module",
                                                   "Adds LLVM lint checks.");
 
-} // namespace llvm
+} // namespace llvm_project
 
 // 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-tools-extra/clang-tidy/llvm_project/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_PROJECT_TWINE_LOCAL_CHECK_H
+#define LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_LLVM_PROJECT_TWINE_LOCAL_CHECK_H
 
 #include "../ClangTidyCheck.h"
 
 namespace clang {
 namespace tidy {
-namespace llvm {
+namespace llvm_project {
 
 /// 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_project
 } // namespace tidy
 } // namespace clang
 
-#endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_LLVM_TWINE_LOCAL_CHECK_H
+#endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_LLVM_PROJECT_TWINE_LOCAL_CHECK_H

clang-tools-extra/clang-tidy/llvm_project/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_project {
 
 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_project
 } // namespace tidy
 } // namespace clang

clang-tools-extra/clang-tidy/tool/run-clang-tidy.py

 and clang-apply-replacements in $PATH.
 
 Example invocations.
 - Run clang-tidy on all files in the current working directory with a default
   set of checks and show warnings in the cpp files and all project headers.
     run-clang-tidy.py $PWD
 
 - Fix all header guards.
-    run-clang-tidy.py -fix -checks=-*,llvm-header-guard
+    run-clang-tidy.py -fix -checks=-*,llvm-project-header-guard
 
 - Fix all header guards included from clang-tidy and header guards
   for clang-tidy headers.
-    run-clang-tidy.py -fix -checks=-*,llvm-header-guard extra/clang-tidy \
+    run-clang-tidy.py -fix -checks=-*,llvm-project-header-guard extra/clang-tidy \
                       -header-filter=extra/clang-tidy
 
 Compilation database setup:
 http://clang.llvm.org/docs/HowToSetupToolingForLLVM.html
 """
 
 from __future__ import print_function
 

clang-tools-extra/docs/clang-tidy/checks/google-readability-namespace-comments.rst

 .. title:: clang-tidy - google-readability-namespace-comments
 .. meta::
-   :http-equiv=refresh: 5;URL=llvm-namespace-comment.html
+   :http-equiv=refresh: 5;URL=llvm-project-namespace-comment.html
 
 google-readability-namespace-comments
 =====================================
 
 The google-readability-namespace-comments check is an alias, please see
-`llvm-namespace-comment <llvm-namespace-comment.html>`_ for more information.
+`llvm-project-namespace-comment <llvm-project-namespace-comment.html>`_ for more information.

clang-tools-extra/docs/clang-tidy/checks/list.rst

.. toctree::
    google-global-names-in-headers
    google-objc-avoid-throwing-exception
    google-objc-function-naming
    google-objc-global-variable-declaration
    google-readability-avoid-underscore-in-googletest-name
    google-readability-braces-around-statements (redirects to readability-braces-around-statements) <google-readability-braces-around-statements>
    google-readability-casting
    google-readability-function-size (redirects to readability-function-size) <google-readability-function-size>
-   google-readability-namespace-comments (redirects to llvm-namespace-comment) <google-readability-namespace-comments>
+   google-readability-namespace-comments (redirects to llvm-project-namespace-comment) <google-readability-namespace-comments>
    google-readability-todo
    google-runtime-int
    google-runtime-operator
    google-runtime-references
    hicpp-avoid-c-arrays (redirects to modernize-avoid-c-arrays) <hicpp-avoid-c-arrays>
    hicpp-avoid-goto
    hicpp-braces-around-statements (redirects to readability-braces-around-statements) <hicpp-braces-around-statements>
    hicpp-deprecated-headers (redirects to modernize-deprecated-headers) <hicpp-deprecated-headers>
.. toctree::
    hicpp-use-auto (redirects to modernize-use-auto) <hicpp-use-auto>
    hicpp-use-emplace (redirects to modernize-use-emplace) <hicpp-use-emplace>
    hicpp-use-equals-default (redirects to modernize-use-equals-default) <hicpp-use-equals-default>
    hicpp-use-equals-delete (redirects to modernize-use-equals-delete) <hicpp-use-equals-delete>
    hicpp-use-noexcept (redirects to modernize-use-noexcept) <hicpp-use-noexcept>
    hicpp-use-nullptr (redirects to modernize-use-nullptr) <hicpp-use-nullptr>
    hicpp-use-override (redirects to modernize-use-override) <hicpp-use-override>
    hicpp-vararg (redirects to cppcoreguidelines-pro-type-vararg) <hicpp-vararg>
-   llvm-header-guard
-   llvm-include-order
-   llvm-namespace-comment
-   llvm-twine-local
+   llvm-project-header-guard
+   llvm-project-include-order
+   llvm-project-namespace-comment
+   llvm-project-twine-local
    misc-definitions-in-headers
    misc-misplaced-const
    misc-new-delete-overloads
    misc-non-copyable-objects
    misc-non-private-member-variables-in-classes
    misc-redundant-expression
    misc-static-assert
    misc-throw-by-value-catch-by-reference

clang-tools-extra/docs/clang-tidy/checks/llvm-project-header-guard.rst

-.. title:: clang-tidy - llvm-header-guard
+.. title:: clang-tidy - llvm-project-header-guard
 
-llvm-header-guard
+llvm-project-header-guard
 =================
 
 Finds and fixes header guards that do not adhere to LLVM style.
 
 Options
 -------
 
 .. option:: HeaderFileExtensions
 
    A comma-separated list of filename extensions of header files (the filename
    extensions should not include "." prefix). Default is "h,hh,hpp,hxx".
    For header files without an extension, use an empty string (if there are no
    other desired extensions) or leave an empty element in the list. e.g.,
    "h,hh,hpp,hxx," (note the trailing comma).

clang-tools-extra/docs/clang-tidy/checks/llvm-project-include-order.rst

-.. title:: clang-tidy - llvm-include-order
+.. title:: clang-tidy - llvm-project-include-order
 
-llvm-include-order
+llvm-project-include-order
 ==================
 
 
 Checks the correct order of ``#includes``.
 
 See https://llvm.org/docs/CodingStandards.html#include-style

clang-tools-extra/docs/clang-tidy/checks/llvm-project-namespace-comment.rst

-.. title:: clang-tidy - llvm-namespace-comment
+.. title:: clang-tidy - llvm-project-namespace-comment
 
-llvm-namespace-comment
+llvm-project-namespace-comment
 ======================
 
 `google-readability-namespace-comments` redirects here as an alias for this
 check.
 
 Checks that long namespaces have a closing comment.
 
 https://llvm.org/docs/CodingStandards.html#namespace-indentation

clang-tools-extra/docs/clang-tidy/checks/llvm-project-twine-local.rst

-.. title:: clang-tidy - llvm-twine-local
+.. title:: clang-tidy - llvm-project-twine-local
 
-llvm-twine-local
+llvm-project-twine-local
 ================
 
 
 Looks for local ``Twine`` variables which are prone to use after frees and
 should be generally avoided.
 
 .. code-block:: c++
 
   static Twine Moo = Twine("bark") + "bah";
 
   // becomes
 
   static std::string Moo = (Twine("bark") + "bah").str();

clang-tools-extra/docs/clang-tidy/index.rst

 ``boost-``             Checks related to Boost library.
 ``bugprone-``          Checks that target bugprone code constructs.
 ``cert-``              Checks related to CERT Secure Coding Guidelines.
 ``cppcoreguidelines-`` Checks related to C++ Core Guidelines.
 ``clang-analyzer-``    Clang Static Analyzer checks.
 ``fuchsia-``           Checks related to Fuchsia coding conventions.
 ``google-``            Checks related to Google coding conventions.
 ``hicpp-``             Checks related to High Integrity C++ Coding Standard.
-``llvm-``              Checks related to the LLVM coding conventions.
+``llvm-project-``      Checks related to the LLVM coding conventions.
 ``misc-``              Checks that we didn't have a better category for.
 ``modernize-``         Checks that advocate usage of modern (currently "modern"
                        means "C++11") language constructs.
 ``mpi-``               Checks related to MPI (Message Passing Interface).
 ``objc-``              Checks related to Objective-C coding conventions.
 ``openmp-``            Checks related to OpenMP API.
 ``performance-``       Checks that target performance-related issues.
 ``portability-``       Checks that target portability-related issues that don't

clang-tools-extra/test/clang-tidy/Inputs/Headers/cross-file-c.h

 
 
 
 
 
 
 
 // The line number of the following include should match the location of the
-// corresponding comment in llvm-include-order.cpp
+// corresponding comment in llvm-project-include-order.cpp
 #include "cross-file-b.h"

clang-tools-extra/test/clang-tidy/Inputs/overlapping/o.h

-// run: clang-tidy -checks=-*,llvm-include-order -header-filter=.* %s \
+// run: clang-tidy -checks=-*,llvm-project-include-order -header-filter=.* %s \
 // run:   -- -isystem %S/Inputs/Headers -I %S/Inputs/overlapping | \
 // run:   not grep "note: this fix will not be applied because it overlaps with another fix"
 
 #include "b.h"
 #include "a.h"
 
 // The comments above are there to match the offset of the #include with the
 // offset of the #includes in the .cpp file.

clang-tools-extra/test/clang-tidy/basic.cpp

-// RUN: clang-tidy %s -checks='-*,llvm-namespace-comment' -- | FileCheck %s
+// RUN: clang-tidy %s -checks='-*,llvm-project-namespace-comment' -- | FileCheck %s
 
 namespace i {
 }
-// CHECK: warning: namespace 'i' not terminated with a closing comment [llvm-namespace-comment]
+// CHECK: warning: namespace 'i' not terminated with a closing comment [llvm-project-namespace-comment]

clang-tools-extra/test/clang-tidy/check_clang_tidy.py

Usage:
   check_clang_tidy.py [-resource-dir=<resource-dir>] \
     [-assume-filename=<file-with-source-extension>] \
     [-check-suffix=<comma-separated-file-check-suffixes>] \
     [-check-suffixes=<comma-separated-file-check-suffixes>] \
     <source-file> <check-name> <temp-file> \
     -- [optional clang-tidy arguments]
 
 Example:
-  // RUN: %check_clang_tidy %s llvm-include-order %t -- -- -isystem %S/Inputs
+  // RUN: %check_clang_tidy %s llvm-project-include-order %t -- -- -isystem %S/Inputs
 """
 
 import argparse
 import os
 import re
 import subprocess
 import sys
 

clang-tools-extra/test/clang-tidy/export-relpath.cpp

 // RUN: rm -rf %T/clang-tidy/export-relpath
 // RUN: mkdir -p %T/clang-tidy/export-relpath/subdir
 // RUN: cp %s %T/clang-tidy/export-relpath/subdir/source.cpp
 // RUN: echo '[{ "directory": "%/T/clang-tidy/export-relpath/subdir", "command": "clang++ source.cpp", "file": "%/T/clang-tidy/export-relpath/subdir/source.cpp"}]' > %T/clang-tidy/export-relpath/subdir/compile_commands.json
 //
 // Check that running clang-tidy in './subdir' and storing results
 // in './fixes.yaml' works as expected.
 //
 // RUN: cd %T/clang-tidy/export-relpath
-// RUN: clang-tidy -p subdir subdir/source.cpp -checks='-*,google-explicit-constructor,llvm-namespace-comment' -export-fixes=./fixes.yaml
+// RUN: clang-tidy -p subdir subdir/source.cpp -checks='-*,google-explicit-constructor,llvm-project-namespace-comment' -export-fixes=./fixes.yaml
 // RUN: FileCheck -input-file=%T/clang-tidy/export-relpath/fixes.yaml -check-prefix=CHECK-YAML %s
 
 namespace i {
 void f(); // So that the namespace isn't empty.
 }
 // CHECK-YAML: ReplacementText: ' // namespace i'
 
 class A { A(int i); };
 // CHECK-YAML: ReplacementText: 'explicit '

clang-tools-extra/test/clang-tidy/fix.cpp

 // RUN: grep -Ev "// *[A-Z-]+:" %s > %t.cpp
-// RUN: clang-tidy %t.cpp -checks='-*,google-explicit-constructor,llvm-namespace-comment' -fix -export-fixes=%t.yaml -- > %t.msg 2>&1
+// RUN: clang-tidy %t.cpp -checks='-*,google-explicit-constructor,llvm-project-namespace-comment' -fix -export-fixes=%t.yaml -- > %t.msg 2>&1
 // RUN: FileCheck -input-file=%t.cpp %s
 // RUN: FileCheck -input-file=%t.msg -check-prefix=CHECK-MESSAGES %s
 // RUN: FileCheck -input-file=%t.yaml -check-prefix=CHECK-YAML %s
 
 namespace i {
 void f(); // So that the namespace isn't empty.
 }
 // CHECK: } // namespace i
 // CHECK-MESSAGES: note: FIX-IT applied suggested code changes
 // CHECK-YAML: ReplacementText: ' // namespace i'
 
 class A { A(int i); };
 // CHECK: class A { explicit A(int i); };
 // CHECK-MESSAGES: note: FIX-IT applied suggested code changes
 // CHECK-MESSAGES: clang-tidy applied 2 of 2 suggested fixes.
 // CHECK-YAML: ReplacementText: 'explicit '

clang-tools-extra/test/clang-tidy/llvm-project-include-order.cpp

-// RUN: %check_clang_tidy %s llvm-include-order %t -- -- -isystem %S/Inputs/Headers
+// RUN: %check_clang_tidy %s llvm-project-include-order %t -- -- -isystem %S/Inputs/Headers
 
 // CHECK-MESSAGES: [[@LINE+2]]:1: warning: #includes are not sorted properly
 #include "j.h"
 #include "gtest/foo.h"
 #include "i.h"
 #include <s.h>
 #include "llvm/a.h"
 #include "clang/b.h"

clang-tools-extra/test/clang-tidy/llvm-project-twine-local.cpp

-// RUN: %check_clang_tidy %s llvm-twine-local %t
+// RUN: %check_clang_tidy %s llvm-project-twine-local %t
 
 namespace llvm {
 class Twine {
 public:
   Twine(const char *);
   Twine(int);
   Twine();
   Twine &operator+(const Twine &);

clang-tools-extra/test/clang-tidy/overlapping.cpp

-// RUN: clang-tidy -checks=-*,llvm-include-order -header-filter=.* %s \
+// RUN: clang-tidy -checks=-*,llvm-project-include-order -header-filter=.* %s \
 // RUN:   -- -isystem %S/Inputs/Headers -I %S/Inputs/overlapping | \
 // RUN:   not grep "note: this fix will not be applied because it overlaps with another fix"
 
 #include <s.h>
 #include "o.h"
 
 // Test that clang-tidy takes into account in which file we are doing the
 // replacements to determine if they overlap or not. In the file "o.h" there is
 // a similar error at the same file offset, but they do not overlap.

clang-tools-extra/test/clang-tidy/select-checks.cpp

-// RUN: clang-tidy %s -checks='-*,llvm-namespace-*' -- 2>&1 | FileCheck -implicit-check-not='{{warning:|error:}}' %s
+// RUN: clang-tidy %s -checks='-*,llvm-project-namespace-*' -- 2>&1 | FileCheck -implicit-check-not='{{warning:|error:}}' %s
 // RUN: not clang-tidy %s -checks='-*,an-unknown-check' -- 2>&1 | FileCheck -implicit-check-not='{{warning:|error:}}' -check-prefix=CHECK2 %s
 
 // CHECK2: Error: no checks enabled.
 
 namespace i {
 }
-// CHECK: :[[@LINE-1]]:2: warning: namespace 'i' not terminated with a closing comment [llvm-namespace-comment]
+// CHECK: :[[@LINE-1]]:2: warning: namespace 'i' not terminated with a closing comment [llvm-project-namespace-comment]
 
 // Expect no warnings from the google-explicit-constructor check:
 class A { A(int i); };

clang-tools-extra/test/clang-tidy/serialize-diagnostics.cpp

-// RUN: not clang-tidy -checks=-*,llvm-namespace-comment %s -- -serialize-diagnostics %t | FileCheck %s
+// RUN: not clang-tidy -checks=-*,llvm-project-namespace-comment %s -- -serialize-diagnostics %t | FileCheck %s
 // CHECK: :[[@LINE+1]]:12: error: expected ';' after struct [clang-diagnostic-error]
 struct A {}

clang-tools-extra/test/clang-tidy/warnings-as-errors-diagnostics.cpp

-// RUN: clang-tidy %s -checks='-*,llvm-namespace-comment,clang-diagnostic*' \
+// RUN: clang-tidy %s -checks='-*,llvm-project-namespace-comment,clang-diagnostic*' \
 // RUN:   -- -Wunused-variable 2>&1 \
 // RUN:   | FileCheck %s --check-prefix=CHECK-WARN -implicit-check-not='{{warning|error}}:'
-// RUN: not clang-tidy %s -checks='-*,llvm-namespace-comment,clang-diagnostic*' \
+// RUN: not clang-tidy %s -checks='-*,llvm-project-namespace-comment,clang-diagnostic*' \
 // RUN:   -warnings-as-errors='clang-diagnostic*' -- -Wunused-variable 2>&1 \
 // RUN:   | FileCheck %s --check-prefix=CHECK-WERR -implicit-check-not='{{warning|error}}:'
-// RUN: not clang-tidy %s -checks='-*,llvm-namespace-comment,clang-diagnostic*' \
+// RUN: not clang-tidy %s -checks='-*,llvm-project-namespace-comment,clang-diagnostic*' \
 // RUN:   -warnings-as-errors='clang-diagnostic*' -quiet -- -Wunused-variable 2>&1 \
 // RUN:   | FileCheck %s --check-prefix=CHECK-WERR-QUIET -implicit-check-not='{{warning|error}}:'
 
 void f() { int i; }
 // CHECK-WARN: warning: unused variable 'i' [clang-diagnostic-unused-variable]
 // CHECK-WERR: error: unused variable 'i' [clang-diagnostic-unused-variable,-warnings-as-errors]
 // CHECK-WERR-QUIET: error: unused variable 'i' [clang-diagnostic-unused-variable,-warnings-as-errors]
 
 // CHECK-WARN-NOT: treated as
 // CHECK-WERR: 1 warning treated as error
 // CHECK-WERR-QUIET-NOT: treated as

clang-tools-extra/test/clang-tidy/warnings-as-errors-plural.cpp

-// RUN: clang-tidy %s -checks='-*,llvm-namespace-comment,clang-diagnostic*' -- 2>&1 \
+// RUN: clang-tidy %s -checks='-*,llvm-project-namespace-comment,clang-diagnostic*' -- 2>&1 \
 // RUN:   | FileCheck %s --check-prefix=CHECK-WARN -implicit-check-not='{{warning|error}}:'
-// RUN: not clang-tidy %s -checks='-*,llvm-namespace-comment,clang-diagnostic*' \
-// RUN:   -warnings-as-errors='llvm-namespace-comment' -- 2>&1 \
+// RUN: not clang-tidy %s -checks='-*,llvm-project-namespace-comment,clang-diagnostic*' \
+// RUN:   -warnings-as-errors='llvm-project-namespace-comment' -- 2>&1 \
 // RUN:   | FileCheck %s --check-prefix=CHECK-WERR -implicit-check-not='{{warning|error}}:'
-// RUN: not clang-tidy %s -checks='-*,llvm-namespace-comment,clang-diagnostic*' \
-// RUN:   -warnings-as-errors='llvm-namespace-comment' -quiet -- 2>&1 \
+// RUN: not clang-tidy %s -checks='-*,llvm-project-namespace-comment,clang-diagnostic*' \
+// RUN:   -warnings-as-errors='llvm-project-namespace-comment' -quiet -- 2>&1 \
 // RUN:   | FileCheck %s --check-prefix=CHECK-WERR-QUIET -implicit-check-not='{{warning|error}}:'
 
 namespace j {
 }
-// CHECK-WARN: warning: namespace 'j' not terminated with a closing comment [llvm-namespace-comment]
-// CHECK-WERR: error: namespace 'j' not terminated with a closing comment [llvm-namespace-comment,-warnings-as-errors]
-// CHECK-WERR-QUIET: error: namespace 'j' not terminated with a closing comment [llvm-namespace-comment,-warnings-as-errors]
+// CHECK-WARN: warning: namespace 'j' not terminated with a closing comment [llvm-project-namespace-comment]
+// CHECK-WERR: error: namespace 'j' not terminated with a closing comment [llvm-project-namespace-comment,-warnings-as-errors]
+// CHECK-WERR-QUIET: error: namespace 'j' not terminated with a closing comment [llvm-project-namespace-comment,-warnings-as-errors]
 
 namespace k {
 }
-// CHECK-WARN: warning: namespace 'k' not terminated with a closing comment [llvm-namespace-comment]
-// CHECK-WERR: error: namespace 'k' not terminated with a closing comment [llvm-namespace-comment,-warnings-as-errors]
-// CHECK-WERR-QUIET: error: namespace 'k' not terminated with a closing comment [llvm-namespace-comment,-warnings-as-errors]
+// CHECK-WARN: warning: namespace 'k' not terminated with a closing comment [llvm-project-namespace-comment]
+// CHECK-WERR: error: namespace 'k' not terminated with a closing comment [llvm-project-namespace-comment,-warnings-as-errors]
+// CHECK-WERR-QUIET: error: namespace 'k' not terminated with a closing comment [llvm-project-namespace-comment,-warnings-as-errors]
 
 // CHECK-WARN-NOT: treated as
 // CHECK-WERR: 2 warnings treated as errors
 // CHECK-WERR-QUIET-NOT: treated as

clang-tools-extra/test/clang-tidy/warnings-as-errors.cpp

-// RUN: clang-tidy %s -checks='-*,llvm-namespace-comment' -- 2>&1 | FileCheck %s --check-prefix=CHECK-WARN -implicit-check-not='{{warning|error}}:'
-// RUN: not clang-tidy %s -checks='-*,llvm-namespace-comment' -warnings-as-errors='llvm-namespace-comment' -- 2>&1 | FileCheck %s --check-prefix=CHECK-WERR -implicit-check-not='{{warning|error}}:'
-// RUN: not clang-tidy %s -checks='-*,llvm-namespace-comment' -warnings-as-errors='llvm-namespace-comment' -quiet -- 2>&1 | FileCheck %s --check-prefix=CHECK-WERR-QUIET -implicit-check-not='{{warning|error}}:'
+// RUN: clang-tidy %s -checks='-*,llvm-project-namespace-comment' -- 2>&1 | FileCheck %s --check-prefix=CHECK-WARN -implicit-check-not='{{warning|error}}:'
+// RUN: not clang-tidy %s -checks='-*,llvm-project-namespace-comment' -warnings-as-errors='llvm-project-namespace-comment' -- 2>&1 | FileCheck %s --check-prefix=CHECK-WERR -implicit-check-not='{{warning|error}}:'
+// RUN: not clang-tidy %s -checks='-*,llvm-project-namespace-comment' -warnings-as-errors='llvm-project-namespace-comment' -quiet -- 2>&1 | FileCheck %s --check-prefix=CHECK-WERR-QUIET -implicit-check-not='{{warning|error}}:'
 
 namespace i {
 }
-// CHECK-WARN: warning: namespace 'i' not terminated with a closing comment [llvm-namespace-comment]
-// CHECK-WERR: error: namespace 'i' not terminated with a closing comment [llvm-namespace-comment,-warnings-as-errors]
-// CHECK-WERR-QUIET: error: namespace 'i' not terminated with a closing comment [llvm-namespace-comment,-warnings-as-errors]
+// CHECK-WARN: warning: namespace 'i' not terminated with a closing comment [llvm-project-namespace-comment]
+// CHECK-WERR: error: namespace 'i' not terminated with a closing comment [llvm-project-namespace-comment,-warnings-as-errors]
+// CHECK-WERR-QUIET: error: namespace 'i' not terminated with a closing comment [llvm-project-namespace-comment,-warnings-as-errors]
 
 // CHECK-WARN-NOT: treated as
 // CHECK-WERR: 1 warning treated as error
 // CHECK-WERR-QUIET-NOT: treated as

clang-tools-extra/unittests/clang-tidy/CMakeLists.txt

 set(LLVM_LINK_COMPONENTS
   support
   )
 
 get_filename_component(CLANG_LINT_SOURCE_DIR
   ${CMAKE_CURRENT_SOURCE_DIR}/../../clang-tidy REALPATH)
 include_directories(${CLANG_LINT_SOURCE_DIR})
 
 add_extra_unittest(ClangTidyTests
   ClangTidyDiagnosticConsumerTest.cpp
   ClangTidyOptionsTest.cpp
   IncludeInserterTest.cpp
   GoogleModuleTest.cpp
-  LLVMModuleTest.cpp
+  LLVMProjectModuleTest.cpp
   NamespaceAliaserTest.cpp
   ObjCModuleTest.cpp
   OverlappingReplacementsTest.cpp
   UsingInserterTest.cpp
   ReadabilityModuleTest.cpp
   )
 
 target_link_libraries(ClangTidyTests
   PRIVATE
   clangAST
   clangASTMatchers
   clangBasic
   clangFrontend
   clangLex
   clangSerialization
   clangTidy
   clangTidyAndroidModule
   clangTidyGoogleModule
-  clangTidyLLVMModule
+  clangTidyLLVMProjectModule
   clangTidyObjCModule
   clangTidyReadabilityModule
   clangTidyUtils
   clangTooling
   clangToolingCore
   )

clang-tools-extra/unittests/clang-tidy/LLVMProjectModuleTest.cpp

 #include "ClangTidyTest.h"
-#include "llvm/HeaderGuardCheck.h"
-#include "llvm/IncludeOrderCheck.h"
+#include "llvm_project/HeaderGuardCheck.h"
+#include "llvm_project/IncludeOrderCheck.h"
 #include "gtest/gtest.h"
 
-using namespace clang::tidy::llvm;
-
 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,
                                        Optional<StringRef> ExpectedWarning) {
   std::vector<ClangTidyError> Errors;
-  std::string Result = test::runCheckOnCode<LLVMHeaderGuardCheck>(
+  std::string Result = test::runCheckOnCode<llvm_project::LLVMHeaderGuardCheck>(
       Code, &Errors, Filename, std::string("-xc++-header"));
   if (Errors.size() != (size_t)ExpectedWarning.hasValue())
     return "invalid error count";
   if (ExpectedWarning && *ExpectedWarning != Errors.back().Message.Message)
     return "expected: '" + ExpectedWarning->str() + "', saw: '" +
            Errors.back().Message.Message + "'";
   return Result;
 }
 
 namespace {
-struct WithEndifComment : public LLVMHeaderGuardCheck {
+struct WithEndifComment : public llvm_project::LLVMHeaderGuardCheck {
   WithEndifComment(StringRef Name, ClangTidyContext *Context)
       : LLVMHeaderGuardCheck(Name, Context) {}
   bool shouldSuggestEndifComment(StringRef Filename) override { return true; }
 };
 } // namespace
 
 static std::string
 runHeaderGuardCheckWithEndif(StringRef Code, const Twine &Filename,