Merge pull request #55 from rianquinn/bsl-tidy

Fix bugs and add some additional checks

Author: rianquinn

clang-tools-extra/clang-tidy/bsl/AssignOpDeclRefQualifierCheck.cpp

@@ -17,20 +17,23 @@ namespace tidy {
 namespace bsl {
 
 void AssignOpDeclRefQualifierCheck::registerMatchers(MatchFinder *Finder) {
-  Finder->addMatcher(cxxMethodDecl(hasAnyOverloadedOperatorName(
-                                       "=", "+=", "-=", "*=", "/=", "%=", "^=",
-                                       "&=", "|=", ">>=", "<<="))
-                         .bind("assign"),
-                     this);
+  Finder->addMatcher(
+    cxxMethodDecl(
+      hasAnyOverloadedOperatorName("=", "+=", "-=", "*=", "/=", "%=", "^=", "&=", "|=", ">>=", "<<="),
+      unless(
+        isImplicit()
+      )
+    ).bind("assign"),
+    this
+  );
 }
 
 void AssignOpDeclRefQualifierCheck::check(
     const MatchFinder::MatchResult &Result) {
   const auto *MatchedDecl = Result.Nodes.getNodeAs<CXXMethodDecl>("assign");
-  if (MatchedDecl->getRefQualifier() == RQ_LValue)
-    return;
-  diag(MatchedDecl->getLocation(),
-       "assignment operators should be declared with the ref-qualifier &");
+  if (MatchedDecl->getRefQualifier() == RQ_None)
+    diag(MatchedDecl->getLocation(),
+        "assignment operators should be declared with the ref-qualifier &");
 }
 
 } // namespace bsl

clang-tools-extra/clang-tidy/bsl/AutoTypeUsageCheck.cpp

@@ -27,7 +27,7 @@ void AutoTypeUsageCheck::registerMatchers(MatchFinder *Finder) {
       valueDecl(hasType(autoType()), hasDescendant(cxxStdInitializerListExpr()))
           .bind("list"),
       this);
-  
+
   Finder->addMatcher(valueDecl(hasType(autoType()), isFundamentalType(),
                                unless(has(callExpr())))
                          .bind("decl"),
@@ -52,7 +52,7 @@ void AutoTypeUsageCheck::check(const MatchFinder::MatchResult &Result) {
          "auto cannot be used to declare variable of fundamental type");
 
   const auto *MatchedTempDecl = Result.Nodes.getNodeAs<FunctionDecl>("trail");
-  if (MatchedTempDecl) {
+  if (MatchedTempDecl && !MatchedTempDecl->getReturnType()->isVoidType()) {
     if (isa<CXXMethodDecl>(MatchedTempDecl)) {
       if (!cast<CXXMethodDecl>(MatchedTempDecl)->isLambdaStaticInvoker())
         diag(MatchedTempDecl->getLocation(),

clang-tools-extra/clang-tidy/bsl/BslTidyModule.cpp

@@ -22,7 +22,9 @@
 #include "ConstObjStdMoveCheck.h"
 #include "DeclForbiddenCheck.h"
 #include "DestructorAccessSpecifierCheck.h"
+#include "DocumentationCheck.h"
 #include "ElseRequiredAfterIfCheck.h"
+#include "EmptyIfElseCheck.h"
 #include "EnumExplicitCheck.h"
 #include "EnumInitCheck.h"
 #include "EnumScopedCheck.h"
@@ -32,17 +34,21 @@
 #include "FunctionNameUseCheck.h"
 #include "FunctionNoexceptCheck.h"
 #include "IdentifierTypographicallyUnambiguousCheck.h"
+#include "ImplicitConversionsForbiddenCheck.h"
 #include "LambdaImplicitCaptureCheck.h"
 #include "LambdaParamListCheck.h"
 #include "LiteralsAsciiOnlyCheck.h"
 #include "LiteralsDigitSeparatorCheck.h"
 #include "LiteralsNoOctalCheck.h"
 #include "LiteralsUnsignedSuffixCheck.h"
 #include "LiteralsUserDefinedCheck.h"
+#include "NameCaseCheck.h"
+#include "NamePrefixesCheck.h"
 #include "NamespaceGlobalCheck.h"
 #include "NodiscardCheck.h"
 #include "NonPodClassdefCheck.h"
 #include "NonPodStaticCheck.h"
+#include "NonSafeIntegralTypesAreForbiddenCheck.h"
 #include "OpBitwiseOperandsCheck.h"
 #include "OpConditionalSubexprCheck.h"
 #include "OpEqualityVirtMemfnNullptrCheck.h"
@@ -62,8 +68,10 @@
 #include "TypesFixedWidthIntsCheck.h"
 #include "TypesNoWideCharCheck.h"
 #include "UnusedReturnValueCheck.h"
+#include "UserDefinedTypeNamesMatchHeaderNameCheck.h"
 #include "UsingDeclScopeCheck.h"
 #include "UsingIdentUniqueNamespaceCheck.h"
+#include "UsingNamespaceForbiddenCheck.h"
 #include "VarBracedInitCheck.h"
 
 namespace clang {
@@ -99,8 +107,12 @@ class BslModule : public ClangTidyModule {
         "bsl-decl-forbidden");
     CheckFactories.registerCheck<DestructorAccessSpecifierCheck>(
         "bsl-destructor-access-specifier");
+    CheckFactories.registerCheck<DocumentationCheck>(
+        "bsl-documentation");
     CheckFactories.registerCheck<ElseRequiredAfterIfCheck>(
         "bsl-else-required-after-if");
+    CheckFactories.registerCheck<EmptyIfElseCheck>(
+        "bsl-empty-if-else");
     CheckFactories.registerCheck<EnumExplicitCheck>(
         "bsl-enum-explicit");
     CheckFactories.registerCheck<EnumInitCheck>(
@@ -119,6 +131,8 @@ class BslModule : public ClangTidyModule {
         "bsl-function-noexcept");
     CheckFactories.registerCheck<IdentifierTypographicallyUnambiguousCheck>(
         "bsl-identifier-typographically-unambiguous");    
+    CheckFactories.registerCheck<ImplicitConversionsForbiddenCheck>(
+        "bsl-implicit-conversions-forbidden");
     CheckFactories.registerCheck<LambdaImplicitCaptureCheck>(
         "bsl-lambda-implicit-capture");
     CheckFactories.registerCheck<LambdaParamListCheck>(
@@ -127,6 +141,10 @@ class BslModule : public ClangTidyModule {
         "bsl-literals-digit-separator");
     CheckFactories.registerCheck<LiteralsUserDefinedCheck>(
         "bsl-literals-user-defined");
+    CheckFactories.registerCheck<NameCaseCheck>(
+        "bsl-name-case");
+    CheckFactories.registerCheck<NamePrefixesCheck>(
+        "bsl-name-prefixes");
     CheckFactories.registerCheck<NamespaceGlobalCheck>(
         "bsl-namespace-global");
     CheckFactories.registerCheck<NodiscardCheck>(
@@ -135,6 +153,8 @@ class BslModule : public ClangTidyModule {
         "bsl-non-pod-classdef");
     CheckFactories.registerCheck<NonPodStaticCheck>(
         "bsl-non-pod-static");
+    CheckFactories.registerCheck<NonSafeIntegralTypesAreForbiddenCheck>(
+        "bsl-non-safe-integral-types-are-forbidden");
     CheckFactories.registerCheck<OpBitwiseOperandsCheck>(
         "bsl-op-bitwise-operands");
     CheckFactories.registerCheck<OpConditionalSubexprCheck>(
@@ -179,10 +199,14 @@ class BslModule : public ClangTidyModule {
         "bsl-types-no-wide-char");
     CheckFactories.registerCheck<UnusedReturnValueCheck>(
         "bsl-unused-return-value");
+    CheckFactories.registerCheck<UserDefinedTypeNamesMatchHeaderNameCheck>(
+        "bsl-user-defined-type-names-match-header-name");
     CheckFactories.registerCheck<UsingDeclScopeCheck>(
         "bsl-using-decl-scope");
     CheckFactories.registerCheck<UsingIdentUniqueNamespaceCheck>(
         "bsl-using-ident-unique-namespace");
+    CheckFactories.registerCheck<UsingNamespaceForbiddenCheck>(
+        "bsl-using-namespace-forbidden");
     CheckFactories.registerCheck<VarBracedInitCheck>(
         "bsl-var-braced-init");
   }

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

@@ -16,7 +16,9 @@ add_clang_library(clangTidyBslModule
   ConstObjStdMoveCheck.cpp
   DeclForbiddenCheck.cpp
   DestructorAccessSpecifierCheck.cpp
+  DocumentationCheck.cpp
   ElseRequiredAfterIfCheck.cpp
+  EmptyIfElseCheck.cpp
   EnumExplicitCheck.cpp
   EnumInitCheck.cpp
   EnumScopedCheck.cpp
@@ -26,17 +28,21 @@ add_clang_library(clangTidyBslModule
   FunctionNameUseCheck.cpp
   FunctionNoexceptCheck.cpp
   IdentifierTypographicallyUnambiguousCheck.cpp
+  ImplicitConversionsForbiddenCheck.cpp
   LambdaImplicitCaptureCheck.cpp
   LambdaParamListCheck.cpp
   LiteralsAsciiOnlyCheck.cpp
   LiteralsDigitSeparatorCheck.cpp
   LiteralsNoOctalCheck.cpp
   LiteralsUnsignedSuffixCheck.cpp
   LiteralsUserDefinedCheck.cpp
+  NameCaseCheck.cpp
+  NamePrefixesCheck.cpp
   NamespaceGlobalCheck.cpp
   NodiscardCheck.cpp
   NonPodClassdefCheck.cpp
   NonPodStaticCheck.cpp
+  NonSafeIntegralTypesAreForbiddenCheck.cpp
   OpBitwiseOperandsCheck.cpp
   OpConditionalSubexprCheck.cpp
   OpEqualityVirtMemfnNullptrCheck.cpp
@@ -56,8 +62,10 @@ add_clang_library(clangTidyBslModule
   TypesFixedWidthIntsCheck.cpp
   TypesNoWideCharCheck.cpp
   UnusedReturnValueCheck.cpp
+  UserDefinedTypeNamesMatchHeaderNameCheck.cpp
   UsingDeclScopeCheck.cpp
   UsingIdentUniqueNamespaceCheck.cpp
+  UsingNamespaceForbiddenCheck.cpp
   VarBracedInitCheck.cpp
 
   LINK_LIBS

clang-tools-extra/clang-tidy/bsl/DestructorAccessSpecifierCheck.cpp

@@ -16,6 +16,10 @@ namespace clang {
 namespace tidy {
 namespace bsl {
 
+AST_MATCHER(CXXDestructorDecl, isUnion) {
+  return Node.getParent()->isUnion();
+}
+
 AST_MATCHER(CXXDestructorDecl, isPublicVirtual) {
   return Node.getAccess() == AS_public && Node.isVirtual();
 }
@@ -25,10 +29,17 @@ AST_MATCHER(CXXDestructorDecl, isProtectedNonVirtual) {
 }
 
 void DestructorAccessSpecifierCheck::registerMatchers(MatchFinder *Finder) {
-  Finder->addMatcher(cxxDestructorDecl(unless(anyOf(isPublicVirtual(),
-                                                    isProtectedNonVirtual())))
-                         .bind("destructor"),
-                     this);
+  Finder->addMatcher(
+    cxxDestructorDecl(
+      unless(
+        anyOf(
+          isUnion(),
+          isPublicVirtual(),
+          isProtectedNonVirtual()
+        )
+      )
+    ).bind("destructor"),
+    this);
 }
 
 void DestructorAccessSpecifierCheck::check(