[clang-tidy] Add misc-shadowed-namespace-function check

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

@@ -34,6 +34,7 @@ add_clang_library(clangTidyMiscModule STATIC
   NonPrivateMemberVariablesInClassesCheck.cpp
   OverrideWithDifferentVisibilityCheck.cpp
   RedundantExpressionCheck.cpp
+  ShadowedNamespaceFunctionCheck.cpp
   StaticAssertCheck.cpp
   ThrowByValueCatchByReferenceCheck.cpp
   UnconventionalAssignOperatorCheck.cpp

clang-tools-extra/clang-tidy/misc/MiscTidyModule.cpp

@@ -24,6 +24,7 @@
 #include "NonPrivateMemberVariablesInClassesCheck.h"
 #include "OverrideWithDifferentVisibilityCheck.h"
 #include "RedundantExpressionCheck.h"
+#include "ShadowedNamespaceFunctionCheck.h"
 #include "StaticAssertCheck.h"
 #include "ThrowByValueCatchByReferenceCheck.h"
 #include "UnconventionalAssignOperatorCheck.h"
@@ -65,6 +66,8 @@ class MiscModule : public ClangTidyModule {
         "misc-non-private-member-variables-in-classes");
     CheckFactories.registerCheck<RedundantExpressionCheck>(
         "misc-redundant-expression");
+    CheckFactories.registerCheck<ShadowedNamespaceFunctionCheck>(
+        "misc-shadowed-namespace-function");
     CheckFactories.registerCheck<StaticAssertCheck>("misc-static-assert");
     CheckFactories.registerCheck<ThrowByValueCatchByReferenceCheck>(
         "misc-throw-by-value-catch-by-reference");

clang-tools-extra/clang-tidy/misc/ShadowedNamespaceFunctionCheck.cpp

@@ -0,0 +1,143 @@
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#include "ShadowedNamespaceFunctionCheck.h"
+#include "../utils/FixItHintUtils.h"
+#include "clang/AST/ASTContext.h"
+#include "clang/AST/Decl.h"
+#include "clang/AST/DeclCXX.h"
+#include "clang/ASTMatchers/ASTMatchers.h"
+#include "llvm/ADT/STLExtras.h"
+#include "llvm/ADT/SmallPtrSet.h"
+
+using namespace clang;
+using namespace clang::ast_matchers;
+using namespace clang::tidy;
+
+namespace clang::tidy::misc {
+
+template <typename ContainerTy>
+static auto makeCannonicalTypesRange(ContainerTy &&C) {
+  return llvm::map_range(C, [](const ParmVarDecl *Param) {
+    return Param->getType().getCanonicalType();
+  });
+}
+
+static bool hasSameSignature(const FunctionDecl *Func1,
+                             const FunctionDecl *Func2) {
+  if (Func1->param_size() != Func2->param_size())
+    return false;
+
+  if (Func1->getReturnType().getCanonicalType() !=
+      Func2->getReturnType().getCanonicalType())
+    return false;
+
+  return llvm::equal(makeCannonicalTypesRange(Func1->parameters()),
+                     makeCannonicalTypesRange(Func2->parameters()));
+}
+
+static std::pair<const FunctionDecl *, const NamespaceDecl *>
+findShadowedInNamespace(const NamespaceDecl *NS, const FunctionDecl *GlobalFunc,
+                        StringRef GlobalFuncName,
+                        llvm::SmallPtrSet<const FunctionDecl *, 16> &All) {
+
+  if (NS->isAnonymousNamespace())
+    return {nullptr, nullptr};
+
+  const FunctionDecl *ShadowedFunc = nullptr;
+  const NamespaceDecl *ShadowedNamespace = nullptr;
+
+  for (const auto *Decl : NS->decls()) {
+    // Check nested namespaces
+    if (const auto *NestedNS = dyn_cast<NamespaceDecl>(Decl)) {
+      auto [NestedShadowedFunc, NestedShadowedNamespace] =
+          findShadowedInNamespace(NestedNS, GlobalFunc, GlobalFuncName, All);
+      if (!ShadowedFunc)
+        std::tie(ShadowedFunc, ShadowedNamespace) =
+            std::tie(NestedShadowedFunc, NestedShadowedNamespace);
+    }
+
+    // Check functions
+    if (const auto *Func = dyn_cast<FunctionDecl>(Decl)) {
+      // TODO: syncronize this check with the matcher?
+      if (Func == GlobalFunc || Func->isTemplated() ||
+          Func->isThisDeclarationADefinition())
+        continue;
+
+      if (Func->getName() == GlobalFuncName && !Func->isVariadic() &&
+          hasSameSignature(Func, GlobalFunc)) {
+        All.insert(Func);
+        if (!ShadowedFunc)
+          std::tie(ShadowedFunc, ShadowedNamespace) = std::tie(Func, NS);
+      }
+    }
+  }
+  return {ShadowedFunc, ShadowedNamespace};
+}
+
+void ShadowedNamespaceFunctionCheck::registerMatchers(MatchFinder *Finder) {
+  Finder->addMatcher(
+      functionDecl(isDefinition(), decl(hasDeclContext(translationUnitDecl())),
+                   unless(anyOf(isImplicit(), isVariadic(), isMain(),
+                                isStaticStorageClass(),
+                                ast_matchers::isTemplateInstantiation())))
+          .bind("func"),
+      this);
+}
+
+void ShadowedNamespaceFunctionCheck::check(
+    const MatchFinder::MatchResult &Result) {
+  const auto *Func = Result.Nodes.getNodeAs<FunctionDecl>("func");
+
+  const StringRef FuncName = Func->getName();
+  if (FuncName.empty())
+    return;
+
+  const ASTContext *Context = Result.Context;
+
+  llvm::SmallPtrSet<const FunctionDecl *, 16> AllShadowedFuncs;
+  const FunctionDecl *ShadowedFunc = nullptr;
+  const NamespaceDecl *ShadowedNamespace = nullptr;
+
+  for (const auto *Decl : Context->getTranslationUnitDecl()->decls()) {
+    if (const auto *NS = dyn_cast<NamespaceDecl>(Decl)) {
+      auto [NestedShadowedFunc, NestedShadowedNamespace] =
+          findShadowedInNamespace(NS, Func, FuncName, AllShadowedFuncs);
+      if (!ShadowedFunc)
+        std::tie(ShadowedFunc, ShadowedNamespace) =
+            std::tie(NestedShadowedFunc, NestedShadowedNamespace);
+    }
+  }
+
+  if (!ShadowedFunc || !ShadowedNamespace)
+    return;
+
+  // TODO: should it be inside findShadowedInNamespace?
+  if (ShadowedFunc->getDefinition())
+    return;
+
+  const bool Ambiguous = AllShadowedFuncs.size() > 1;
+  std::string NamespaceName = ShadowedNamespace->getQualifiedNameAsString();
+  auto Diag = diag(Func->getLocation(),
+                   "free function %0 shadows %select{|at least }1'%2::%3'")
+              << Func << Ambiguous << NamespaceName
+              << ShadowedFunc->getDeclName().getAsString();
+
+  const SourceLocation NameLoc = Func->getLocation();
+  if (NameLoc.isValid() && !Func->getPreviousDecl() && !Ambiguous) {
+    const std::string Fix = std::move(NamespaceName) + "::";
+    Diag << FixItHint::CreateInsertion(NameLoc, Fix);
+  }
+
+  for (const FunctionDecl *NoteShadowedFunc : AllShadowedFuncs)
+    diag(NoteShadowedFunc->getLocation(), "function %0 declared here",
+         DiagnosticIDs::Note)
+        << NoteShadowedFunc->getDeclName();
+}
+
+} // namespace clang::tidy::misc

clang-tools-extra/clang-tidy/misc/ShadowedNamespaceFunctionCheck.h

@@ -0,0 +1,35 @@
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_MISC_SHADOWEDNAMESPACEFUNCTIONCHECK_H
+#define LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_MISC_SHADOWEDNAMESPACEFUNCTIONCHECK_H
+
+#include "../ClangTidyCheck.h"
+#include <tuple>
+
+namespace clang::tidy::misc {
+
+/// Detects free functions in global namespace that shadow functions from other
+/// namespaces.
+///
+/// For the user-facing documentation see:
+/// https://clang.llvm.org/extra/clang-tidy/checks/misc/shadowed-namespace-function.html
+class ShadowedNamespaceFunctionCheck : public ClangTidyCheck {
+public:
+  ShadowedNamespaceFunctionCheck(StringRef Name, ClangTidyContext *Context)
+      : ClangTidyCheck(Name, Context) {}
+  void registerMatchers(ast_matchers::MatchFinder *Finder) override;
+  void check(const ast_matchers::MatchFinder::MatchResult &Result) override;
+  bool isLanguageVersionSupported(const LangOptions &LangOpts) const override {
+    return LangOpts.CPlusPlus;
+  }
+};
+
+} // namespace clang::tidy::misc
+
+#endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_MISC_SHADOWEDNAMESPACEFUNCTIONCHECK_H

clang-tools-extra/docs/ReleaseNotes.rst

@@ -226,6 +226,12 @@ New checks
   Finds virtual function overrides with different visibility than the function
   in the base class.
 
+- New :doc:`misc-shadowed-namespace-function
+  <clang-tidy/checks/misc/shadowed-namespace-function>` check.
+
+  Detects free functions in global namespace that shadow functions from other
+  namespaces.
+
 - New :doc:`readability-redundant-parentheses
   <clang-tidy/checks/readability/redundant-parentheses>` check.
 

clang-tools-extra/docs/clang-tidy/checks/list.rst

@@ -277,6 +277,7 @@ Clang-Tidy Checks
    :doc:`misc-non-private-member-variables-in-classes <misc/non-private-member-variables-in-classes>`,
    :doc:`misc-override-with-different-visibility <misc/override-with-different-visibility>`,
    :doc:`misc-redundant-expression <misc/redundant-expression>`, "Yes"
+   :doc:`misc-shadowed-namespace-function <misc/shadowed-namespace-function>`, "Yes"
    :doc:`misc-static-assert <misc/static-assert>`, "Yes"
    :doc:`misc-throw-by-value-catch-by-reference <misc/throw-by-value-catch-by-reference>`,
    :doc:`misc-unconventional-assign-operator <misc/unconventional-assign-operator>`,

clang-tools-extra/docs/clang-tidy/checks/misc/shadowed-namespace-function.rst

@@ -0,0 +1,64 @@
+.. title:: clang-tidy - misc-shadowed-namespace-function
+
+misc-shadowed-namespace-function
+================================
+
+Detects free functions in the global namespace that shadow functions declared 
+in other namespaces.
+
+This check helps prevent accidental shadowing of namespace functions, which can
+lead to confusion about which function is being called and potential linking
+errors.
+
+Examples
+--------
+
+.. code-block:: c++
+
+  namespace utils {
+    void process();
+    void calculate();
+  }
+
+  // Warning: free function shadows utils::process
+  void process() {} 
+
+  // No warning - static function
+  static void calculate() {}
+
+The check will suggest adding the appropriate namespace qualification:
+
+.. code-block:: diff
+
+  - void process() {}
+  + void utils::process() {}
+
+The check will not warn about:
+
+- Static functions or member functions;
+- Functions in anonymous namespaces;
+- The ``main`` function.
+
+Limitations
+-----------
+
+- Does not warn about friend functions:
+
+.. code-block:: c++
+
+  namespace llvm::gsym {
+    struct MergedFunctionsInfo {
+        friend bool operator==(const MergedFunctionsInfo &LHS,
+                               const MergedFunctionsInfo &RHS);
+    };
+  }
+
+  using namespace llvm::gsym;
+
+  bool operator==(const MergedFunctionsInfo &LHS,  // no warning in this version
+                  const MergedFunctionsInfo &RHS) {
+    return LHS.MergedFunctions == RHS.MergedFunctions;
+  }
+
+- Does not warn about template functions;
+- Does not warn about variadic functions.

clang-tools-extra/test/clang-tidy/checkers/misc/shadowed-namespace-function-cxx20.cpp

@@ -0,0 +1,29 @@
+// RUN: %check_clang_tidy -std=c++20 %s misc-shadowed-namespace-function %t
+
+void f1_nested_inline_ns();
+namespace foo_nested_inline_ns::inline foo2::foo3 {
+  void f0_nested_inline_ns();
+  void f1_nested_inline_ns();
+}
+void f0_nested_inline_ns() {}
+// CHECK-MESSAGES: :[[@LINE-1]]:6: warning: free function 'f0_nested_inline_ns' shadows 'foo_nested_inline_ns::foo3::f0_nested_inline_ns' [misc-shadowed-namespace-function]
+// CHECK-FIXES: void foo_nested_inline_ns::foo3::f0_nested_inline_ns() {}
+void f1_nested_inline_ns() {}
+// CHECK-MESSAGES: :[[@LINE-1]]:6: warning: free function 'f1_nested_inline_ns' shadows 'foo_nested_inline_ns::foo3::f1_nested_inline_ns' [misc-shadowed-namespace-function]
+// CHECK-MESSAGES-NOT: :[[@LINE-2]]:{{.*}}: note: FIX-IT applied suggested code changes
+
+//////////////////////////////////////////////////////////////////////////////////////////
+
+void f1_nested_inline_ns_2();
+namespace foo_nested_inline_ns_2::inline foo2 {
+  void f0_nested_inline_ns_2();
+  void f1_nested_inline_ns_2();
+}
+void f0_nested_inline_ns_2() {}
+// CHECK-MESSAGES: :[[@LINE-1]]:6: warning: free function 'f0_nested_inline_ns_2' shadows 'foo_nested_inline_ns_2::foo2::f0_nested_inline_ns_2' [misc-shadowed-namespace-function]
+// CHECK-FIXES: void foo_nested_inline_ns_2::foo2::f0_nested_inline_ns_2() {}
+void f1_nested_inline_ns_2() {}
+// CHECK-MESSAGES: :[[@LINE-1]]:6: warning: free function 'f1_nested_inline_ns_2' shadows 'foo_nested_inline_ns_2::foo2::f1_nested_inline_ns_2' [misc-shadowed-namespace-function]
+// CHECK-MESSAGES-NOT: :[[@LINE-2]]:{{.*}}: note: FIX-IT applied suggested code changes
+
+//////////////////////////////////////////////////////////////////////////////////////////