Implementation template from DeepSeek

Author: denzor200

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,131 @@
+//===----------------------------------------------------------------------===//
+//
+// 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/ASTMatchers/ASTMatchers.h"
+#include "clang/AST/Decl.h"
+#include "clang/AST/DeclCXX.h"
+
+using namespace clang;
+using namespace clang::ast_matchers;
+using namespace clang::tidy;
+
+namespace clang {
+namespace tidy {
+namespace misc {
+
+void ShadowedNamespaceFunctionCheck::registerMatchers(MatchFinder *Finder) {
+  // Simple matcher for all function definitions
+  Finder->addMatcher(
+      functionDecl(
+          isDefinition()
+      ).bind("func"),
+      this
+  );
+}
+
+void ShadowedNamespaceFunctionCheck::check(
+    const MatchFinder::MatchResult &Result) {
+  const auto *Func = Result.Nodes.getNodeAs<FunctionDecl>("func");
+  
+  if (!Func || !Result.SourceManager)
+    return;
+
+  // Skip if not in global namespace
+  const DeclContext *DC = Func->getDeclContext();
+  if (!DC->isTranslationUnit())
+    return;
+
+  // Skip templates, static functions, main, etc.
+  if (Func->isTemplated() || Func->isStatic() || 
+      Func->getName() == "main" || Func->isImplicit())
+    return;
+
+  std::string FuncName = Func->getNameAsString();
+  if (FuncName.empty())
+    return;
+
+  ASTContext *Context = Result.Context;
+
+  // Look for functions with the same name in namespaces
+  const FunctionDecl *ShadowedFunc = nullptr;
+  const NamespaceDecl *ShadowedNamespace = nullptr;
+
+  // Traverse all declarations in the translation unit
+  for (const auto *Decl : Context->getTranslationUnitDecl()->decls()) {
+    if (const auto *NS = dyn_cast<NamespaceDecl>(Decl)) {
+      findShadowedInNamespace(NS, Func, FuncName, ShadowedFunc, ShadowedNamespace);
+      if (ShadowedFunc) break;
+    }
+  }
+
+  if (!ShadowedFunc || !ShadowedNamespace)
+    return;
+
+  // Generate warning message
+  std::string NamespaceName = ShadowedNamespace->getNameAsString();
+  auto Diag = diag(Func->getLocation(), 
+                   "free function %0 shadows %1::%2")
+              << Func->getDeclName() 
+              << NamespaceName 
+              << ShadowedFunc->getDeclName();
+
+  // Generate fixit hint to add namespace qualification
+  SourceLocation NameLoc = Func->getLocation();
+  if (NameLoc.isValid()) {
+    std::string Fix = NamespaceName + "::";
+    Diag << FixItHint::CreateInsertion(NameLoc, Fix);
+  }
+
+  // Note: Also show where the shadowed function is declared
+  diag(ShadowedFunc->getLocation(), 
+       "function %0 declared here", DiagnosticIDs::Note)
+      << ShadowedFunc->getDeclName();
+}
+
+void ShadowedNamespaceFunctionCheck::findShadowedInNamespace(
+    const NamespaceDecl *NS, 
+    const FunctionDecl *GlobalFunc,
+    const std::string &GlobalFuncName,
+    const FunctionDecl *&ShadowedFunc,
+    const NamespaceDecl *&ShadowedNamespace) {
+  
+  // Skip anonymous namespaces
+  if (NS->isAnonymousNamespace())
+    return;
+
+  for (const auto *Decl : NS->decls()) {
+    // Check nested namespaces
+    if (const auto *NestedNS = dyn_cast<NamespaceDecl>(Decl)) {
+      findShadowedInNamespace(NestedNS, GlobalFunc, GlobalFuncName, 
+                             ShadowedFunc, ShadowedNamespace);
+      if (ShadowedFunc) return;
+    }
+
+    // Check functions
+    if (const auto *Func = dyn_cast<FunctionDecl>(Decl)) {
+      // Skip if it's the same function, templates, or definitions
+      if (Func == GlobalFunc || Func->isTemplated() || 
+          Func->isThisDeclarationADefinition())
+        continue;
+
+      if (Func->getNameAsString() == GlobalFuncName) {
+        ShadowedFunc = Func;
+        ShadowedNamespace = NS;
+        return;
+      }
+    }
+  }
+}
+
+} // namespace misc
+} // namespace tidy
+} // namespace clang
+

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

@@ -0,0 +1,39 @@
+//===----------------------------------------------------------------------===//
+//
+// 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"
+
+namespace clang::tidy::misc {
+
+/// FIXME: Write a short description.
+///
+/// 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;
+  }
+private:
+  void findShadowedInNamespace(const NamespaceDecl *NS,
+                               const FunctionDecl *GlobalFunc,
+                               const std::string &GlobalFuncName,
+                               const FunctionDecl *&ShadowedFunc,
+                               const NamespaceDecl *&ShadowedNamespace);
+};
+
+} // namespace clang::tidy::misc
+
+#endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_MISC_SHADOWEDNAMESPACEFUNCTIONCHECK_H

clang-tools-extra/docs/ReleaseNotes.rst

@@ -226,6 +226,11 @@ 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.
+
+  FIXME: Write a short description.
+
 - New :doc:`readability-redundant-parentheses
   <clang-tidy/checks/readability/redundant-parentheses>` check.
 

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

@@ -277,6 +277,8 @@ 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-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,6 @@
+.. title:: clang-tidy - misc-shadowed-namespace-function
+
+misc-shadowed-namespace-function
+================================
+
+FIXME: Describe what patterns does the check detect and why. Give examples.

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

@@ -0,0 +1,13 @@
+// RUN: %check_clang_tidy %s misc-shadowed-namespace-function %t
+
+void f1();
+namespace foo {
+  void f0();
+  void f1();
+}
+void f0() {}
+// CHECK-MESSAGES: :[[@LINE-1]]:6: warning: free function 'f0' shadows foo::f0 [misc-shadowed-namespace-function]
+// CHECK-FIXES: void foo::f0() {}
+void f1() {}
+// CHECK-MESSAGES: :[[@LINE-1]]:6: warning: free function 'f1' shadows foo::f1 [misc-shadowed-namespace-function]
+// CHECK-MESSAGES-NOT: :[[@LINE-2]]:{{.*}}: note: FIX-IT applied suggested code changes