[clang-tidy] Extend redundant-string-c-str to also flag constructing a string_view.

clang-tools-extra/clang-tidy/readability/RedundantStringCStrCheck.cpp

 //===- RedundantStringCStrCheck.cpp - Check for redundant c_str calls -----===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 //
 //  This file implements a check for redundant calls of c_str() on strings.
 //
 //===----------------------------------------------------------------------===//
 
 #include "RedundantStringCStrCheck.h"
+#include "clang/AST/DeclCXX.h"
+#include "clang/AST/ExprCXX.h"
 #include "clang/Lex/Lexer.h"
 #include "clang/Tooling/FixIt.h"
 
 using namespace clang::ast_matchers;
 
 namespace clang {
 namespace tidy {
 namespace readability {
formatDereference(const ast_matchers::MatchFinder::MatchResult &Result,
   }
   return (llvm::Twine("*") + Text).str();
 }
 
 AST_MATCHER(MaterializeTemporaryExpr, isBoundToLValue) {
   return Node.isBoundToLvalueReference();
 }
 
+AST_MATCHER_P(CXXConstructExpr, forClass,
+              ast_matchers::internal::Matcher<CXXRecordDecl>, InnerMatcher) {
+  const CXXRecordDecl *Parent = Node.getConstructor()->getParent();
+  return Parent && InnerMatcher.matches(*Parent, Finder, Builder);
+}
+
 } // end namespace
 
 void RedundantStringCStrCheck::registerMatchers(
     ast_matchers::MatchFinder *Finder) {
   // Match expressions of type 'string' or 'string*'.
   const auto StringDecl = type(hasUnqualifiedDesugaredType(recordType(
       hasDeclaration(cxxRecordDecl(hasName("::std::basic_string"))))));
   const auto StringExpr =
void RedundantStringCStrCheck::registerMatchers(
   Finder->addMatcher(
       cxxMemberCallExpr(on(StringExpr),
                         callee(decl(cxxMethodDecl(hasName("insert")))),
                         argumentCountIs(2), hasArgument(1, StringCStrCallExpr)),
       this);
 
   // Detect redundant 'c_str()' calls through a StringRef constructor.
   Finder->addMatcher(
-      traverse(
-          TK_AsIs,
+      traverse(TK_AsIs,
                cxxConstructExpr(
                    // Implicit constructors of these classes are overloaded
                    // wrt. string types and they internally make a StringRef
                    // referring to the argument.  Passing a string directly to
                    // them is preferred to passing a char pointer.
-              hasDeclaration(cxxMethodDecl(hasAnyName(
-                  "::llvm::StringRef::StringRef", "::llvm::Twine::Twine"))),
+                   forClass(hasAnyName("::std::basic_string_view",
+                                       "::llvm::StringRef", "::llvm::Twine")),
                    argumentCountIs(1),
-              // The only argument must have the form x.c_str() or p->c_str()
-              // where the method is string::c_str().  StringRef also has
-              // a constructor from string which is more efficient (avoids
-              // strlen), so we can construct StringRef from the string
-              // directly.
+                   // The only argument must have the form x.c_str() or
+                   // p->c_str() where the method is string::c_str().  StringRef
+                   // also has a constructor from string which is more efficient
+                   // (avoids strlen), so we can construct StringRef from the
+                   // string directly.
                    hasArgument(0, StringCStrCallExpr))),
       this);
 }
 
 void RedundantStringCStrCheck::check(const MatchFinder::MatchResult &Result) {
   const auto *Call = Result.Nodes.getNodeAs<CallExpr>("call");
   const auto *Arg = Result.Nodes.getNodeAs<Expr>("arg");
   const auto *Member = Result.Nodes.getNodeAs<MemberExpr>("member");
   bool Arrow = Member->isArrow();

clang-tools-extra/test/clang-tidy/checkers/readability/redundant-string-cstr.cpp

struct basic_string {
   _Type& operator=(const _Type& str);
   _Type& operator=(const C* s);
 };
 
 typedef basic_string<char, std::char_traits<char>, std::allocator<char>> string;
 typedef basic_string<wchar_t, std::char_traits<wchar_t>, std::allocator<wchar_t>> wstring;
 typedef basic_string<char16, std::char_traits<char16>, std::allocator<char16>> u16string;
 typedef basic_string<char32, std::char_traits<char32>, std::allocator<char32>> u32string;
+
+template<typename C, typename T>
+struct basic_string_view {
+  basic_string_view(const C*);
+};
+
+typedef basic_string_view<char, std::char_traits<char>> string_view;
+typedef basic_string_view<wchar_t, std::char_traits<wchar_t>> wstring_voew;
+typedef basic_string_view<char16, std::char_traits<char16>> u16string_view;
+typedef basic_string_view<char32, std::char_traits<char32>> u32string_view;
 }
 
 std::string operator+(const std::string&, const std::string&);
 std::string operator+(const std::string&, const char*);
 std::string operator+(const char*, const std::string&);
 
 bool operator==(const std::string&, const std::string&);
 bool operator==(const std::string&, const char*);
void f6(const std::string &s) {
   tmp = s + s;
 
   if (tmp.find(s.c_str(), 2, 4) == 0) return;
 
   tmp.insert(1, s);
   tmp.insert(1, s.c_str(), 2);
 }
 
+void f7(const std::string_view&) {
+  std::string S;
+  f7(S.c_str());
+  // CHECK-MESSAGES: :[[@LINE-1]]:6: warning: redundant call {{.*}}
+  // CHECK-FIXES: {{^  }}std::string S;{{$}}
+  // CHECK-FIXES-NEXT: {{^  }}f7(S);{{$}}
+}
+
 // Tests for std::wstring.
 
 void g1(const std::wstring &s) {
   g1(s.c_str());
   // CHECK-MESSAGES: :[[@LINE-1]]:6: warning: redundant call to 'c_str' [readability-redundant-string-cstr]
   // CHECK-FIXES: {{^  }}g1(s);{{$}}
 }