No nested namespaces in Clang-Tidy checkers

[pi1024e]

Summary

A lot of the code, including ironically the nested namespace checker itself, was using "namespace clang { tidy { modernize...", so I put those together for readability as "namespace clang::tidy::modernize"

[lebedev.ri]

Isn't that C++17?
LLVM is at C++14.

[MaskRay]

As the warnings suggest, nested name definitions can't be used because llvm-project is still using C++14.

llvm.org as a reviewer doesn't work. You can use git log and find active contributors for your patches.

Last time you closed a revision manually for a commit I pushed on your behalf - it is not necessary, Phabricator will close a revision automatically if a commit description contains Differential Revision:

clang-tools-extra/clang-tidy/modernize/AvoidBindCheck.h

 
 #include "../ClangTidyCheck.h"
 
-namespace clang {
-namespace tidy {
-namespace modernize {
+namespace clang::tidy::modernize {
 
 /// Replace simple uses of std::bind with a lambda.
 ///

 private:
   bool PermissiveParameterList = false;
 };
-} // namespace modernize
-} // namespace tidy
-} // namespace clang
 
-#endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_MODERNIZE_AVOID_BIND_H
+
+} // namespace clang::tidy::modernize#endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_MODERNIZE_AVOID_BIND_H

clang-tools-extra/clang-tidy/modernize/AvoidBindCheck.cpp

 
 using namespace clang::ast_matchers;
 
-namespace clang {
-namespace tidy {
-namespace modernize {
+namespace clang::tidy::modernize {
 
 namespace {
 

                                        Stream.str());
 }
 
-} // namespace modernize
-} // namespace tidy
-} // namespace clang
+} // namespace clang::tidy::modernize

clang-tools-extra/clang-tidy/modernize/AvoidCArraysCheck.h

 
 #include "../ClangTidyCheck.h"
 
-namespace clang {
-namespace tidy {
-namespace modernize {
+namespace clang::tidy::modernize {
 
 /// Find C-style array types and recommend to use std::array<> / std::vector<>.
 ///

   void check(const ast_matchers::MatchFinder::MatchResult &Result) override;
 };
 
-} // namespace modernize
-} // namespace tidy
-} // namespace clang
-
-#endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_MODERNIZE_AVOIDCARRAYSCHECK_H
+} // namespace clang::tidy::modernize#endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_MODERNIZE_AVOIDCARRAYSCHECK_H

clang-tools-extra/clang-tidy/modernize/AvoidCArraysCheck.cpp

 
 } // namespace
 
-namespace clang {
-namespace tidy {
-namespace modernize {
+namespace clang::tidy::modernize {
 
 void AvoidCArraysCheck::registerMatchers(MatchFinder *Finder) {
   Finder->addMatcher(

        ArrayType->getTypePtr()->isVariableArrayType() ? UseVector : UseArray);
 }
 
-} // namespace modernize
-} // namespace tidy
-} // namespace clang
+} // namespace clang::tidy::modernize

clang-tools-extra/clang-tidy/modernize/ConcatNestedNamespacesCheck.h

 #include "llvm/ADT/SmallString.h"
 #include "llvm/ADT/SmallVector.h"
 
-namespace clang {
-namespace tidy {
-namespace modernize {
+namespace clang::tidy::modernize {
 
 class ConcatNestedNamespacesCheck : public ClangTidyCheck {
 public:

   NamespaceString concatNamespaces();
   NamespaceContextVec Namespaces;
 };
-} // namespace modernize
-} // namespace tidy
-} // namespace clang
 
-#endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_MODERNIZE_CONCATNESTEDNAMESPACESCHECK_H
+} // namespace clang::tidy::modernize#endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_MODERNIZE_CONCATNESTEDNAMESPACESCHECK_H

clang-tools-extra/clang-tidy/modernize/ConcatNestedNamespacesCheck.cpp

 #include <algorithm>
 #include <iterator>
 
-namespace clang {
-namespace tidy {
-namespace modernize {
+namespace clang::tidy::modernize {
 
 static bool locationsInSameFile(const SourceManager &Sources,
                                 SourceLocation Loc1, SourceLocation Loc2) {

   Namespaces.clear();
 }
 
-} // namespace modernize
-} // namespace tidy
-} // namespace clang
+} // namespace clang::tidy::modernize

clang-tools-extra/clang-tidy/modernize/DeprecatedHeadersCheck.h

 
 #include "../ClangTidyCheck.h"
 
-namespace clang {
-namespace tidy {
-namespace modernize {
+namespace clang::tidy::modernize {
 
 /// This check replaces deprecated C library headers with their C++ STL
 /// alternatives.

                            Preprocessor *ModuleExpanderPP) override;
 };
 
-} // namespace modernize
-} // namespace tidy
-} // namespace clang
-
-#endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_MODERNIZE_C_HEADERS_TO_CXX_H
+} // namespace clang::tidy::modernize#endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_MODERNIZE_C_HEADERS_TO_CXX_H

clang-tools-extra/clang-tidy/modernize/DeprecatedHeadersCheck.cpp

 
 #include <vector>
 
-namespace clang {
-namespace tidy {
-namespace modernize {
+namespace clang::tidy::modernize {
 
 namespace {
 class IncludeModernizePPCallbacks : public PPCallbacks {

   }
 }
 
-} // namespace modernize
-} // namespace tidy
-} // namespace clang
+
+} // namespace clang::tidy::modernize

clang-tools-extra/clang-tidy/modernize/DeprecatedIosBaseAliasesCheck.h

 
 #include "../ClangTidyCheck.h"
 
-namespace clang {
-namespace tidy {
-namespace modernize {
+namespace clang::tidy::modernize {
 
 /// This check warns the uses of the deprecated member types of ``std::ios_base``
 /// and replaces those that have a non-deprecated equivalent.

   void check(const ast_matchers::MatchFinder::MatchResult &Result) override;
 };
 
-} // namespace modernize
-} // namespace tidy
-} // namespace clang
 
-#endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_MODERNIZE_DEPRECATEDIOSBASEALIASESCHECK_H
+} // namespace clang::tidy::modernize#endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_MODERNIZE_DEPRECATEDIOSBASEALIASESCHECK_H

clang-tools-extra/clang-tidy/modernize/DeprecatedIosBaseAliasesCheck.cpp

 
 using namespace clang::ast_matchers;
 
-namespace clang {
-namespace tidy {
-namespace modernize {
+namespace clang::tidy::modernize {
 
 static constexpr std::array<StringRef, 5> DeprecatedTypes = {
     "::std::ios_base::io_state", "::std::ios_base::open_mode",

     diag(IoStateLoc, "'std::ios_base::%0' is deprecated") << TypeName;
 }
 
-} // namespace modernize
-} // namespace tidy
-} // namespace clang
+} // namespace clang::tidy::modernize

clang-tools-extra/clang-tidy/modernize/LoopConvertCheck.h

 #include "../ClangTidyCheck.h"
 #include "LoopConvertUtils.h"
 
-namespace clang {
-namespace tidy {
-namespace modernize {
+namespace clang::tidy::modernize {
 
 class LoopConvertCheck : public ClangTidyCheck {
 public:

   const VariableNamer::NamingStyle NamingStyle;
 };
 
-} // namespace modernize
-} // namespace tidy
-} // namespace clang
-
-#endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_MODERNIZE_LOOP_CONVERT_H
+} // namespace clang::tidy::modernize#endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_MODERNIZE_LOOP_CONVERT_H

clang-tools-extra/clang-tidy/modernize/LoopConvertCheck.cpp

 using namespace clang::ast_matchers;
 using namespace llvm;
 
-namespace clang {
-namespace tidy {
-namespace modernize {
+namespace clang::tidy::modernize {
 
 static const char LoopNameArray[] = "forLoopArray";
 static const char LoopNameIterator[] = "forLoopIterator";

                Finder.aliasFromForInit(), Loop, Descriptor);
 }
 
-} // namespace modernize
-} // namespace tidy
-} // namespace clang
+
+} // namespace clang::tidy::modernize

clang-tools-extra/clang-tidy/modernize/LoopConvertUtils.h

 #include <string>
 #include <utility>
 
-namespace clang {
-namespace tidy {
-namespace modernize {
+namespace clang::tidy::modernize {
 
 enum LoopFixerKind { LFK_Array, LFK_Iterator, LFK_PseudoArray };
 

   bool declarationExists(llvm::StringRef Symbol);
 };
 
-} // namespace modernize
-} // namespace tidy
-} // namespace clang
+} // namespace clang::tidy::modernize
 
 #endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_MODERNIZE_LOOP_CONVERT_UTILS_H

clang-tools-extra/clang-tidy/modernize/LoopConvertUtils.cpp

 
 using namespace clang::ast_matchers;
 
-namespace clang {
-namespace tidy {
-namespace modernize {
+namespace clang::tidy::modernize {
 
 /// Tracks a stack of parent statements during traversal.
 ///

   return DeclFinder.findUsages(SourceStmt);
 }
 
-} // namespace modernize
-} // namespace tidy
-} // namespace clang
+} // namespace clang::tidy::modernize

clang-tools-extra/clang-tidy/modernize/MakeSharedCheck.h

 
 #include "MakeSmartPtrCheck.h"
 
-namespace clang {
-namespace tidy {
-namespace modernize {
+namespace clang::tidy::modernize {
 
 /// Replace the pattern:
 /// \code

   SmartPtrTypeMatcher getSmartPointerTypeMatcher() const override;
 };
 
-} // namespace modernize
-} // namespace tidy
-} // namespace clang
-
-#endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_MODERNIZE_MAKE_SHARED_H
+} // namespace clang::tidy::modernize#endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_MODERNIZE_MAKE_SHARED_H

clang-tools-extra/clang-tidy/modernize/MakeSharedCheck.cpp

 
 using namespace clang::ast_matchers;
 
-namespace clang {
-namespace tidy {
-namespace modernize {
+namespace clang::tidy::modernize {
 
 MakeSharedCheck::MakeSharedCheck(StringRef Name, ClangTidyContext *Context)
     : MakeSmartPtrCheck(Name, Context, "std::make_shared") {}

                                      qualType().bind(PointerType)))))))));
 }
 
-} // namespace modernize
-} // namespace tidy
-} // namespace clang
+} // namespace clang::tidy::modernize

clang-tools-extra/clang-tidy/modernize/MakeSmartPtrCheck.h

 #include "llvm/ADT/StringRef.h"
 #include <string>
 
-namespace clang {
-namespace tidy {
-namespace modernize {
+namespace clang::tidy::modernize {
 
 /// Base class for MakeSharedCheck and MakeUniqueCheck.
 class MakeSmartPtrCheck : public ClangTidyCheck {

   void insertHeader(DiagnosticBuilder &Diag, FileID FD);
 };
 
-} // namespace modernize
-} // namespace tidy
-} // namespace clang
-
+} // namespace clang::tidy::modernize
 #endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_MODERNIZE_MAKE_SMART_PTR_H

clang-tools-extra/clang-tidy/modernize/MakeSmartPtrCheck.cpp

 
 using namespace clang::ast_matchers;
 
-namespace clang {
-namespace tidy {
-namespace modernize {
+namespace clang::tidy::modernize {
 
 namespace {
 

       /*IsAngled=*/MakeSmartPtrFunctionHeader == StdMemoryHeader);
 }
 
-} // namespace modernize
-} // namespace tidy
-} // namespace clang
+
+} // namespace clang::tidy::modernize

clang-tools-extra/clang-tidy/modernize/MakeUniqueCheck.h

 
 #include "MakeSmartPtrCheck.h"
 
-namespace clang {
-namespace tidy {
-namespace modernize {
+namespace clang::tidy::modernize {
 
 /// Replace the pattern:
 /// \code

   const bool RequireCPlusPlus14;
 };
 
-} // namespace modernize
-} // namespace tidy
-} // namespace clang
-
+} // namespace clang::tidy::modernize
 #endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_MODERNIZE_MAKE_UNIQUE_H

clang-tools-extra/clang-tidy/modernize/MakeUniqueCheck.cpp

 
 using namespace clang::ast_matchers;
 
-namespace clang {
-namespace tidy {
-namespace modernize {
+namespace clang::tidy::modernize {
 
 MakeUniqueCheck::MakeUniqueCheck(StringRef Name,
                                  clang::tidy::ClangTidyContext *Context)

 
 // FixItHint is done by MakeSmartPtrCheck
 
-} // namespace modernize
-} // namespace tidy
-} // namespace clang
+
+} // namespace clang::tidy::modernize

clang-tools-extra/clang-tidy/modernize/ModernizeTidyModule.cpp

 
 using namespace clang::ast_matchers;
 
-namespace clang {
-namespace tidy {
-namespace modernize {
+namespace clang::tidy::modernize {
 
 class ModernizeModule : public ClangTidyModule {
 public:

 static ClangTidyModuleRegistry::Add<ModernizeModule> X("modernize-module",
                                                        "Add modernize checks.");
 
-} // namespace modernize
-
-// This anchor is used to force the linker to link in the generated object file
+} // namespace clang::tidy::modernize// This anchor is used to force the linker to link in the generated object file
 // and thus register the ModernizeModule.
 volatile int ModernizeModuleAnchorSource = 0;
 
-} // namespace tidy
-} // namespace clang
+
+

clang-tools-extra/clang-tidy/modernize/PassByValueCheck.h

 
 #include <memory>
 
-namespace clang {
-namespace tidy {
-namespace modernize {
+namespace clang::tidy::modernize {
 
 class PassByValueCheck : public ClangTidyCheck {
 public:

   const bool ValuesOnly;
 };
 
-} // namespace modernize
-} // namespace tidy
-} // namespace clang
-
+} // namespace clang::tidy::modernize
 #endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_MODERNIZE_PASS_BY_VALUE_H

clang-tools-extra/clang-tidy/modernize/PassByValueCheck.cpp

 using namespace clang::ast_matchers;
 using namespace llvm;
 
-namespace clang {
-namespace tidy {
-namespace modernize {
+namespace clang::tidy::modernize {
 
 namespace {
 /// Matches move-constructible classes.

               /*IsAngled=*/true);
 }
 
-} // namespace modernize
-} // namespace tidy
-} // namespace clang
+} // namespace clang::tidy::modernize

clang-tools-extra/clang-tidy/modernize/RawStringLiteralCheck.h

 #include "../ClangTidyCheck.h"
 #include <bitset>
 
-namespace clang {
-namespace tidy {
-namespace modernize {
+namespace clang::tidy::modernize {
 
 using CharsBitSet = std::bitset<1 << CHAR_BIT>;
 

   const bool ReplaceShorterLiterals;
 };
 
-} // namespace modernize
-} // namespace tidy
-} // namespace clang
-
+} // namespace clang::tidy::modernize
 #endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_MODERNIZE_RAW_STRING_LITERAL_H

clang-tools-extra/clang-tidy/modernize/RawStringLiteralCheck.cpp

 
 using namespace clang::ast_matchers;
 
-namespace clang {
-namespace tidy {
-namespace modernize {
+namespace clang::tidy::modernize {
 
 namespace {
 

       << FixItHint::CreateReplacement(CharRange, Replacement);
 }
 
-} // namespace modernize
-} // namespace tidy
-} // namespace clang
+} // namespace clang::tidy::modernize

clang-tools-extra/clang-tidy/modernize/RedundantVoidArgCheck.h

 
 #include <string>
 
-namespace clang {
-namespace tidy {
-namespace modernize {
+namespace clang::tidy::modernize {
 
 /// Find and remove redundant void argument lists.
 ///

   void removeVoidToken(Token VoidToken, StringRef Diagnostic);
 };
 
-} // namespace modernize
-} // namespace tidy
-} // namespace clang
-
+} // namespace clang::tidy::modernize
 #endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_MODERNIZE_REDUNDANT_VOID_ARG_CHECK_H

clang-tools-extra/clang-tidy/modernize/RedundantVoidArgCheck.cpp

 
 using namespace clang::ast_matchers;
 
-namespace clang {
-namespace tidy {
-namespace modernize {
+namespace clang::tidy::modernize {
 
 namespace {
 

   }
 }
 
-} // namespace modernize
-} // namespace tidy
-} // namespace clang
+} // namespace clang::tidy::modernize

clang-tools-extra/clang-tidy/modernize/ReplaceAutoPtrCheck.h

 #include "../ClangTidyCheck.h"
 #include "../utils/IncludeInserter.h"
 
-namespace clang {
+namespace clang::tidy::modernize {
 namespace tidy {
 namespace modernize {
 

   const utils::IncludeSorter::IncludeStyle IncludeStyle;
 };
 
-} // namespace modernize
-} // namespace tidy
-} // namespace clang
-
+} // namespace clang::tidy::modernize
 #endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_MODERNIZE_REPLACE_AUTO_PTR_H

clang-tools-extra/clang-tidy/modernize/ReplaceAutoPtrCheck.cpp

 using namespace clang;
 using namespace clang::ast_matchers;
 
-namespace clang {
-namespace tidy {
-namespace modernize {
+namespace clang::tidy::modernize {
 
 namespace {
 static const char AutoPtrTokenId[] = "AutoPrTokenId";

                                       "unique_ptr");
 }
 
-} // namespace modernize
-} // namespace tidy
-} // namespace clang
+} // namespace clang::tidy::modernize

clang-tools-extra/clang-tidy/modernize/ReplaceDisallowCopyAndAssignMacroCheck.h

 
 #include "../ClangTidyCheck.h"
 
-namespace clang {
-namespace tidy {
-namespace modernize {
+namespace clang::tidy::modernize {
 
 /// This check finds macro expansions of ``DISALLOW_COPY_AND_ASSIGN(Type)`` and
 /// replaces them with a deleted copy constructor and a deleted assignment

   const std::string MacroName;
 };
 
-} // namespace modernize
-} // namespace tidy
-} // namespace clang
-
+} // namespace clang::tidy::modernize
 #endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_MODERNIZE_REPLACEDISALLOWCOPYANDASSIGNMACROCHECK_H

clang-tools-extra/clang-tidy/modernize/ReplaceDisallowCopyAndAssignMacroCheck.cpp

 #include "clang/Lex/MacroArgs.h"
 #include "llvm/Support/FormatVariadic.h"
 
-namespace clang {
-namespace tidy {
-namespace modernize {
+namespace clang::tidy::modernize {
 
 namespace {
 

   Options.store(Opts, "MacroName", MacroName);
 }
 
-} // namespace modernize
-} // namespace tidy
-} // namespace clang
+} // namespace clang::tidy::modernize

clang-tools-extra/clang-tidy/modernize/ReplaceRandomShuffleCheck.h

 #include "../ClangTidyCheck.h"
 #include "../utils/IncludeInserter.h"
 
-namespace clang {
-namespace tidy {
-namespace modernize {
+namespace clang::tidy::modernize {
 
 /// std::random_shuffle will be removed as of C++17. This check will find and
 /// replace all occurrences of std::random_shuffle with std::shuffle.

   const utils::IncludeSorter::IncludeStyle IncludeStyle;
 };
 
-} // namespace modernize
-} // namespace tidy
-} // namespace clang
-
+} // namespace clang::tidy::modernize
 #endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_MODERNIZE_REPLACE_RANDOM_SHUFFLE_H

clang-tools-extra/clang-tidy/modernize/ReplaceRandomShuffleCheck.cpp

 
 using namespace clang::ast_matchers;
 
-namespace clang {
-namespace tidy {
-namespace modernize {
+namespace clang::tidy::modernize {
 
 ReplaceRandomShuffleCheck::ReplaceRandomShuffleCheck(StringRef Name,
                                                      ClangTidyContext *Context)

       "random", /*IsAngled=*/true);
 }
 
-} // namespace modernize
-} // namespace tidy
-} // namespace clang
+} // namespace clang::tidy::modernize

clang-tools-extra/clang-tidy/modernize/ReturnBracedInitListCheck.h

 
 #include "../ClangTidyCheck.h"
 
-namespace clang {
-namespace tidy {
-namespace modernize {
+namespace clang::tidy::modernize {
 
 /// Use a braced init list for return statements rather than unnecessary
 /// repeating the return type name.

   void check(const ast_matchers::MatchFinder::MatchResult &Result) override;
 };
 
-} // namespace modernize
-} // namespace tidy
-} // namespace clang
-
+} // namespace clang::tidy::modernize
 #endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_MODERNIZE_RETURN_BRACED_INIT_LIST_H

clang-tools-extra/clang-tidy/modernize/ReturnBracedInitListCheck.cpp

 
 using namespace clang::ast_matchers;
 
-namespace clang {
-namespace tidy {
-namespace modernize {
+namespace clang::tidy::modernize {
 
 void ReturnBracedInitListCheck::registerMatchers(MatchFinder *Finder) {
   // Skip list initialization and constructors with an initializer list.

        << FixItHint::CreateReplacement(CallParensRange.getEnd(), "}");
 }
 
-} // namespace modernize
-} // namespace tidy
-} // namespace clang
+} // namespace clang::tidy::modernize

clang-tools-extra/clang-tidy/modernize/ShrinkToFitCheck.h

 
 #include "../ClangTidyCheck.h"
 
-namespace clang {
-namespace tidy {
-namespace modernize {
+namespace clang::tidy::modernize {
 
 /// Replace copy and swap tricks on shrinkable containers with the
 /// `shrink_to_fit()` method call.

   void check(const ast_matchers::MatchFinder::MatchResult &Result) override;
 };
 
-} // namespace modernize
-} // namespace tidy
-} // namespace clang
-
+} // namespace clang::tidy::modernize
 #endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_MODERNIZE_SHRINKTOFITCHECK_H

clang-tools-extra/clang-tidy/modernize/ShrinkToFitCheck.cpp

 
 using namespace clang::ast_matchers;
 
-namespace clang {
-namespace tidy {
-namespace modernize {
+namespace clang::tidy::modernize {
 
 void ShrinkToFitCheck::registerMatchers(MatchFinder *Finder) {
   // Swap as a function need not to be considered, because rvalue can not

       << Hint;
 }
 
-} // namespace modernize
-} // namespace tidy
-} // namespace clang
+} // namespace clang::tidy::modernize

clang-tools-extra/clang-tidy/modernize/UnaryStaticAssertCheck.h

 
 #include "../ClangTidyCheck.h"
 
-namespace clang {
-namespace tidy {
-namespace modernize {
+namespace clang::tidy::modernize {
 
 /// Replaces a static_assert declaration with an empty message
 /// with the unary version.

   void check(const ast_matchers::MatchFinder::MatchResult &Result) override;
 };
 
-} // namespace modernize
-} // namespace tidy
-} // namespace clang
-
+} // namespace clang::tidy::modernize
 #endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_MODERNIZE_UNARY_STATIC_ASSERT_H

clang-tools-extra/clang-tidy/modernize/UnaryStaticAssertCheck.cpp

 
 using namespace clang::ast_matchers;
 
-namespace clang {
-namespace tidy {
-namespace modernize {
+namespace clang::tidy::modernize {
 
 void UnaryStaticAssertCheck::registerMatchers(MatchFinder *Finder) {
   Finder->addMatcher(staticAssertDecl().bind("static_assert"), this);

       << FixItHint::CreateRemoval(AssertMessage->getSourceRange());
 }
 
-} // namespace modernize
-} // namespace tidy
-} // namespace clang
+} // namespace clang::tidy::modernize

clang-tools-extra/clang-tidy/modernize/UseAutoCheck.h

 
 #include "../ClangTidyCheck.h"
 
-namespace clang {
-namespace tidy {
-namespace modernize {
+namespace clang::tidy::modernize {
 
 class UseAutoCheck : public ClangTidyCheck {
 public:

   const bool RemoveStars;
 };
 
-} // namespace modernize
-} // namespace tidy
-} // namespace clang
-
+} // namespace clang::tidy::modernize
 #endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_MODERNIZE_USE_AUTO_H

clang-tools-extra/clang-tidy/modernize/UseAutoCheck.cpp

 using namespace clang::ast_matchers;
 using namespace clang::ast_matchers::internal;
 
-namespace clang {
-namespace tidy {
-namespace modernize {
+namespace clang::tidy::modernize {
 namespace {
 
 const char IteratorDeclStmtId[] = "iterator_decl";

   }
 }
 
-} // namespace modernize
-} // namespace tidy
-} // namespace clang
+} // namespace clang::tidy::modernize

clang-tools-extra/clang-tidy/modernize/UseBoolLiteralsCheck.h

 
 #include "../ClangTidyCheck.h"
 
-namespace clang {
-namespace tidy {
-namespace modernize {
+namespace clang::tidy::modernize {
 
 /// Finds integer literals which are cast to bool.
 ///

   const bool IgnoreMacros;
 };
 
-} // namespace modernize
-} // namespace tidy
-} // namespace clang
-
+} // namespace clang::tidy::modernize
 #endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_MODERNIZE_USE_BOOL_LITERALS_H

clang-tools-extra/clang-tidy/modernize/UseBoolLiteralsCheck.cpp

 
 using namespace clang::ast_matchers;
 
-namespace clang {
-namespace tidy {
-namespace modernize {
+namespace clang::tidy::modernize {
 
 UseBoolLiteralsCheck::UseBoolLiteralsCheck(StringRef Name,
                                            ClangTidyContext *Context)

         Expression->getSourceRange(), LiteralBooleanValue ? "true" : "false");
 }
 
-} // namespace modernize
-} // namespace tidy
-} // namespace clang
+} // namespace clang::tidy::modernize

clang-tools-extra/clang-tidy/modernize/UseDefaultMemberInitCheck.h

 
 #include "../ClangTidyCheck.h"
 
-namespace clang {
-namespace tidy {
-namespace modernize {
+namespace clang::tidy::modernize {
 
 /// Convert a default constructor's member initializers into default member
 /// initializers.  Remove member initializers that are the same as a default

   const bool IgnoreMacros;
 };
 
-} // namespace modernize
-} // namespace tidy
-} // namespace clang
-
+} // namespace clang::tidy::modernize
 #endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_MODERNIZE_USE_DEFAULT_MEMBER_INIT_H

clang-tools-extra/clang-tidy/modernize/UseDefaultMemberInitCheck.cpp

 
 using namespace clang::ast_matchers;
 
-namespace clang {
-namespace tidy {
-namespace modernize {
+namespace clang::tidy::modernize {
 
 namespace {
 AST_MATCHER_P(InitListExpr, initCountIs, unsigned, N) {

       << FixItHint::CreateRemoval(Init->getSourceRange());
 }
 
-} // namespace modernize
-} // namespace tidy
-} // namespace clang
+} // namespace clang::tidy::modernize

clang-tools-extra/clang-tidy/modernize/UseEmplaceCheck.h

 #include <string>
 #include <vector>
 
-namespace clang {
-namespace tidy {
-namespace modernize {
+namespace clang::tidy::modernize {
 
 /// This check looks for cases when inserting new element into std::vector but
 /// the element is constructed temporarily.

   const std::vector<std::string> TupleMakeFunctions;
 };
 
-} // namespace modernize
-} // namespace tidy
-} // namespace clang
-
+} // namespace clang::tidy::modernize
 #endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_MODERNIZE_USE_EMPLACE_H

clang-tools-extra/clang-tidy/modernize/UseEmplaceCheck.cpp

 #include "../utils/OptionsUtils.h"
 using namespace clang::ast_matchers;
 
-namespace clang {
-namespace tidy {
-namespace modernize {
+namespace clang::tidy::modernize {
 
 namespace {
 AST_MATCHER(DeclRefExpr, hasExplicitTemplateArgs) {

                 utils::options::serializeStringList(TupleMakeFunctions));
 }
 
-} // namespace modernize
-} // namespace tidy
-} // namespace clang
+} // namespace clang::tidy::modernize

clang-tools-extra/clang-tidy/modernize/UseEqualsDefaultCheck.h

 
 #include "../ClangTidyCheck.h"
 
-namespace clang {
-namespace tidy {
-namespace modernize {
+namespace clang::tidy::modernize {
 
 /// Replace default bodies of special member functions with '= default;'.
 /// \code

   const bool IgnoreMacros;
 };
 
-} // namespace modernize
-} // namespace tidy
-} // namespace clang
-
+} // namespace clang::tidy::modernize
 #endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_MODERNIZE_USE_EQUALS_DEFAULT_H

clang-tools-extra/clang-tidy/modernize/UseEqualsDefaultCheck.cpp

 
 using namespace clang::ast_matchers;
 
-namespace clang {
-namespace tidy {
-namespace modernize {
+namespace clang::tidy::modernize {
 
 static const char SpecialFunction[] = "SpecialFunction";
 

   }
 }
 
-} // namespace modernize
-} // namespace tidy
-} // namespace clang
+} // namespace clang::tidy::modernize

clang-tools-extra/clang-tidy/modernize/UseEqualsDeleteCheck.h

 
 #include "../ClangTidyCheck.h"
 
-namespace clang {
-namespace tidy {
-namespace modernize {
+namespace clang::tidy::modernize {
 
 /// Mark unimplemented private special member functions with '= delete'.
 /// \code

   const bool IgnoreMacros;
 };
 
-} // namespace modernize
-} // namespace tidy
-} // namespace clang
-
+} // namespace clang::tidy::modernize
 #endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_MODERNIZE_USE_EQUALS_DELETE_H

clang-tools-extra/clang-tidy/modernize/UseEqualsDeleteCheck.cpp

 
 using namespace clang::ast_matchers;
 
-namespace clang {
-namespace tidy {
-namespace modernize {
+namespace clang::tidy::modernize {
 
 static const char SpecialFunction[] = "SpecialFunction";
 static const char DeletedNotPublic[] = "DeletedNotPublic";

   }
 }
 
-} // namespace modernize
-} // namespace tidy
-} // namespace clang
+} // namespace clang::tidy::modernize

clang-tools-extra/clang-tidy/modernize/UseNodiscardCheck.h

 
 #include "../ClangTidyCheck.h"
 
-namespace clang {
-namespace tidy {
-namespace modernize {
+namespace clang::tidy::modernize {
 
 /// Add ``[[nodiscard]]`` to non-void const-member functions with no
 /// arguments or pass-by-value or pass by const-reference arguments.

   const std::string NoDiscardMacro;
 };
 
-} // namespace modernize
-} // namespace tidy
-} // namespace clang
-
+} // namespace clang::tidy::modernize
 #endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_MODERNIZE_USENODISCARDCHECK_H

clang-tools-extra/clang-tidy/modernize/UseNodiscardCheck.cpp

 
 using namespace clang::ast_matchers;
 
-namespace clang {
-namespace tidy {
-namespace modernize {
+namespace clang::tidy::modernize {
 
 static bool doesNoDiscardMacroExist(ASTContext &Context,
                                     const llvm::StringRef &MacroId) {

   return LangOpts.CPlusPlus;
 }
 
-} // namespace modernize
-} // namespace tidy
-} // namespace clang
+} // namespace clang::tidy::modernize

clang-tools-extra/clang-tidy/modernize/UseNoexceptCheck.h

 
 #include "../ClangTidyCheck.h"
 
-namespace clang {
-namespace tidy {
-namespace modernize {
+namespace clang::tidy::modernize {
 
 /// Replace dynamic exception specifications, with
 /// `noexcept` (or user-defined macro) or `noexcept(false)`.

   const bool UseNoexceptFalse;
 };
 
-} // namespace modernize
-} // namespace tidy
-} // namespace clang
-
+} // namespace clang::tidy::modernize
 #endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_MODERNIZE_USE_NOEXCEPT_H

clang-tools-extra/clang-tidy/modernize/UseNoexceptCheck.cpp

 
 using namespace clang::ast_matchers;
 
-namespace clang {
-namespace tidy {
-namespace modernize {
+namespace clang::tidy::modernize {
 
 namespace {
 AST_MATCHER(NamedDecl, isValid) { return !Node.isInvalidDecl(); }

       << ReplacementStr.empty() << ReplacementStr << FixIt;
 }
 
-} // namespace modernize
-} // namespace tidy
-} // namespace clang
+} // namespace clang::tidy::modernize

clang-tools-extra/clang-tidy/modernize/UseNullptrCheck.h

 
 #include "../ClangTidyCheck.h"
 
-namespace clang {
-namespace tidy {
-namespace modernize {
+namespace clang::tidy::modernize {
 
 class UseNullptrCheck : public ClangTidyCheck {
 public:

   SmallVector<StringRef, 1> NullMacros;
 };
 
-} // namespace modernize
-} // namespace tidy
-} // namespace clang
-
+} // namespace clang::tidy::modernize
 #endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_MODERNIZE_USE_NULLPTR_H

clang-tools-extra/clang-tidy/modernize/UseNullptrCheck.cpp

 using namespace clang::ast_matchers;
 using namespace llvm;
 
-namespace clang {
-namespace tidy {
-namespace modernize {
+namespace clang::tidy::modernize {
 namespace {
 
 const char CastSequence[] = "sequence";

       .TraverseStmt(const_cast<CastExpr *>(NullCast));
 }
 
-} // namespace modernize
-} // namespace tidy
-} // namespace clang
+} // namespace clang::tidy::modernize

clang-tools-extra/clang-tidy/modernize/UseOverrideCheck.h

 
 #include "../ClangTidyCheck.h"
 
-namespace clang {
-namespace tidy {
-namespace modernize {
+namespace clang::tidy::modernize {
 
 /// Use C++11's `override` and remove `virtual` where applicable.
 class UseOverrideCheck : public ClangTidyCheck {

   const std::string FinalSpelling;
 };
 
-} // namespace modernize
-} // namespace tidy
-} // namespace clang
-
+} // namespace clang::tidy::modernize
 #endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_MODERNIZE_USEOVERRIDECHECK_H

clang-tools-extra/clang-tidy/modernize/UseOverrideCheck.cpp

 
 using namespace clang::ast_matchers;
 
-namespace clang {
-namespace tidy {
-namespace modernize {
+namespace clang::tidy::modernize {
 
 UseOverrideCheck::UseOverrideCheck(StringRef Name, ClangTidyContext *Context)
     : ClangTidyCheck(Name, Context),

   }
 }
 
-} // namespace modernize
-} // namespace tidy
-} // namespace clang
+} // namespace clang::tidy::modernize

clang-tools-extra/clang-tidy/modernize/UseTrailingReturnTypeCheck.h

 
 #include "../ClangTidy.h"
 
-namespace clang {
-namespace tidy {
-namespace modernize {
+namespace clang::tidy::modernize {
 
 struct ClassifiedToken {
   Token T;

                       const SourceManager &SM, const LangOptions &LangOpts);
 };
 
-} // namespace modernize
-} // namespace tidy
-} // namespace clang
-
+} // namespace clang::tidy::modernize
 #endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_MODERNIZE_USETRAILINGRETURNTYPECHECK_H

clang-tools-extra/clang-tidy/modernize/UseTrailingReturnTypeCheck.cpp

 
 using namespace clang::ast_matchers;
 
-namespace clang {
-namespace tidy {
-namespace modernize {
+namespace clang::tidy::modernize {
 namespace {
 struct UnqualNameVisitor : public RecursiveASTVisitor<UnqualNameVisitor> {
 public:

       << FixItHint::CreateInsertion(InsertionLoc, " -> " + ReturnType);
 }
 
-} // namespace modernize
-} // namespace tidy
-} // namespace clang
+} // namespace clang::tidy::modernize

clang-tools-extra/clang-tidy/modernize/UseTransparentFunctorsCheck.h

 
 #include "../ClangTidyCheck.h"
 
-namespace clang {
-namespace tidy {
-namespace modernize {
+namespace clang::tidy::modernize {
 
 /// Prefer using transparent functors to non-transparent ones.
 ///

   const bool SafeMode;
 };
 
-} // namespace modernize
-} // namespace tidy
-} // namespace clang
-
+} // namespace clang::tidy::modernize
 #endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_MODERNIZE_USE_TRANSPARENT_FUNCTORS_H

clang-tools-extra/clang-tidy/modernize/UseTransparentFunctorsCheck.cpp

 
 using namespace clang::ast_matchers;
 
-namespace clang {
-namespace tidy {
-namespace modernize {
+namespace clang::tidy::modernize {
 
 UseTransparentFunctorsCheck::UseTransparentFunctorsCheck(
     StringRef Name, ClangTidyContext *Context)

                                   FunctorTypeLoc.getArgLoc(0).getSourceRange());
 }
 
-} // namespace modernize
-} // namespace tidy
-} // namespace clang
+} // namespace clang::tidy::modernize

clang-tools-extra/clang-tidy/modernize/UseUncaughtExceptionsCheck.h

 
 #include "../ClangTidyCheck.h"
 
-namespace clang {
-namespace tidy {
-namespace modernize {
+namespace clang::tidy::modernize {
 
 /// This check will warn on calls to std::uncaught_exception and replace them with calls to
 /// std::uncaught_exceptions, since std::uncaught_exception was deprecated in C++17. In case of

   void check(const ast_matchers::MatchFinder::MatchResult &Result) override;
 };
 
-} // namespace modernize
-} // namespace tidy
-} // namespace clang
-
+} // namespace clang::tidy::modernize
 #endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_MODERNIZE_USE_UNCAUGHT_EXCEPTIONS_H

clang-tools-extra/clang-tidy/modernize/UseUncaughtExceptionsCheck.cpp

 
 using namespace clang::ast_matchers;
 
-namespace clang {
-namespace tidy {
-namespace modernize {
+namespace clang::tidy::modernize {
 
 void UseUncaughtExceptionsCheck::registerMatchers(MatchFinder *Finder) {
   std::string MatchText = "::std::uncaught_exception";

   }
 }
 
-} // namespace modernize
-} // namespace tidy
-} // namespace clang
+} // namespace clang::tidy::modernize

clang-tools-extra/clang-tidy/modernize/UseUsingCheck.h

 
 #include "../ClangTidyCheck.h"
 
-namespace clang {
-namespace tidy {
-namespace modernize {
+namespace clang::tidy::modernize {
 
 /// Check finds typedefs and replaces it with usings.
 ///

   void check(const ast_matchers::MatchFinder::MatchResult &Result) override;
 };
 
-} // namespace modernize
-} // namespace tidy
-} // namespace clang
-
+} // namespace clang::tidy::modernize
 #endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_MODERNIZE_USE_USING_H

clang-tools-extra/clang-tidy/modernize/UseUsingCheck.cpp

 
 using namespace clang::ast_matchers;
 
-namespace clang {
-namespace tidy {
-namespace modernize {
+namespace clang::tidy::modernize {
 
 UseUsingCheck::UseUsingCheck(StringRef Name, ClangTidyContext *Context)
     : ClangTidyCheck(Name, Context),

   std::string Replacement = Using + Name + " = " + Type;
   Diag << FixItHint::CreateReplacement(ReplaceRange, Replacement);
 }
-} // namespace modernize
-} // namespace tidy
-} // namespace clang
+
+} // namespace clang::tidy::modernize

clang/lib/Analysis/Consumed.cpp

 
 } // namespace
 
-namespace clang {
-namespace consumed {
+namespace clang::consumed {
 
 enum EffectiveOp {
   EO_And,

   }
 };
 
-} // namespace consumed
-} // namespace clang
+} // namespace clang::consumed
 
 static void
 setStateForVarOrTmp(ConsumedStateMap *StateMap, const PropagationInfo &PInfo,

     StateMap->setState(PInfo.getTmp(), State);
 }
 
-namespace clang {
-namespace consumed {
+namespace clang::consumed {
 
 class ConsumedStmtVisitor : public ConstStmtVisitor<ConsumedStmtVisitor> {
   using MapType = llvm::DenseMap<const Stmt *, PropagationInfo>;

   }
 };
 
-} // namespace consumed
-} // namespace clang
+} // namespace clang::consumed
 
 void ConsumedStmtVisitor::forwardInfo(const Expr *From, const Expr *To) {
   InfoEntry Entry = findInfo(From);

clang/lib/Analysis/ReachableCode.cpp

 // Reachability APIs.
 //===----------------------------------------------------------------------===//
 
-namespace clang { namespace reachable_code {
+namespace clang::reachable_code {
 
 void Callback::anchor() { }
 

   }
 }
 
-}} // end namespace clang::reachable_code
+}// end namespace clang::reachable_code

clang/lib/Analysis/ThreadSafety.cpp

 
 } // namespace
 
-namespace clang {
-namespace threadSafety {
+namespace clang::threadSafety {
 
 class BeforeSet {
 private:

   BeforeMap BMap;
   CycleMap CycMap;
 };
-
-} // namespace threadSafety
-} // namespace clang
+} // namespace clang::threadSafety
 
 namespace {
 

clang/lib/Analysis/ThreadSafetyCommon.cpp

 
 } // namespace
 
-namespace clang {
-namespace threadSafety {
+namespace clang::threadSafety {
 
 void printSCFG(CFGWalker &Walker) {
   llvm::BumpPtrAllocator Bpa;

   TILPrinter::print(Scfg, llvm::errs());
 }
 
-} // namespace threadSafety
-} // namespace clang
+} // namespace clang::threadSafety
 */

clang/lib/Analysis/ThreadSafetyLogical.cpp

   return cast<Terminal>(LHS)->expr() == cast<Terminal>(RHS)->expr();
 }
 
-namespace clang {
-namespace threadSafety {
-namespace lexpr {
+namespace clang::threadSafety::lexpr {
 
 bool implies(const LExpr *LHS, const LExpr *RHS) {
   // Start out by assuming that LHS and RHS are not negated.
   return ::implies(LHS, false, RHS, false);
 }
 }
-}
-}