[clang-tidy] Skip overloaded functions in modernize-use-string-view (llvm#183921)

Author: irishrover

clang-tools-extra/clang-tidy/modernize/UseStringViewCheck.cpp

@@ -21,6 +21,38 @@ using namespace clang::ast_matchers;
 
 namespace clang::tidy::modernize {
 
+namespace {
+AST_MATCHER(FunctionDecl, isOverloaded) {
+  const DeclarationName Name = Node.getDeclName();
+  // Sanity check
+  if (Name.isEmpty())
+    return false;
+  const DeclContext *DC = Node.getDeclContext();
+  auto LookupResult = DC->lookup(Name);
+  size_t UniqueSignatures = 0;
+  llvm::SmallPtrSet<const FunctionDecl *, 2> SeenFunctions;
+  for (NamedDecl *ND : LookupResult) {
+    const FunctionDecl *FD = nullptr;
+    if (const auto *Func = dyn_cast<FunctionDecl>(ND)) {
+      // Regular functions
+      FD = Func;
+    } else if (const auto *USD = dyn_cast<UsingShadowDecl>(ND)) {
+      // Overloads via "using ns::func_name"
+      FD = dyn_cast<FunctionDecl>(USD->getTargetDecl());
+    } else if (const auto *FTD = dyn_cast<FunctionTemplateDecl>(ND)) {
+      // Templated functions
+      FD = FTD->getTemplatedDecl();
+    }
+    if (FD && SeenFunctions.insert(FD->getCanonicalDecl()).second) {
+      UniqueSignatures++;
+      if (UniqueSignatures > 1)
+        return true;
+    }
+  }
+  return false;
+}
+} // namespace
+
 static constexpr StringRef StringViewClassKey = "string";
 static constexpr StringRef WStringViewClassKey = "wstring";
 static constexpr StringRef U8StringViewClassKey = "u8string";
@@ -81,6 +113,7 @@ void UseStringViewCheck::registerMatchers(MatchFinder *Finder) {
       functionDecl(
           isDefinition(),
           unless(anyOf(VirtualOrOperator, IgnoredFunctionsMatcher,
+                       isOverloaded(),
                        ast_matchers::isExplicitTemplateSpecialization())),
           returns(IsStdString), hasDescendant(returnStmt()),
           unless(hasDescendant(returnStmt(hasReturnValue(unless(

clang-tools-extra/docs/clang-tidy/checks/modernize/use-string-view.rst

@@ -83,6 +83,7 @@ Limitations
   * ``auto Trailing() -> std::string { return "Trailing"; }`` warns, doesn't fix
   * returnings from lambda
   * complicated macro and templated code
+  * overloaded functions and methods
 
 In some cases the fixed code will not compile due to lack of conversion from
 ``std::string_view`` to ``std::string``. It can be fixed (preferably) by

clang-tools-extra/test/clang-tidy/checkers/modernize/use-string-view.cpp

@@ -203,6 +203,44 @@ MyString<wchar_t> aliasedWChar() {
   return L"aliasedWChar";
 }
 
+namespace overload_funcs_redeclared {
+std::basic_string<char> overload(int);
+std::string overload(int);
+std::string overload(int) { return "int"; }
+// CHECK-MESSAGES:[[@LINE-1]]:1: warning: consider using 'std::string_view' to avoid unnecessary copying and allocations [modernize-use-string-view]
+// CHECK-FIXES: std::string_view overload(int) { return "int"; }
+}
+
+namespace overload_non_func {
+struct overload {};
+std::string overload(int) { return "int"; }
+// CHECK-MESSAGES:[[@LINE-1]]:1: warning: consider using 'std::string_view' to avoid unnecessary copying and allocations [modernize-use-string-view]
+// CHECK-FIXES: std::string_view overload(int) { return "int"; }
+}
+
+namespace overload_with_inline {
+  inline namespace inline_namespace {
+    std::string overload(int) { return "int"; }
+// CHECK-MESSAGES:[[@LINE-1]]:5: warning: consider using 'std::string_view' to avoid unnecessary copying and allocations [modernize-use-string-view]
+// CHECK-FIXES: std::string_view overload(int) { return "int"; }
+  }
+  inline namespace regular_namespace {
+    std::string overload(int) { return "int"; }
+// CHECK-MESSAGES:[[@LINE-1]]:5: warning: consider using 'std::string_view' to avoid unnecessary copying and allocations [modernize-use-string-view]
+// CHECK-FIXES: std::string_view overload(int) { return "int"; }
+  }
+}
+
+namespace overload_with_outer {
+namespace overload_with_templates {
+    template <typename T>
+    std::string overload(T) { return "T"; }
+    std::string overload(std::string) { return "string"; }
+}
+using overload_with_templates::overload;
+std::string overload(char*) { return "char*"; }
+}
+
 // ==========================================================
 // Negative tests
 // ==========================================================
@@ -357,6 +395,59 @@ std::string lambda() {
   }();
 }
 
+namespace overload_funcs {
+std::string dbl2str(double f);
+// Skip overloaded functions
+std::string overload(int) { return "int"; }
+// Because of this overload (non-literal return) the fix should not be applied
+std::string overload(double f) { return "f=" + dbl2str(f); }
+std::string overload(std::string) { return "string"; }
+}
+
+namespace overload_methods {
+struct Foo {
+  // Skip overloaded methods
+  std::string overload(int) { return "int"; }
+  std::string overload(double f) { return "double"; }
+  std::string overload(std::string) { return "string"; }
+};
+}
+
+namespace overload_methods_nested_classes {
+struct Bar {
+  std::string overload(int) { return "int"; }
+  std::string overload(std::string) { return "string"; }
+
+  struct FooBar {
+    std::string overload(char*) { return "char*"; }
+    std::string overload(double f) { return "double"; }
+  };
+};
+}
+
+namespace overload_methods_nested_namespaces {
+namespace foo {
+  std::string overload(int) { return "int"; }
+  std::string overload(std::string) { return "string"; }
+}
+using foo::overload;
+std::string overload(char*) { return "char*"; }
+}
+
+namespace overload_methods_templated {
+    template <typename T>
+    std::string overload(T value) { return "T";}
+    std::string overload(int value) { return "int"; }
+}
+
+namespace two_overloads_with_inline {
+  inline namespace inline_namespace {
+    std::string overload(int) { return "int"; }
+    std::string overload(double) { return "double"; }
+  }
+  std::string overload(int) { return "int"; }
+}
+
 struct TemplateString {
   static constexpr char* val = "TEMPLATE";
   template<typename T>