Make google-build-using-namespace skip std::.*literals

[marejde]

Summary

C++14 added a couple of user-defined literals in the standard library. E.g.
std::chrono_literals and std::literals::chrono_literals . Using them
requires a using directive so do not warn in google-build-using-namespace
if namespace name starts with "std::" and ends with "literals".

[marejde]

test/clang-tidy/google-namespaces.cpp

33

s/Use/use/ . Same below. Fixing.

[marejde]

Fixed wrong capitalization in added CHECK strings.

[alexfh]

clang-tidy/google/UsingNamespaceDirectiveCheck.cpp

43

getQualifiedNameAsString() is pretty expensive, since it allocates a string and reconstructs the qualified name by going up all declaration contexts. Instead, consider checking the names directly, something like this:

const NamespaceDecl *NS = U->getNominatedNamespace();
if (NS->getName().ends_with("literals")) {
  const auto *Parent = dyn_cast_or_null<NamespaceDecl>(NS->getParent());
  if (Parent && (Parent->isStdNamespace() || (Parent->getName() == "literals" && Parent->getParent() && Parent->getParent()->isStdNamespace())))
    return;
}

[marejde]

Removed use of getQualifiedNameAsString().

[marejde]

Removed use of nested namespace definition in test (C++17) and added a couple of more namespaces with "literals" in name that check should warn for.

[alexfh]

LG with one nit. Thank you for addressing this! Do you need me to commit the patch for you?

clang-tidy/google/UsingNamespaceDirectiveCheck.cpp

55

Please make this a static free function instead, since it doesn't need access to the check's members.

[marejde]

Modified isStdLiteralsNamespace() to be a static method.

[marejde]

Do you need me to commit the patch for you?

Yes please. I do not have commit access.

clang-tidy/google/UsingNamespaceDirectiveCheck.cpp

55

Done.

clang-tidy/google/UsingNamespaceDirectiveCheck.h

 //===--- UsingNamespaceDirectiveCheck.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_GOOGLE_USINGNAMESPACEDIRECTIVECHECK_H
 #define LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_GOOGLE_USINGNAMESPACEDIRECTIVECHECK_H
 
 #include "../ClangTidy.h"
+#include "llvm/Support/Regex.h"
 
 namespace clang {
 namespace tidy {
 namespace google {
 namespace build {
 
 /// Finds using namespace directives.
 ///
 /// https://google.github.io/styleguide/cppguide.html#Namespaces
 ///
 /// The check implements the following rule of the Google C++ Style Guide:
 ///
 ///   You may not use a using-directive to make all names from a namespace
 ///   available.
 ///
 ///   \code
 ///     // Forbidden -- This pollutes the namespace.
 ///     using namespace foo;
 ///   \endcode
 ///
 /// Corresponding cpplint.py check name: `build/namespaces`.
 class UsingNamespaceDirectiveCheck : public ClangTidyCheck {
 public:
-  UsingNamespaceDirectiveCheck(StringRef Name, ClangTidyContext *Context)
-      : ClangTidyCheck(Name, Context) {}
+  UsingNamespaceDirectiveCheck(StringRef Name, ClangTidyContext *Context);
+
   void registerMatchers(ast_matchers::MatchFinder *Finder) override;
   void check(const ast_matchers::MatchFinder::MatchResult &Result) override;
+
+private:
+  llvm::Regex StandardLiteralsNamespaceRE;
 };
 
 } // namespace build
 } // namespace google
 } // namespace tidy
 } // namespace clang
 
 #endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_GOOGLE_USINGNAMESPACEDIRECTIVECHECK_H

clang-tidy/google/UsingNamespaceDirectiveCheck.cpp

 
 using namespace clang::ast_matchers;
 
 namespace clang {
 namespace tidy {
 namespace google {
 namespace build {
 
+UsingNamespaceDirectiveCheck::UsingNamespaceDirectiveCheck(
+    StringRef Name, ClangTidyContext *Context)
+    : ClangTidyCheck(Name, Context),
+      StandardLiteralsNamespaceRE("^std::.*literals$") {}
+
 void UsingNamespaceDirectiveCheck::registerMatchers(
     ast_matchers::MatchFinder *Finder) {
   // Only register the matchers for C++; the functionality currently does not
   // provide any benefit to other languages, despite being benign.
   if (getLangOpts().CPlusPlus)
     Finder->addMatcher(usingDirectiveDecl().bind("usingNamespace"), this);
 }
 
 void UsingNamespaceDirectiveCheck::check(
     const MatchFinder::MatchResult &Result) {
   const auto *U = Result.Nodes.getNodeAs<UsingDirectiveDecl>("usingNamespace");
   SourceLocation Loc = U->getLocStart();
   if (U->isImplicit() || !Loc.isValid())
     return;
 
+  if (StandardLiteralsNamespaceRE.match(
+          U->getNominatedNamespace()->getQualifiedNameAsString())) {
+    // Do not warn if name matches std::.*literals. User-defined literals in
+    // standard library can only be used with a using directive.
+    return;
+  }
+
   diag(Loc, "do not use namespace using-directives; "
             "use using-declarations instead");
   // TODO: We could suggest a list of using directives replacing the using
   //       namespace directive.
 }
 
 } // namespace build
 } // namespace google
 } // namespace tidy
 } // namespace clang

test/clang-tidy/google-namespaces.cpp

 // RUN: clang-tidy %s -checks='-*,google-build-namespaces,google-build-using-namespace' -header-filter='.*' -- | FileCheck %s -implicit-check-not="{{warning|error}}:"
 #include "Inputs/google-namespaces.h"
 // CHECK: warning: do not use unnamed namespaces in header files [google-build-namespaces]
 
 using namespace spaaaace;
 // CHECK: :[[@LINE-1]]:1: warning: do not use namespace using-directives; use using-declarations instead [google-build-using-namespace]
 
 using spaaaace::core; // no-warning
+
+namespace std {
+inline namespace literals {
+inline namespace chrono_literals {
+}
+inline namespace complex_literals {
+}
+inline namespace string_literals {
+}
+}
+}
+
+using namespace std::chrono_literals;            // no-warning
+using namespace std::complex_literals;           // no-warning
+using namespace std::literals;                   // no-warning
+using namespace std::literals::chrono_literals;  // no-warning
+using namespace std::literals::complex_literals; // no-warning
+using namespace std::literals::string_literals;  // no-warning
+using namespace std::string_literals;            // no-warning
+
+namespace literals {}
+namespace foo::literals {}
+
+using namespace literals;
+// CHECK: :[[@LINE-1]]:1: warning: do not use namespace using-directives; Use using-declarations instead [google-build-using-namespace]
+
+using namespace foo::literals;
+// CHECK: :[[@LINE-1]]:1: warning: do not use namespace using-directives; Use using-declarations instead [google-build-using-namespace]