[clang-tidy] check for using declaration qualification

[Naysh]

Summary

This patch adds a "Qualified Aliases" check, based off the guidelines in https://abseil.io/tips/119, to the abseil module.

The check flags any using declarations which are not fully qualified.

[Eugene.Zelenko]

clang-tidy/abseil/AnonymousEnclosedAliasesCheck.cpp

31

Please remove unnecessary empty line.

33

Please remove unnecessary empty line.

34

const auto *

clang-tidy/abseil/QualifiedAliasesCheck.cpp

13

Please remove unnecessary empty line.

clang-tidy/abseil/SafelyScopedCheck.cpp

27

Please run Clang-format over patch.

docs/ReleaseNotes.rst

73

Please enclose using in ``. Same in other places, including documentation.

docs/clang-tidy/checks/abseil-alias-free-headers.rst

10

Are there guidelines?

docs/clang-tidy/checks/abseil-qualified-aliases.rst

24

Please remove unnecessary empty line.

docs/clang-tidy/checks/abseil-safely-scoped.rst

28

Please remove unnecessary empty line.

test/clang-tidy/abseil-qualified-aliases.cpp

27

Please remove unnecessary empty line.

test/clang-tidy/abseil-safely-scoped.cpp

27

Please remove unnecessary empty line.

[Eugene.Zelenko]

docs/clang-tidy/checks/abseil-anonymous-enclosed-aliases.rst

20

Are there guidelines?

docs/clang-tidy/checks/abseil-qualified-aliases.rst

22

Please make text consistent across all these checks.

[alexfh]

Could you send each check in a separate patch, please? This makes the review much more straightforward and I'm sure it will be faster too.

[alexfh]

clang-tidy/abseil/AbseilTidyModule.cpp

25

Please upload the patch with full context. See https://llvm.org/docs/Phabricator.html

[Naysh]

To respond to alexfh's request to split this submission into four separate patches (corresponding to each of the introduced checks), I've updated the patch to only include the "Qualified Aliases" check.

I'll add the other checks as separate patches.

[aaron.ballman]

clang-tidy/abseil/QualifiedAliasesCheck.cpp

30

Drop the top-level const qualifier (here and elsewhere).

35

No need for the assignment.

40

This is missing a check for whether the referenced name is within the current namespace.

44–45

Do not put HTML links into the diagnostic -- the wording should stand on its own. I would probably phrase it "using declaration should use a fully qualified name" or something along those lines.

clang-tidy/abseil/QualifiedAliasesCheck.h

20

This should be fixed.

test/clang-tidy/abseil-qualified-aliases.cpp

23–24

I don't think this should warn, per the tip.

.gitignore

 # vim swap files
 .*.swp
 .sw?
+# Others
+.DS_Store
 
 #==============================================================================#
 # Explicit files to ignore (only matches one).

clang-tidy/abseil/AbseilTidyModule.cpp

 #include "../ClangTidy.h"
 #include "../ClangTidyModule.h"
 #include "../ClangTidyModuleRegistry.h"
+#include "AliasFreeHeadersCheck.h"
+#include "AnonymousEnclosedAliasesCheck.h"
 #include "DurationDivisionCheck.h"
 #include "DurationFactoryFloatCheck.h"
 #include "FasterStrsplitDelimiterCheck.h"
 #include "NoInternalDependenciesCheck.h"
 #include "NoNamespaceCheck.h"
+#include "QualifiedAliasesCheck.h"
 #include "RedundantStrcatCallsCheck.h"
+#include "SafelyScopedCheck.h"
 #include "StringFindStartswithCheck.h"
 #include "StrCatAppendCheck.h"
 

 class AbseilModule : public ClangTidyModule {
 public:
   void addCheckFactories(ClangTidyCheckFactories &CheckFactories) override {
+    CheckFactories.registerCheck<AliasFreeHeadersCheck>(
+        "abseil-alias-free-headers");
+    CheckFactories.registerCheck<AnonymousEnclosedAliasesCheck>(
+        "abseil-anonymous-enclosed-aliases");
     CheckFactories.registerCheck<DurationDivisionCheck>(
         "abseil-duration-division");
     CheckFactories.registerCheck<DurationFactoryFloatCheck>(

     CheckFactories.registerCheck<NoInternalDependenciesCheck>(
         "abseil-no-internal-dependencies");
     CheckFactories.registerCheck<NoNamespaceCheck>("abseil-no-namespace");
+    CheckFactories.registerCheck<QualifiedAliasesCheck>(
+        "abseil-qualified-aliases");
     CheckFactories.registerCheck<RedundantStrcatCallsCheck>(
         "abseil-redundant-strcat-calls");
+    CheckFactories.registerCheck<SafelyScopedCheck>(
+        "abseil-safely-scoped");
     CheckFactories.registerCheck<StrCatAppendCheck>(
         "abseil-str-cat-append");
     CheckFactories.registerCheck<StringFindStartswithCheck>(

clang-tidy/abseil/AliasFreeHeadersCheck.h

+//===--- AliasFreeHeadersCheck.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_ABSEIL_ALIASFREEHEADERSCHECK_H
+#define LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_ABSEIL_ALIASFREEHEADERSCHECK_H
+
+#include "../ClangTidy.h"
+
+namespace clang {
+namespace tidy {
+namespace abseil {
+
+/// FIXME: Write a short description.
+///
+/// For the user-facing documentation see:
+/// http://clang.llvm.org/extra/clang-tidy/checks/abseil-alias-free-headers.html
+class AliasFreeHeadersCheck : public ClangTidyCheck {
+public:
+  AliasFreeHeadersCheck(StringRef Name, ClangTidyContext *Context)
+      : ClangTidyCheck(Name, Context) {}
+  void registerMatchers(ast_matchers::MatchFinder *Finder) override;
+  void check(const ast_matchers::MatchFinder::MatchResult &Result) override;
+};
+
+} // namespace abseil
+} // namespace tidy
+} // namespace clang
+
+#endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_ABSEIL_ALIASFREEHEADERSCHECK_H

clang-tidy/abseil/AliasFreeHeadersCheck.cpp

+//===--- AliasFreeHeadersCheck.cpp - clang-tidy ---------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+#include "AliasFreeHeadersCheck.h"
+#include "clang/AST/ASTContext.h"
+#include "clang/ASTMatchers/ASTMatchFinder.h"
+
+using namespace clang::ast_matchers;
+
+namespace clang {
+namespace tidy {
+namespace abseil {
+
+void AliasFreeHeadersCheck::registerMatchers(MatchFinder *Finder) {
+  // Match using declarations in header files.
+  Finder->addMatcher(usingDecl(isExpansionInFileMatching(".*\\.h.*")).bind("x"), 
+    this);
+}
+
+void AliasFreeHeadersCheck::check(const MatchFinder::MatchResult &Result) {
+  const auto *MatchedDecl = Result.Nodes.getNodeAs<UsingDecl>("x");
+  diag(MatchedDecl->getLocation(), "convenience aliases in header files are "
+"dangerous: see http://google.github.io/styleguide/cppguide.html#Aliases");
+}
+
+} // namespace abseil
+} // namespace tidy
+} // namespace clang

clang-tidy/abseil/AnonymousEnclosedAliasesCheck.h

+//===--- AnonymousEnclosedAliasesCheck.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_ABSEIL_ANONYMOUSENCLOSEDALIASESCHECK_H
+#define LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_ABSEIL_ANONYMOUSENCLOSEDALIASESCHECK_H
+
+#include "../ClangTidy.h"
+#include <vector>
+
+namespace clang {
+namespace tidy {
+namespace abseil {
+
+/// Detecting incorrect practice of putting using declarations outside an
+/// anonymous namespace when there exists one.
+/// For the user-facing documentation see:
+/// http://clang.llvm.org/extra/clang-tidy/checks/
+/// abseil-anonymous-enclosed-aliases.html
+class AnonymousEnclosedAliasesCheck : public ClangTidyCheck {
+public:
+  AnonymousEnclosedAliasesCheck(StringRef Name, ClangTidyContext *Context)
+      : ClangTidyCheck(Name, Context) {}
+  void registerMatchers(ast_matchers::MatchFinder *Finder) override;
+  void check(const ast_matchers::MatchFinder::MatchResult &Result) override;
+private:
+  const NamespaceDecl* AnonymousNamespaceDecl;
+  std::vector<const UsingDecl*> MatchedUsingDecls;
+};
+
+} // namespace abseil
+} // namespace tidy
+} // namespace clang
+
+#endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_ABSEIL_ANONYMOUSENCLOSEDALIASESCHECK_H

clang-tidy/abseil/AnonymousEnclosedAliasesCheck.cpp

+//===--- AnonymousEnclosedAliasesCheck.cpp - clang-tidy -------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+#include "AnonymousEnclosedAliasesCheck.h"
+#include "clang/AST/ASTContext.h"
+#include "clang/ASTMatchers/ASTMatchFinder.h"
+
+using namespace clang::ast_matchers;
+
+namespace clang {
+namespace tidy {
+namespace abseil {
+
+void AnonymousEnclosedAliasesCheck::registerMatchers(MatchFinder *Finder) {
+  // We try to match two nodes: 
+  // 1. anonymous namespace declarations,
+  // 2. using declarations that are not inside an anonymous declaration
+  Finder->addMatcher(
+    namespaceDecl(isAnonymous()).bind("anonymous_namespace"), this);
+  Finder->addMatcher(
+    usingDecl(unless(hasAncestor(
+      namespaceDecl(isAnonymous())))).bind("using_decl"), this);
+}
+
+
+void AnonymousEnclosedAliasesCheck::check(const MatchFinder::MatchResult &Result) {
+  
+  const UsingDecl *MatchedUsingDecl = 
+    Result.Nodes.getNodeAs<UsingDecl>("using_decl");
+  // If a potential using declaration is matched,
+  if (MatchedUsingDecl) {
+    // and if an anonymous namespace declaration has already been found,
+    // the matched using declaration is a target, and we print out 
+    // the diagnostics for it. Otherwise, we add the using declaration
+    // to the vector containing all candidate using declarations.
+    if (AnonymousNamespaceDecl) {
+      diag(MatchedUsingDecl->getLocation(), 
+        "UsingDecl %0 should be in the anonymous namespace") 
+        << MatchedUsingDecl;
+    } else {
+      MatchedUsingDecls.push_back(MatchedUsingDecl);
+    }
+    return;
+  }
+  // Otherwise, an anonymous namespace declaration is matched. In this case, 
+  // all the previously matched namespace declarations in the vector 
+  // CurrentUsingDecl are our targets, and we print out the 
+  // diagnostics for all of them.
+  AnonymousNamespaceDecl = 
+    Result.Nodes.getNodeAs<NamespaceDecl>("anonymous_namespace");
+  for (const UsingDecl* CurrentUsingDecl: MatchedUsingDecls) {
+    diag(CurrentUsingDecl->getLocation(), 
+      "UsingDecl %0 should be in the anonymous namespace. See: "
+      "https://abseil.io/tips/119")
+      << CurrentUsingDecl;
+  }
+}
+
+} // namespace abseil
+} // namespace tidy
+} // namespace clang

clang-tidy/abseil/CMakeLists.txt

 
 add_clang_library(clangTidyAbseilModule
   AbseilTidyModule.cpp
+  AliasFreeHeadersCheck.cpp
+  AnonymousEnclosedAliasesCheck.cpp
   DurationDivisionCheck.cpp
   DurationFactoryFloatCheck.cpp
   FasterStrsplitDelimiterCheck.cpp
   NoInternalDependenciesCheck.cpp
   NoNamespaceCheck.cpp
+  QualifiedAliasesCheck.cpp
   RedundantStrcatCallsCheck.cpp
+  SafelyScopedCheck.cpp
   StrCatAppendCheck.cpp
   StringFindStartswithCheck.cpp
 

clang-tidy/abseil/QualifiedAliasesCheck.h

+//===--- QualifiedAliasesCheck.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_ABSEIL_QUALIFIEDALIASESCHECK_H
+#define LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_ABSEIL_QUALIFIEDALIASESCHECK_H
+
+#include "../ClangTidy.h"
+
+namespace clang {
+namespace tidy {
+namespace abseil {
+
+/// FIXME: Write a short description.
+///
+/// For the user-facing documentation see:
+/// http://clang.llvm.org/extra/clang-tidy/checks/abseil-qualified-aliases.html
+class QualifiedAliasesCheck : public ClangTidyCheck {
+public:
+  QualifiedAliasesCheck(StringRef Name, ClangTidyContext *Context)
+      : ClangTidyCheck(Name, Context) {}
+  void registerMatchers(ast_matchers::MatchFinder *Finder) override;
+  void check(const ast_matchers::MatchFinder::MatchResult &Result) override;
+};
+
+} // namespace abseil
+} // namespace tidy
+} // namespace clang
+
+#endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_ABSEIL_QUALIFIEDALIASESCHECK_H

clang-tidy/abseil/QualifiedAliasesCheck.cpp

+//===--- QualifiedAliasesCheck.cpp - clang-tidy ---------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+#include "QualifiedAliasesCheck.h"
+#include "clang/AST/ASTContext.h"
+#include "clang/ASTMatchers/ASTMatchFinder.h"
+
+#include <string>
+
+using namespace clang::ast_matchers;
+
+namespace clang {
+namespace tidy {
+namespace abseil {
+
+void QualifiedAliasesCheck::registerMatchers(MatchFinder *Finder) {
+  // Looks for all using declarations.
+  Finder->addMatcher(usingDecl().bind("x"), this);
+}
+
+void QualifiedAliasesCheck::check(const MatchFinder::MatchResult &Result) {
+  const auto *MatchedDecl = Result.Nodes.getNodeAs<UsingDecl>("x");
+
+  // Finds the nested-name-specifier location.
+  const NestedNameSpecifierLoc QualifiedLoc = MatchedDecl->getQualifierLoc();
+  const SourceLocation FrontLoc = QualifiedLoc.getBeginLoc();
+
+  // Ignores the using declaration if its fully qualified.
+  const SourceManager *SM = Result.SourceManager;
+  CharSourceRange FrontRange = CharSourceRange();
+  FrontRange.setBegin(FrontLoc);
+  FrontRange.setEnd(FrontLoc.getLocWithOffset(2));
+  llvm::StringRef Beg = Lexer::getSourceText(FrontRange, *SM, LangOptions());
+
+  if (Beg.startswith("::"))
+    return;
+ 
+  diag(FrontLoc, "using declaration is not fully qualified: see "
+  "https://abseil.io/tips/119");
+}
+
+} // namespace abseil
+} // namespace tidy
+} // namespace clang

clang-tidy/abseil/SafelyScopedCheck.h

+//===--- SafelyScopedCheck.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_ABSEIL_SAFELYSCOPEDCHECK_H
+#define LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_ABSEIL_SAFELYSCOPEDCHECK_H
+
+#include "../ClangTidy.h"
+
+namespace clang {
+namespace tidy {
+namespace abseil {
+
+/// Detecting using declarations not in a namespace declaration or not in 
+/// the innermost layer of namespace declarations.
+///
+/// For the user-facing documentation see:
+/// http://clang.llvm.org/extra/clang-tidy/checks/abseil-safely-scoped.html
+class SafelyScopedCheck : public ClangTidyCheck {
+public:
+  SafelyScopedCheck(StringRef Name, ClangTidyContext *Context)
+      : ClangTidyCheck(Name, Context) {}
+  void registerMatchers(ast_matchers::MatchFinder *Finder) override;
+  void check(const ast_matchers::MatchFinder::MatchResult &Result) override;
+};
+
+} // namespace abseil
+} // namespace tidy
+} // namespace clang
+
+#endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_ABSEIL_SAFELYSCOPEDCHECK_H

clang-tidy/abseil/SafelyScopedCheck.cpp

+//===--- SafelyScopedCheck.cpp - clang-tidy -------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+#include "SafelyScopedCheck.h"
+#include "clang/AST/ASTContext.h"
+#include "clang/ASTMatchers/ASTMatchFinder.h"
+
+using namespace clang::ast_matchers;
+
+namespace clang {
+namespace tidy {
+namespace abseil {
+
+void SafelyScopedCheck::registerMatchers(MatchFinder *Finder) {
+  // The target using declaration is either:
+  // 1. not in any namespace declaration, or
+  // 2. in some namespace declaration but not in the innermost layer
+  Finder->addMatcher(usingDecl(eachOf( 
+    usingDecl(unless(hasParent(namespaceDecl()))),
+    usingDecl(hasParent(namespaceDecl(forEach(namespaceDecl())))) )
+    ).bind("use"), this);
+}
+
+void SafelyScopedCheck::check(const MatchFinder::MatchResult &Result) {
+  const auto *MatchedDecl = Result.Nodes.getNodeAs<UsingDecl>("use");
+  diag(MatchedDecl->getLocation(), "UsingDecl %0 should be in the innermost "
+    "scope. See: https://abseil.io/tips/119")
+      << MatchedDecl;
+}
+
+} // namespace abseil
+} // namespace tidy
+} // namespace clang

docs/ReleaseNotes.rst

 Improvements to clang-tidy
 --------------------------
 
+- New :doc:`abseil-alias-free-headers
+  <clang-tidy/checks/abseil-alias-free-headers>` check.
+
+  Flags using declarations in header files, and suggests that 
+  these aliases be removed.
+
+- New :doc:`abseil-anonymous-enclosed-aliases
+  <clang-tidy/checks/abseil-anonymous-enclosed-aliases>` check.
+
+  Finds using declarations outside of anonymous namespaces, and 
+  suggests those declarations be moved to that namespace.
+
 - New :doc:`abseil-duration-division
   <clang-tidy/checks/abseil-duration-division>` check.
 

   Ensures code does not open ``namespace absl`` as that violates Abseil's
   compatibility guidelines.
 
+- New :doc:`abseil-qualified-aliases
+  <clang-tidy/checks/abseil-qualified-aliases>` check.
+
+  Detects using declarations that are not fully qualified, and suggests 
+  those declarations be fully qualified.
+
 - New :doc:`abseil-redundant-strcat-calls
   <clang-tidy/checks/abseil-redundant-strcat-calls>` check.
 
   Suggests removal of unnecessary calls to ``absl::StrCat`` when the result is
   being passed to another ``absl::StrCat`` or ``absl::StrAppend``.
 
+- New :doc:`abseil-safely-scoped
+  <clang-tidy/checks/abseil-safely-scoped>` check.
+
+  Flags using declarations that are not contained in an innermost 
+  namespace, and suggests these declarations be moved elsewhere.
+
 - New :doc:`abseil-str-cat-append
   <clang-tidy/checks/abseil-str-cat-append>` check.
 

docs/clang-tidy/checks/abseil-alias-free-headers.rst

+.. title:: clang-tidy - abseil-alias-free-headers
+
+abseil-alias-free-headers
+=========================
+
+Flags using declarations in header files, and suggests that these aliases be removed.
+
+A using declaration placed in a header file forces users of that header file
+accept the specified alias. This is bad practice, which is why the check suggests
+such declarations be removed. 

docs/clang-tidy/checks/abseil-anonymous-enclosed-aliases.rst

+.. title:: clang-tidy - abseil-anonymous-enclosed-aliases
+
+abseil-anonymous-enclosed-aliases
+=================================
+
+Finds using declarations outside of anonymous namespaces, and
+suggests those declarations be moved to that namespace.
+
+Example:
+.. code-block:: c++
+
+  namespace foo {
+  
+  using something; // should be inside the anonymous namespace below
+
+  namespace {
+
+  } // anonymous namespace
+
+  } // foo

docs/clang-tidy/checks/abseil-qualified-aliases.rst

+.. title:: clang-tidy - abseil-qualified-aliases
+
+abseil-qualified-aliases
+========================
+
+Detects using declarations that are not fully qualified, and suggests 
+those declarations be fully qualified. 
+
+Example:
+.. code-block:: c++
+
+  namespace foo {
+    void f();
+    void correct();
+  }
+  
+  namespace bar {
+    using foo::f; // The check produces a warning here. 
+    using ::foo::correct; // The check sees no issue here.
+  }
+
+See https://abseil.io/tips/119 for an in depth justification for this
+check. 
+ 

docs/clang-tidy/checks/abseil-safely-scoped.rst

+.. title:: clang-tidy - abseil-safely-scoped
+
+abseil-safely-scoped
+====================
+
+Flags using declarations that are not contained in an innermost
+namespace, and suggests these declarations be moved elsewhere.
+
+Example:
+
+.. code-block:: c++
+
+  using something; // should be inside the innermost namespace bar below
+
+  namespace foo {
+  namespace bar {
+  
+  } // bar
+
+  using something_else; // shoulw be inside the innermost namespace bar above
+
+  } // foo
+
+Placing convenience aliases in upper level namespaces can lead to ambiguity in 
+which name the compiler should use. 
+
+See https://abseil.io/tips/119 for more explanation. 
+

docs/clang-tidy/checks/list.rst

 =================
 
 .. toctree::
+   abseil-alias-free-headers
+   abseil-anonymous-enclosed-aliases
    abseil-duration-division
    abseil-duration-factory-float
    abseil-faster-strsplit-delimiter
    abseil-no-internal-dependencies
    abseil-no-namespace
+   abseil-qualified-aliases
    abseil-redundant-strcat-calls
-   abseil-string-find-startswith
+   abseil-safely-scoped
    abseil-str-cat-append
+   abseil-string-find-startswith
    android-cloexec-accept
    android-cloexec-accept4
    android-cloexec-creat

    hicpp-special-member-functions (redirects to cppcoreguidelines-special-member-functions) <hicpp-special-member-functions>
    hicpp-static-assert (redirects to misc-static-assert) <hicpp-static-assert>
    hicpp-undelegated-constructor (redirects to bugprone-undelegated-constructor) <hicpp-undelegated-constructor>
+   hicpp-uppercase-literal-suffix (redirects to readability-uppercase-literal-suffix) <hicpp-uppercase-literal-suffix>
    hicpp-use-auto (redirects to modernize-use-auto) <hicpp-use-auto>
    hicpp-use-emplace (redirects to modernize-use-emplace) <hicpp-use-emplace>
    hicpp-use-equals-default (redirects to modernize-use-equals-default) <hicpp-use-equals-default>

    hicpp-use-nullptr (redirects to modernize-use-nullptr) <hicpp-use-nullptr>
    hicpp-use-override (redirects to modernize-use-override) <hicpp-use-override>
    hicpp-vararg (redirects to cppcoreguidelines-pro-type-vararg) <hicpp-vararg>
-   hicpp-uppercase-literal-suffix (redirects to readability-uppercase-literal-suffix) <hicpp-uppercase-literal-suffix>
    llvm-header-guard
    llvm-include-order
    llvm-namespace-comment

test/clang-tidy/abseil-alias-free-headers.hpp

+// RUN: %check_clang_tidy %s abseil-alias-free-headers %t
+  
+namespace foo {
+  void f();
+}
+
+using foo::f;
+// CHECK-MESSAGES: :[[@LINE-1]]:12: warning: convenience aliases in header files are dangerous: see http://google.github.io/styleguide/cppguide.html#Aliases [abseil-alias-free-headers]
+
+void other_function();

test/clang-tidy/abseil-anonymous-enclosed-aliases.cpp

+// RUN: %check_clang_tidy %s abseil-anonymous-enclosed-aliases %t
+namespace bar {
+
+class something {
+
+};
+}
+
+namespace foo {
+
+using bar::something;
+
+namespace {
+
+}  // anonymous namespace
+}  // namespace foo
+// CHECK-MESSAGES: :[[@LINE-6]]:12: warning: UsingDecl 'something' should be in the anonymous namespace. See: https://abseil.io/tips/119 [abseil-anonymous-enclosed-aliases]
+
+
+namespace foo {
+
+namespace {
+
+using ::bar::something;
+
+}  // anonymous namespace
+}  // namespace foo

test/clang-tidy/abseil-qualified-aliases.cpp

+// RUN: %check_clang_tidy %s abseil-qualified-aliases %t
+
+namespace foo {
+  void f();
+  void correct();
+}
+
+namespace bar {
+  using foo::f;
+// CHECK-MESSAGES: :[[@LINE-1]]:9: warning: using declaration is not fully qualified: see https://abseil.io/tips/119 [abseil-qualified-aliases]
+  using ::foo::correct;
+}
+
+namespace outermost {
+  namespace middle {
+    namespace innermost {
+
+      enum Color {Red, Blue, Yellow};
+
+    } // namespace innermost
+
+    using innermost::Color;
+// CHECK-MESSAGES: :[[@LINE-1]]:11: warning: using declaration is not fully qualified: see https://abseil.io/tips/119 [abseil-qualified-aliases]
+
+  } // namespace middle
+} // namespace example
+

test/clang-tidy/abseil-safely-scoped.cpp

+// RUN: %check_clang_tidy %s abseil-safely-scoped %t
+namespace bar {
+
+class something {
+
+};
+}
+
+namespace foo {
+
+using bar::something;
+
+namespace {
+
+}  // anonymous namespace
+}  // namespace foo
+// CHECK-MESSAGES: :[[@LINE-6]]:12: warning: UsingDecl 'something' should be in the innermost scope. See: https://abseil.io/tips/119 [abseil-safely-scoped]
+
+namespace foo {
+
+namespace {
+
+using ::bar::something;
+
+}  // anonymous namespace
+}  // namespace foo
+

test/clang-tidy/temporaries.cpp

-// REQUIRES: static-analyzer
-// RUN: clang-tidy -checks='-*,clang-analyzer-core.NullDereference' %s -- | FileCheck %s
-
-struct NoReturnDtor {
-  ~NoReturnDtor() __attribute__((noreturn));
-};
-
-extern bool check(const NoReturnDtor &);
-
-// CHECK-NOT: warning
-void testNullPointerDereferencePositive() {
-  int *value = 0;
-  // CHECK: [[@LINE+1]]:10: warning: Dereference of null pointer (loaded from variable 'value') [clang-analyzer-core.NullDereference]
-  *value = 1;
-}
-
-// CHECK-NOT: warning
-void testNullPointerDereference() {
-  int *value = 0;
-  if (check(NoReturnDtor())) {
-    // This unreachable code causes a warning if analysis of temporary
-    // destructors is not enabled.
-    *value = 1;
-  }
-}