[clang-tidy] Cleanup code in CERT module.

[hokein]

Summary

This patch fixes some code styles caused by bugs of add_new_check.py script.

[hokein]

Update.

[hokein]

I'm wondering whether should we rename CERT to cert to keep the same with other modules like misc and google.
For adding a new check in CERT module, you need to use the upper name explicitly via python add_new_check.py CERT foo rather than python add_new_check.py cert foo.

[alexfh]

In D15805#317629, @hokein wrote:

I'm wondering whether should we rename CERT to cert to keep the same with other modules like misc and google.

SGTM. Aaron, do you see any reasons not to do this?

[aaron.ballman]

Fine by me -- I went with CERT since it's an acronym, but we don't do this for LLVM, so this change makes sense. Thanks!

[alexfh]

In D15805#317657, @aaron.ballman wrote:

Fine by me -- I went with CERT since it's an acronym, but we don't do this for LLVM, so this change makes sense. Thanks!

AFAIU, LLVM is not an acronym anymore ;) (but still an upper-case spelling is the correct one).

[aaron.ballman]

Fine by me -- I went with CERT since it's an acronym, but we don't do this for LLVM, so this change makes sense. Thanks!

In D15805#317736, @alexfh wrote:

In D15805#317657, @aaron.ballman wrote:

Fine by me -- I went with CERT since it's an acronym, but we don't do this for LLVM, so this change makes sense. Thanks!

AFAIU, LLVM is not an acronym anymore ;) (but still an upper-case spelling is the correct one).

Hah, good point. ;-) Regardless, I am fine with the namespace being "cert" in code so that it isn't confused with a macro.

[hokein]

So shoud we need to rename to cert at this patch?

[aaron.ballman]

In D15805#318307, @hokein wrote:

So shoud we need to rename to cert at this patch?

Yes, but just the namespaces as you do in this patch (not anything in user documentation, for instance). This patch LG; if you need me to commit on your behalf, I'm happy to do so.

[hokein]

Rename: 'CERT' => 'cert'

[hokein]

Yes, but just the namespaces as you do in this patch (not anything in user documentation, for instance). This patch LG; if you need me to commit on your behalf, I'm happy to do so.

Done. But My account has no write access to the code repo. Can I commit the patch by myself? If not, I'm happy you can land it on my behalf :)

[aaron.ballman]

In D15805#318624, @hokein wrote:

Yes, but just the namespaces as you do in this patch (not anything in user documentation, for instance). This patch LG; if you need me to commit on your behalf, I'm happy to do so.

Done. But My account has no write access to the code repo. Can I commit the patch by myself? If not, I'm happy you can land it on my behalf :)

You can ask Chris Lattner for commit privileges if you would like to commit this yourself (http://llvm.org/docs/DeveloperPolicy.html#obtaining-commit-access). Let me know if you want me to commit instead.

[hokein]

In D15805#318646, @aaron.ballman wrote:

In D15805#318624, @hokein wrote:

Yes, but just the namespaces as you do in this patch (not anything in user documentation, for instance). This patch LG; if you need me to commit on your behalf, I'm happy to do so.

Done. But My account has no write access to the code repo. Can I commit the patch by myself? If not, I'm happy you can land it on my behalf :)

You can ask Chris Lattner for commit privileges if you would like to commit this yourself (http://llvm.org/docs/DeveloperPolicy.html#obtaining-commit-access). Let me know if you want me to commit instead.

Thanks for the link. Please commit for me this time :)

[aaron.ballman]

I've commit in r256756, thanks!

clang-tidy/cert/CERTTidyModule.cpp

 #include "../misc/ThrowByValueCatchByReferenceCheck.h"
 #include "SetLongJmpCheck.h"
 #include "StaticObjectExceptionCheck.h"
 #include "ThrownExceptionTypeCheck.h"
 #include "VariadicFunctionDefCheck.h"
 
 namespace clang {
 namespace tidy {
-namespace CERT {
+namespace cert {
 
 class CERTModule : public ClangTidyModule {
 public:
   void addCheckFactories(ClangTidyCheckFactories &CheckFactories) override {
     // C++ checkers
     // DCL
     CheckFactories.registerCheck<VariadicFunctionDefCheck>(
         "cert-dcl50-cpp");
CheckFactories.registerCheck<StaticAssertCheck>(
         "cert-dcl03-c");
 
     // FIO
     CheckFactories.registerCheck<NonCopyableObjectsCheck>(
         "cert-fio38-c");
   }
 };
 
-} // namespace misc
+} // namespace cert
 
 // Register the MiscTidyModule using this statically initialized variable.
-static ClangTidyModuleRegistry::Add<CERT::CERTModule>
+static ClangTidyModuleRegistry::Add<cert::CERTModule>
 X("cert-module",
   "Adds lint checks corresponding to CERT secure coding guidelines.");
 
 // This anchor is used to force the linker to link in the generated object file
 // and thus register the CERTModule.
 volatile int CERTModuleAnchorSource = 0;
 
 } // namespace tidy
 } // namespace clang

clang-tidy/cert/SetLongJmpCheck.h

 //===--- SetLongJmpCheck.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_SETLONGJMPCHECK_H
 #define LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_SETLONGJMPCHECK_H
 
 #include "../ClangTidy.h"
 
 namespace clang {
 namespace tidy {
+namespace cert {
 
 /// Guards against use of setjmp/longjmp in C++ code
 ///
 /// For the user-facing documentation see:
 /// http://clang.llvm.org/extra/clang-tidy/checks/cert-err52-cpp.html
 class SetLongJmpCheck : public ClangTidyCheck {
 public:
   SetLongJmpCheck(StringRef Name, ClangTidyContext *Context)
       : ClangTidyCheck(Name, Context) {}
   void registerMatchers(ast_matchers::MatchFinder *Finder) override;
   void check(const ast_matchers::MatchFinder::MatchResult &Result) override;
   void registerPPCallbacks(CompilerInstance &Compiler) override;
 
   static const char DiagWording[];
 };
 
+} // namespace cert
 } // namespace tidy
 } // namespace clang
 
 #endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_SETLONGJMPCHECK_H
-

clang-tidy/cert/SetLongJmpCheck.cpp

 #include "clang/Frontend/CompilerInstance.h"
 #include "clang/Lex/PPCallbacks.h"
 #include "clang/Lex/Preprocessor.h"
 
 using namespace clang::ast_matchers;
 
 namespace clang {
 namespace tidy {
+namespace cert {
 
 const char SetLongJmpCheck::DiagWording[] =
     "do not call %0; consider using exception handling instead";
 
 namespace {
 class SetJmpMacroCallbacks : public PPCallbacks {
   SetLongJmpCheck &Check;
 
Finder->addMatcher(callExpr(callee(functionDecl(anyOf(hasName("setjmp"),
                      this);
 }
 
 void SetLongJmpCheck::check(const MatchFinder::MatchResult &Result) {
   const auto *E = Result.Nodes.getNodeAs<CallExpr>("expr");
   diag(E->getExprLoc(), DiagWording) << cast<NamedDecl>(E->getCalleeDecl());
 }
 
+} // namespace cert
 } // namespace tidy
 } // namespace clang

clang-tidy/cert/StaticObjectExceptionCheck.h

 //===--- StaticObjectExceptionCheck.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_CERT_ERR58_CPP_H
 #define LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_CERT_ERR58_CPP_H
 
 #include "../ClangTidy.h"
 
 namespace clang {
 namespace tidy {
+namespace cert {
 
 /// Checks whether the constructor for a static or thread_local object will
 /// throw.
 ///
 /// For the user-facing documentation see:
 /// http://clang.llvm.org/extra/clang-tidy/checks/cert-err58-cpp.html
 class StaticObjectExceptionCheck : public ClangTidyCheck {
 public:
   StaticObjectExceptionCheck(StringRef Name, ClangTidyContext *Context)
       : ClangTidyCheck(Name, Context) {}
   void registerMatchers(ast_matchers::MatchFinder *Finder) override;
   void check(const ast_matchers::MatchFinder::MatchResult &Result) override;
 };
 
+} // namespace cert
 } // namespace tidy
 } // namespace clang
 
 #endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_CERT_ERR58_CPP_H
-

clang-tidy/cert/StaticObjectExceptionCheck.cpp

 #include "../utils/Matchers.h"
 #include "clang/AST/ASTContext.h"
 #include "clang/ASTMatchers/ASTMatchFinder.h"
 
 using namespace clang::ast_matchers;
 
 namespace clang {
 namespace tidy {
+namespace cert {
 
 void StaticObjectExceptionCheck::registerMatchers(MatchFinder *Finder) {
   if (!getLangOpts().CPlusPlus)
     return;
 
   // Match any static or thread_local variable declaration that is initialized
   // with a constructor that can throw.
   Finder->addMatcher(
void StaticObjectExceptionCheck::check(const MatchFinder::MatchResult &Result) {
   diag(VD->getLocation(),
        "construction of %0 with %select{static|thread_local}1 storage "
        "duration may throw an exception that cannot be caught")
       << VD << (VD->getStorageDuration() == SD_Static ? 0 : 1);
   diag(Ctor->getLocation(), "possibly throwing constructor declared here",
        DiagnosticIDs::Note);
 }
 
+} // namespace cert
 } // namespace tidy
 } // namespace clang
-

clang-tidy/cert/ThrownExceptionTypeCheck.h

 //===--- ThrownExceptionTypeCheck.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_CERT_THROWNEXCEPTIONTYPECHECK_H
 #define LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_CERT_THROWNEXCEPTIONTYPECHECK_H
 
 #include "../ClangTidy.h"
 
 namespace clang {
 namespace tidy {
+namespace cert {
 
 /// Checks whether a thrown object is nothrow copy constructible.
 ///
 /// For the user-facing documentation see:
 /// http://clang.llvm.org/extra/clang-tidy/checks/cert-err60-cpp.html
 class ThrownExceptionTypeCheck : public ClangTidyCheck {
 public:
   ThrownExceptionTypeCheck(StringRef Name, ClangTidyContext *Context)
     : ClangTidyCheck(Name, Context) {}
   void registerMatchers(ast_matchers::MatchFinder *Finder) override;
   void check(const ast_matchers::MatchFinder::MatchResult &Result) override;
 };
 
+} // namespace cert
 } // namespace tidy
 } // namespace clang
 
 #endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_CERT_THROWNEXCEPTIONTYPECHECK_H
-

clang-tidy/cert/ThrownExceptionTypeCheck.cpp

 #include "../utils/Matchers.h"
 #include "clang/AST/ASTContext.h"
 #include "clang/ASTMatchers/ASTMatchFinder.h"
 
 using namespace clang::ast_matchers;
 
 namespace clang {
 namespace tidy {
+namespace cert {
+
 void ThrownExceptionTypeCheck::registerMatchers(MatchFinder *Finder) {
   if (!getLangOpts().CPlusPlus)
     return;
 
   Finder->addMatcher(
       cxxThrowExpr(
           has(cxxConstructExpr(hasDeclaration(cxxConstructorDecl(
               isCopyConstructor(), unless(isNoThrow()))))
           .bind("expr"))),
       this);
 }
 
 void ThrownExceptionTypeCheck::check(const MatchFinder::MatchResult &Result) {
   const auto *E = Result.Nodes.getNodeAs<Expr>("expr");
   diag(E->getExprLoc(),
        "thrown exception type is not nothrow copy constructible");
 }
 
+} // namespace cert
 } // namespace tidy
 } // namespace clang
-

clang-tidy/cert/VariadicFunctionDefCheck.h

 //===--- VariadicFunctionDefCheck.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_CERT_VARIADICFUNCTIONDEF_H
 #define LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_CERT_VARIADICFUNCTIONDEF_H
 
 #include "../ClangTidy.h"
 
 namespace clang {
 namespace tidy {
+namespace cert {
 
 /// Guards against any C-style variadic function definitions (not declarations).
 ///
 /// For the user-facing documentation see:
 /// http://clang.llvm.org/extra/clang-tidy/checks/cert-dcl50-cpp.html
 class VariadicFunctionDefCheck : public ClangTidyCheck {
 public:
   VariadicFunctionDefCheck(StringRef Name, ClangTidyContext *Context)
       : ClangTidyCheck(Name, Context) {}
   void registerMatchers(ast_matchers::MatchFinder *Finder) override;
   void check(const ast_matchers::MatchFinder::MatchResult &Result) override;
 };
 
+} // namespace cert
 } // namespace tidy
 } // namespace clang
 
 #endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_CERT_VARIADICFUNCTIONDEF_H
-

clang-tidy/cert/VariadicFunctionDefCheck.cpp

 #include "VariadicFunctionDefCheck.h"
 #include "clang/AST/ASTContext.h"
 #include "clang/ASTMatchers/ASTMatchFinder.h"
 
 using namespace clang::ast_matchers;
 
 namespace clang {
 namespace tidy {
+namespace cert {
 
 void VariadicFunctionDefCheck::registerMatchers(MatchFinder *Finder) {
   if (!getLangOpts().CPlusPlus)
     return;
 
   // We only care about function *definitions* that are variadic, and do not
   // have extern "C" language linkage.
   Finder->addMatcher(
       functionDecl(isDefinition(), isVariadic(), unless(isExternC()))
           .bind("func"),
       this);
 }
 
 void VariadicFunctionDefCheck::check(const MatchFinder::MatchResult &Result) {
   const auto *FD = Result.Nodes.getNodeAs<FunctionDecl>("func");
 
   diag(FD->getLocation(),
        "do not define a C-style variadic function; consider using a function "
        "parameter pack or currying instead");
 }
 
+} // namespace cert
 } // namespace tidy
 } // namespace clang
-