[clang-tidy] Fix readability-redundant-string-c-str fix for overloaded operator->

[PiotrZSL]

Summary

Fixes https://github.com/llvm/llvm-project/issues/56705.

[PiotrZSL]

Already fixed by D145730

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

bool needParensAfterUnaryOperator(const Expr &ExprNode) {
   if (const auto *Op = dyn_cast<CXXOperatorCallExpr>(&ExprNode)) {
     return Op->getNumArgs() == 2 && Op->getOperator() != OO_PlusPlus &&
            Op->getOperator() != OO_MinusMinus && Op->getOperator() != OO_Call &&
            Op->getOperator() != OO_Subscript;
   }
   return false;
 }
 
-// Format a pointer to an expression: prefix with '*' but simplify
-// when it already begins with '&'.  Return empty string on failure.
-std::string
-formatDereference(const ast_matchers::MatchFinder::MatchResult &Result,
-                  const Expr &ExprNode) {
-  if (const auto *Op = dyn_cast<clang::UnaryOperator>(&ExprNode)) {
-    if (Op->getOpcode() == UO_AddrOf) {
-      // Strip leading '&'.
-      return std::string(tooling::fixit::getText(
-          *Op->getSubExpr()->IgnoreParens(), *Result.Context));
-    }
-  }
-  StringRef Text = tooling::fixit::getText(ExprNode, *Result.Context);
-
-  if (Text.empty())
-    return std::string();
-  // Add leading '*'.
-  if (needParensAfterUnaryOperator(ExprNode)) {
-    return (llvm::Twine("*(") + Text + ")").str();
-  }
-  return (llvm::Twine("*") + Text).str();
-}
-
 AST_MATCHER(MaterializeTemporaryExpr, isBoundToLValue) {
   return Node.isBoundToLvalueReference();
 }
 
 } // end namespace
 
 void RedundantStringCStrCheck::registerMatchers(
     ast_matchers::MatchFinder *Finder) {
Finder->addMatcher(
               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();
-  // Replace the "call" node with the "arg" node, prefixed with '*'
-  // if the call was using '->' rather than '.'.
-  std::string ArgText =
-      Arrow ? formatDereference(Result, *Arg)
-            : tooling::fixit::getText(*Arg, *Result.Context).str();
-  if (ArgText.empty())
-    return;
 
-  diag(Call->getBeginLoc(), "redundant call to %0")
+  auto D = diag(Call->getBeginLoc(), "redundant call to %0")
            << Member->getMemberDecl()
-      << FixItHint::CreateReplacement(Call->getSourceRange(), ArgText);
+           << FixItHint::CreateRemoval(CharSourceRange::getTokenRange(
+                  {Member->getOperatorLoc(), Call->getEndLoc()}));
+
+  if (Member->isArrow()) {
+    if (needParensAfterUnaryOperator(*Arg))
+      D << FixItHint::CreateInsertion(Arg->getBeginLoc(), "*(")
+        << FixItHint::CreateInsertion(Member->getOperatorLoc(), ")");
+    else
+      D << FixItHint::CreateInsertion(Arg->getBeginLoc(), "*");
+  }
 }
 
 } // namespace readability
 } // namespace tidy
 } // namespace clang

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

void bar() {
 
   // Ensure its not confused by parens
   Foo.func((Str.c_str()));
   // CHECK-MESSAGES: :[[@LINE-1]]:13: warning: redundant call to 'c_str' [readability-redundant-string-cstr]
   // CHECK-FIXES: {{^  }}Foo.func((Str));{{$}}
   Foo.func2((Str.c_str()));
 }
 } // namespace PR45286
+
+template<typename T>
+struct SmartPtr{
+  T* operator->()const;
+  T& operator*()const;
+};
+
+void smartPtrTest(SmartPtr<std::string> X){
+  f1(X->c_str());
+  // CHECK-MESSAGES: :[[@LINE-1]]:6: warning: redundant call to 'c_str' [readability-redundant-string-cstr]
+  // CHECK-FIXES: f1(*X);
+}