Refactor: Move misc clang-tidy checks to namespace clang::tidy::misc

[LegalizeAdulthood]

Summary

clang-tidy checks are organized into modules. This refactoring moves the misc module checks into the namespace clang::tidy::misc

[alexfh]

Looks good!

I'll commit the patch for you.

[alexfh]

Committed revision 230950.

clang-tidy/misc/ArgumentCommentCheck.h

 #ifndef LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_MISC_ARG_COMMENT_CHECK_H
 #define LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_MISC_ARG_COMMENT_CHECK_H
 
 #include "../ClangTidy.h"
 #include "llvm/Support/Regex.h"
 
 namespace clang {
 namespace tidy {
+namespace misc {
 
 /// \brief Checks that argument comments match parameter names.
 class ArgumentCommentCheck : public ClangTidyCheck {
 public:
   ArgumentCommentCheck(StringRef Name, ClangTidyContext *Context);
 
   void registerMatchers(ast_matchers::MatchFinder *Finder) override;
   void check(const ast_matchers::MatchFinder::MatchResult &Result) override;
 
 private:
   llvm::Regex IdentRE;
 
   bool isLikelyTypo(llvm::ArrayRef<ParmVarDecl *> Params, StringRef ArgName,
                     unsigned ArgIndex);
   std::vector<std::pair<SourceLocation, StringRef>>
   getCommentsInRange(ASTContext *Ctx, SourceRange Range);
   void checkCallArgs(ASTContext *Ctx, const FunctionDecl *Callee,
                      SourceLocation ArgBeginLoc,
                      llvm::ArrayRef<const Expr *> Args);
 };
 
+} // namespace misc
 } // namespace tidy
 } // namespace clang
 
 #endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_MISC_ARG_COMMENT_CHECK_H

clang-tidy/misc/ArgumentCommentCheck.cpp

 #include "clang/ASTMatchers/ASTMatchFinder.h"
 #include "clang/Lex/Lexer.h"
 #include "clang/Lex/Token.h"
 
 using namespace clang::ast_matchers;
 
 namespace clang {
 namespace tidy {
+namespace misc {
 
 ArgumentCommentCheck::ArgumentCommentCheck(StringRef Name,
                                            ClangTidyContext *Context)
     : ClangTidyCheck(Name, Context),
       IdentRE("^(/\\* *)([_A-Za-z][_A-Za-z0-9]*)( *= *\\*/)$") {}
 
 void ArgumentCommentCheck::registerMatchers(MatchFinder *Finder) {
   Finder->addMatcher(
if (auto Call = dyn_cast<CallExpr>(E)) {
     auto Construct = cast<CXXConstructExpr>(E);
     checkCallArgs(
         Result.Context, Construct->getConstructor(),
         Construct->getParenOrBraceRange().getBegin(),
         llvm::makeArrayRef(Construct->getArgs(), Construct->getNumArgs()));
   }
 }
 
+} // namespace misc
 } // namespace tidy
 } // namespace clang

clang-tidy/misc/AssignOperatorSignatureCheck.h

 //===--- AssignOperatorSignatureCheck.h - clang-tidy ------------*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_MISC_ASSIGN_OPERATOR_SIGNATURE_CHECK_H
 #define LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_MISC_ASSIGN_OPERATOR_SIGNATURE_CHECK_H
 
 #include "../ClangTidy.h"
 
 namespace clang {
 namespace tidy {
+namespace misc {
 
 /// \brief Finds declarations of assign operators with the wrong return and/or
 ///   argument types.
 ///
 /// The return type must be \c Class&.
 /// Works with move-assign and assign by value.
 /// Private and deleted operators are ignored.
 class AssignOperatorSignatureCheck : public ClangTidyCheck {
 public:
   AssignOperatorSignatureCheck(StringRef Name, ClangTidyContext *Context)
       : ClangTidyCheck(Name, Context) {}
   void registerMatchers(ast_matchers::MatchFinder *Finder) override;
   void check(const ast_matchers::MatchFinder::MatchResult &Result) override;
 };
 
+} // namespace misc
 } // namespace tidy
 } // namespace clang
 
 #endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_MISC_ASSIGN_OPERATOR_SIGNATURE_CHECK_H

clang-tidy/misc/AssignOperatorSignatureCheck.cpp

 #include "AssignOperatorSignatureCheck.h"
 #include "clang/ASTMatchers/ASTMatchFinder.h"
 #include "clang/ASTMatchers/ASTMatchers.h"
 
 using namespace clang::ast_matchers;
 
 namespace clang {
 namespace tidy {
+namespace misc {
 
 void AssignOperatorSignatureCheck::registerMatchers(
     ast_matchers::MatchFinder *Finder) {
   const auto HasGoodReturnType = methodDecl(returns(lValueReferenceType(pointee(
       unless(isConstQualified()), hasDeclaration(equalsBoundNode("class"))))));
 
   const auto IsSelf = qualType(
       anyOf(hasDeclaration(equalsBoundNode("class")),
void AssignOperatorSignatureCheck::check(
   };
 
   for (const auto& Message : Messages) {
     if (Result.Nodes.getNodeAs<Decl>(Message[0]))
       diag(Method->getLocStart(), Message[1]) << Name;
   }
 }
 
+} // namespace misc
 } // namespace tidy
 } // namespace clang

clang-tidy/misc/BoolPointerImplicitConversion.h

 //===--- BoolPointerImplicitConversion.h - clang-tidy -----------*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_MISC_BOOL_POINTER_IMPLICIT_CONV_H
 #define LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_MISC_BOOL_POINTER_IMPLICIT_CONV_H
 
 #include "../ClangTidy.h"
 
 namespace clang {
 namespace tidy {
+namespace misc {
 
 /// \brief Checks for conditions based on implicit conversion from a bool
 /// pointer to bool e.g.
 /// bool *p;
 /// if (p) {
 ///   // Never used in a pointer-specific way.
 /// }
 class BoolPointerImplicitConversion : public ClangTidyCheck {
 public:
   BoolPointerImplicitConversion(StringRef Name, ClangTidyContext *Context)
       : ClangTidyCheck(Name, Context) {}
   void registerMatchers(ast_matchers::MatchFinder *Finder) override;
   void check(const ast_matchers::MatchFinder::MatchResult &Result) override;
 };
 
+} // namespace misc
 } // namespace tidy
 } // namespace clang
 
 #endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_MISC_BOOL_POINTER_IMPLICIT_CONV_H
 

clang-tidy/misc/BoolPointerImplicitConversion.cpp

 AST_MATCHER(CastExpr, isPointerToBoolean) {
   return Node.getCastKind() == CK_PointerToBoolean;
 }
 AST_MATCHER(QualType, isBoolean) { return Node->isBooleanType(); }
 
 } // namespace ast_matchers
 
 namespace tidy {
+namespace misc {
 
 void BoolPointerImplicitConversion::registerMatchers(MatchFinder *Finder) {
   // Look for ifs that have an implicit bool* to bool conversion in the
   // condition. Filter negations.
   Finder->addMatcher(
       ifStmt(hasCondition(findAll(implicitCastExpr(
                  allOf(unless(hasParent(unaryOperator(hasOperatorName("!")))),
                        hasSourceExpression(expr(
if (!match(findAll(
            .empty())
     return;
 
   diag(Var->getLocStart(), "dubious check of 'bool *' against 'nullptr', did "
                            "you mean to dereference it?")
       << FixItHint::CreateInsertion(Var->getLocStart(), "*");
 }
 
+} // namespace misc
 } // namespace tidy
 } // namespace clang

clang-tidy/misc/InaccurateEraseCheck.h

 //===--- InaccurateEraseCheck.h - clang-tidy---------------------*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_MISC_INACCURATE_ERASE_H
 #define LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_MISC_INACCURATE_ERASE_H
 
 #include "../ClangTidy.h"
 
 namespace clang {
 namespace tidy {
+namespace misc {
 
 /// \brief Checks for inaccurate use of \c erase() method.
 ///
 /// Algorithms like \c remove() do not actually remove any element from the
 /// container but return an iterator to the first redundant element at the end
 /// of the container. These redundant elements must be removed using the
 /// \c erase() method. This check warns when not all of the elements will be
 /// removed due to using an inappropriate overload.
 class InaccurateEraseCheck : public ClangTidyCheck {
 public:
   InaccurateEraseCheck(StringRef Name, ClangTidyContext *Context)
       : ClangTidyCheck(Name, Context) {}
   void registerMatchers(ast_matchers::MatchFinder *Finder) override;
   void check(const ast_matchers::MatchFinder::MatchResult &Result) override;
 };
 
+} // namespace misc
 } // namespace tidy
 } // namespace clang
 
 #endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_MISC_INACCURATE_ERASE_H

clang-tidy/misc/InaccurateEraseCheck.cpp

 #include "clang/AST/ASTContext.h"
 #include "clang/ASTMatchers/ASTMatchFinder.h"
 #include "clang/Lex/Lexer.h"
 
 using namespace clang::ast_matchers;
 
 namespace clang {
 namespace tidy {
+namespace misc {
 
 void InaccurateEraseCheck::registerMatchers(MatchFinder *Finder) {
   const auto CheckForEndCall = hasArgument(
       1,
       anyOf(constructExpr(has(memberCallExpr(callee(methodDecl(hasName("end"))))
                                   .bind("InaccEndCall"))),
             anything()));
 
if (!Loc.isMacroID() && EndExpr) {
     Hint = FixItHint::CreateInsertion(EndLoc, ", " + ReplacementText);
   }
 
   diag(Loc, "this call will remove at most one item even when multiple items "
             "should be removed")
       << Hint;
 }
 
+} // namespace misc
 } // namespace tidy
 } // namespace clang

clang-tidy/misc/InefficientAlgorithmCheck.h

 //===--- InefficientAlgorithmCheck.h - clang-tidy----------------*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_MISC_INEFFICIENT_ALGORITHM_H
 #define LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_MISC_INEFFICIENT_ALGORITHM_H
 
 #include "../ClangTidy.h"
 
 namespace clang {
 namespace tidy {
+namespace misc {
 
 /// \brief Warns on inefficient use of STL algorithms on associative containers.
 ///
 /// Associative containers implements some of the algorithms as methods which
 /// should be preferred to the algorithms in the algorithm header. The methods
 /// can take advanatage of the order of the elements.
 class InefficientAlgorithmCheck : public ClangTidyCheck {
 public:
   InefficientAlgorithmCheck(StringRef Name, ClangTidyContext *Context)
       : ClangTidyCheck(Name, Context) {}
   void registerMatchers(ast_matchers::MatchFinder *Finder) override;
   void check(const ast_matchers::MatchFinder::MatchResult &Result) override;
 };
 
+} // namespace misc
 } // namespace tidy
 } // namespace clang
 
 #endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_MISC_INEFFICIENT_ALGORITHM_H

clang-tidy/misc/InefficientAlgorithmCheck.cpp

 #include "clang/AST/ASTContext.h"
 #include "clang/ASTMatchers/ASTMatchFinder.h"
 #include "clang/Lex/Lexer.h"
 
 using namespace clang::ast_matchers;
 
 namespace clang {
 namespace tidy {
+namespace misc {
 
 static bool areTypesCompatible(QualType Left, QualType Right) {
   if (const auto *LeftRefType = Left->getAs<ReferenceType>())
     Left = LeftRefType->getPointeeType();
   if (const auto *RightRefType = Right->getAs<ReferenceType>())
     Right = RightRefType->getPointeeType();
   return Left->getCanonicalTypeUnqualified() ==
          Right->getCanonicalTypeUnqualified();
Hint = FixItHint::CreateReplacement(AlgCall->getSourceRange(),
                                         ReplacementText);
   }
 
   diag(AlgCall->getLocStart(),
        "this STL algorithm call should be replaced with a container method")
       << Hint;
 }
 
+} // namespace misc
 } // namespace tidy
 } // namespace clang

clang-tidy/misc/MiscTidyModule.cpp

 #include "SwappedArgumentsCheck.h"
 #include "UndelegatedConstructor.h"
 #include "UniqueptrResetRelease.h"
 #include "UnusedRAII.h"
 #include "UseOverride.h"
 
 namespace clang {
 namespace tidy {
+namespace misc {
 
 class MiscModule : public ClangTidyModule {
 public:
   void addCheckFactories(ClangTidyCheckFactories &CheckFactories) override {
     CheckFactories.registerCheck<ArgumentCommentCheck>("misc-argument-comment");
     CheckFactories.registerCheck<AssignOperatorSignatureCheck>(
         "misc-assign-operator-signature");
     CheckFactories.registerCheck<BoolPointerImplicitConversion>(
         "misc-bool-pointer-implicit-conversion");
     CheckFactories.registerCheck<InaccurateEraseCheck>(
         "misc-inaccurate-erase");
     CheckFactories.registerCheck<InefficientAlgorithmCheck>(
         "misc-inefficient-algorithm");
     CheckFactories.registerCheck<SwappedArgumentsCheck>(
         "misc-swapped-arguments");
     CheckFactories.registerCheck<UndelegatedConstructorCheck>(
         "misc-undelegated-constructor");
     CheckFactories.registerCheck<UniqueptrResetRelease>(
         "misc-uniqueptr-reset-release");
     CheckFactories.registerCheck<UnusedRAIICheck>("misc-unused-raii");
     CheckFactories.registerCheck<UseOverride>("misc-use-override");
   }
 };
 
+} // namespace misc
+
 // Register the MiscTidyModule using this statically initialized variable.
-static ClangTidyModuleRegistry::Add<MiscModule>
+static ClangTidyModuleRegistry::Add<misc::MiscModule>
 X("misc-module", "Adds miscellaneous lint checks.");
 
 // This anchor is used to force the linker to link in the generated object file
 // and thus register the MiscModule.
 volatile int MiscModuleAnchorSource = 0;
 
 } // namespace tidy
 } // namespace clang

clang-tidy/misc/SwappedArgumentsCheck.h

 //===--- SwappedArgumentsCheck.h - clang-tidy -------------------*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_MISC_SWAPPED_ARGUMENTS_CHECK_H
 #define LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_MISC_SWAPPED_ARGUMENTS_CHECK_H
 
 #include "../ClangTidy.h"
 
 namespace clang {
 namespace tidy {
+namespace misc {
 
 /// \brief Finds potentially swapped arguments by looking at implicit
 /// conversions.
 class SwappedArgumentsCheck : public ClangTidyCheck {
 public:
   SwappedArgumentsCheck(StringRef Name, ClangTidyContext *Context)
       : ClangTidyCheck(Name, Context) {}
   void registerMatchers(ast_matchers::MatchFinder *Finder) override;
   void check(const ast_matchers::MatchFinder::MatchResult &Result) override;
 };
 
+} // namespace misc
 } // namespace tidy
 } // namespace clang
 
 #endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_MISC_SWAPPED_ARGUMENTS_CHECK_H
-

clang-tidy/misc/SwappedArgumentsCheck.cpp

 #include "clang/AST/ASTContext.h"
 #include "clang/Lex/Lexer.h"
 #include "llvm/ADT/SmallPtrSet.h"
 
 using namespace clang::ast_matchers;
 
 namespace clang {
 namespace tidy {
+namespace misc {
 
 void SwappedArgumentsCheck::registerMatchers(MatchFinder *Finder) {
   Finder->addMatcher(callExpr().bind("call"), this);
 }
 
 /// \brief Look through lvalue to rvalue and nop casts. This filters out
 /// implicit conversions that have no effect on the input but block our view for
 /// other implicit casts.
if (!LHSString.empty() && !RHSString.empty()) {
                CharSourceRange::getTokenRange(RHSRange), LHSString);
     }
 
     // Remember that we emitted a warning for this argument.
     UsedArgs.insert(RHSCast);
   }
 }
 
+} // namespace misc
 } // namespace tidy
 } // namespace clang

clang-tidy/misc/UndelegatedConstructor.h

 //===--- UndelegatedConstructor.h - clang-tidy ------------------*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_MISC_UNDELEGATED_CONSTRUCTOR_H
 #define LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_MISC_UNDELEGATED_CONSTRUCTOR_H
 
 #include "../ClangTidy.h"
 
 namespace clang {
 namespace tidy {
+namespace misc {
 
 /// \brief Finds creation of temporary objects in constructors that look like a
 /// function call to another constructor of the same class. The user most likely
 /// meant to use a delegating constructor or base class initializer.
 class UndelegatedConstructorCheck : public ClangTidyCheck {
 public:
   UndelegatedConstructorCheck(StringRef Name, ClangTidyContext *Context)
       : ClangTidyCheck(Name, Context) {}
   void registerMatchers(ast_matchers::MatchFinder *Finder) override;
   void check(const ast_matchers::MatchFinder::MatchResult &Result) override;
 };
 
+} // namespace misc
 } // namespace tidy
 } // namespace clang
 
 #endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_MISC_UNDELEGATED_CONSTRUCTOR_H

clang-tidy/misc/UndelegatedConstructor.cpp

AST_MATCHER_P(CXXRecordDecl, baseOfBoundNode, std::string, ID) {
   return Builder->removeBindings([&](const internal::BoundNodesMap &Nodes) {
     const auto *Derived = Nodes.getNodeAs<CXXRecordDecl>(ID);
     return Derived != &Node && !Derived->isDerivedFrom(&Node);
   });
 }
 } // namespace ast_matchers
 
 namespace tidy {
+namespace misc {
 
 void UndelegatedConstructorCheck::registerMatchers(MatchFinder *Finder) {
   // We look for calls to constructors of the same type in constructors. To do
   // this we have to look through a variety of nodes that occur in the path,
   // depending on the type's destructor and the number of arguments on the
   // constructor call, this is handled by ignoringTemporaryExpr. Ignore template
   // instantiations to reduce the number of duplicated warnings.
   Finder->addMatcher(
       compoundStmt(
           hasParent(constructorDecl(ofClass(recordDecl().bind("parent")))),
           forEach(ignoringTemporaryExpr(
               constructExpr(hasDeclaration(constructorDecl(ofClass(
                                 recordDecl(baseOfBoundNode("parent"))))))
                   .bind("construct"))),
           unless(isInTemplateInstantiation())),
       this);
 }
 
 void UndelegatedConstructorCheck::check(const MatchFinder::MatchResult &Result) {
   const auto *E = Result.Nodes.getStmtAs<CXXConstructExpr>("construct");
   diag(E->getLocStart(), "did you intend to call a delegated constructor? "
                          "A temporary object is created here instead");
 }
 
+} // namespace misc
 } // namespace tidy
 } // namespace clang

clang-tidy/misc/UniqueptrResetRelease.h

 //===--- UniqueptrResetRelease.h - clang-tidy -------------------*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_MISC_UNIQUEPTR_RESET_RELEASE_H
 #define LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_MISC_UNIQUEPTR_RESET_RELEASE_H
 
 #include "../ClangTidy.h"
 
 namespace clang {
 namespace tidy {
+namespace misc {
 
 /// \brief Find and replace unique_ptr::reset(release()) with std::move
 ///
 /// Example:
 ///   std::unique_ptr<Foo> x, y;
 ///   x.reset(y.release()); -> x = std::move(y);
 ///
 /// If "y" is already rvalue, std::move is not added.
 /// "x" and "y" can also be std::unique_ptr<Foo>*.
 class UniqueptrResetRelease : public ClangTidyCheck {
 public:
   UniqueptrResetRelease(StringRef Name, ClangTidyContext *Context)
       : ClangTidyCheck(Name, Context) {}
 
   void registerMatchers(ast_matchers::MatchFinder *Finder) override;
   void check(const ast_matchers::MatchFinder::MatchResult &Result) override;
 };
 
+} // namespace misc
 } // namespace tidy
 } // namespace clang
 
 #endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_MISC_UNIQUEPTR_RESET_RELEASE_H

clang-tidy/misc/UniqueptrResetRelease.cpp

 #include "UniqueptrResetRelease.h"
 #include "clang/ASTMatchers/ASTMatchFinder.h"
 #include "clang/Lex/Lexer.h"
 
 using namespace clang::ast_matchers;
 
 namespace clang {
 namespace tidy {
+namespace misc {
 
 void UniqueptrResetRelease::registerMatchers(MatchFinder *Finder) {
   Finder->addMatcher(
       memberCallExpr(
           on(expr().bind("left")), callee(memberExpr().bind("reset_member")),
           callee(methodDecl(hasName("reset"),
                             ofClass(hasName("::std::unique_ptr")))),
           has(memberCallExpr(
void UniqueptrResetRelease::check(const MatchFinder::MatchResult &Result) {
   std::string NewText = LeftText + " = " + RightText;
 
   diag(ResetMember->getExprLoc(),
        "prefer ptr1 = std::move(ptr2) over ptr1.reset(ptr2.release())")
       << FixItHint::CreateReplacement(
           CharSourceRange::getTokenRange(ResetCall->getSourceRange()), NewText);
 }
 
+} // namespace misc
 } // namespace tidy
 } // namespace clang

clang-tidy/misc/UnusedRAII.h

 //===--- UnusedRAII.h - clang-tidy ------------------------------*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_MISC_UNUSED_RAII_H
 #define LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_MISC_UNUSED_RAII_H
 
 #include "../ClangTidy.h"
 
 namespace clang {
 namespace tidy {
+namespace misc {
 
 /// \brief Finds temporaries that look like RAII objects.
 ///
 /// The canonical example for this is a scoped lock.
 /// \code
 ///   {
 ///     scoped_lock(&global_mutex);
 ///     critical_section();

 class UnusedRAIICheck : public ClangTidyCheck {
 public:
   UnusedRAIICheck(StringRef Name, ClangTidyContext *Context)
       : ClangTidyCheck(Name, Context) {}
   void registerMatchers(ast_matchers::MatchFinder *Finder) override;
   void check(const ast_matchers::MatchFinder::MatchResult &Result) override;
 };
 
+} // namespace misc
 } // namespace tidy
 } // namespace clang
 
 #endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_MISC_UNUSED_RAII_H

clang-tidy/misc/UnusedRAII.cpp

 namespace ast_matchers {
 AST_MATCHER(CXXRecordDecl, hasUserDeclaredDestructor) {
   // TODO: If the dtor is there but empty we don't want to warn either.
   return Node.hasDefinition() && Node.hasUserDeclaredDestructor();
 }
 } // namespace ast_matchers
 
 namespace tidy {
+namespace misc {
 
 void UnusedRAIICheck::registerMatchers(MatchFinder *Finder) {
   // Look for temporaries that are constructed in-place and immediately
   // destroyed. Look for temporaries created by a functional cast but not for
   // those returned from a call.
   auto BindTemp = bindTemporaryExpr(unless(has(callExpr()))).bind("temp");
   Finder->addMatcher(
       exprWithCleanups(unless(isInTemplateInstantiation()),
auto Matches =
       match(expr(hasDescendant(typeLoc().bind("t"))), *E, *Result.Context);
   const auto *TL = selectFirst<TypeLoc>("t", Matches);
   D << FixItHint::CreateInsertion(
       Lexer::getLocForEndOfToken(TL->getLocEnd(), 0, *Result.SourceManager,
                                  Result.Context->getLangOpts()),
       Replacement);
 }
 
+} // namespace misc
 } // namespace tidy
 } // namespace clang

clang-tidy/misc/UseOverride.h

 //===--- UseOverride.h - clang-tidy -----------------------------*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_MISC_USE_OVERRIDE_H
 #define LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_MISC_USE_OVERRIDE_H
 
 #include "../ClangTidy.h"
 
 namespace clang {
 namespace tidy {
+namespace misc {
 
 /// \brief Use C++11's 'override' and remove 'virtual' where applicable.
 class UseOverride : public ClangTidyCheck {
 public:
   UseOverride(StringRef Name, ClangTidyContext *Context)
       : ClangTidyCheck(Name, Context) {}
   void registerMatchers(ast_matchers::MatchFinder *Finder) override;
   void check(const ast_matchers::MatchFinder::MatchResult &Result) override;
 };
 
+} // namespace misc
 } // namespace tidy
 } // namespace clang
 
 #endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_MISC_USE_OVERRIDE_H
-

clang-tidy/misc/UseOverride.cpp

 #include "clang/AST/ASTContext.h"
 #include "clang/ASTMatchers/ASTMatchFinder.h"
 #include "clang/Lex/Lexer.h"
 
 using namespace clang::ast_matchers;
 
 namespace clang {
 namespace tidy {
+namespace misc {
 
 void UseOverride::registerMatchers(MatchFinder *Finder) {
   Finder->addMatcher(methodDecl(isOverride()).bind("method"), this);
 }
 
 // Re-lex the tokens to get precise locations to insert 'override' and remove
 // 'virtual'.
 static SmallVector<Token, 16>
for (Token Tok : Tokens) {
         Diag << FixItHint::CreateRemoval(CharSourceRange::getTokenRange(
             Tok.getLocation(), Tok.getLocation()));
         break;
       }
     }
   }
 }
 
+} // namespace misc
 } // namespace tidy
 } // namespace clang

unittests/clang-tidy/MiscModuleTest.cpp

 #include "ClangTidyTest.h"
 #include "misc/ArgumentCommentCheck.h"
 #include "readability/BracesAroundStatementsCheck.h"
 #include "gtest/gtest.h"
 
 namespace clang {
 namespace tidy {
 
+using misc::ArgumentCommentCheck;
 using readability::BracesAroundStatementsCheck;
 
 namespace test {
 
 #define EXPECT_NO_CHANGES(Check, Code)                                         \
   EXPECT_EQ(Code, runCheckOnCode<Check>(Code))
 
 TEST(ArgumentCommentCheckTest, CorrectComments) {