Add a new check, readability-redundant-string-init, that checks unnecessary string initializations.

[hokein]

LGTM.

[alexfh]

clang-tidy/readability/RedundantStringInitCheck.cpp

26 ↗

(On Diff #48997)

nit: ast_matchers:: can be omitted.

54 ↗

(On Diff #48997)

ditto

test/clang-tidy/readability-redundant-string-init.cpp

1 ↗

(On Diff #48997)

Please add test cases with:

• a template with multiple instantiations
• macros, something along the lines of:

#define M(x) x
M({ std::string a = ""; })
#define M2 { std::string b = ""; }
M2;
M2;

[shuaiwang]

more test cases

[alexfh]

test/clang-tidy/readability-redundant-string-init.cpp

69 ↗

(On Diff #49108)

Please add a CHECK-FIXES to ensure the macro definition hasn't changed and that the macro invocations below are intact.

[shuaiwang]

CHECK-FIXES for macro tests

[alexfh]

Looks good!

I'll commit the patch for you.

[Eugene.Zelenko]

Sorry for arriving late to party :-)

Thank you for great check! I found a quite lot of such problems in my code base, but I'd like to make suggestion for further improvements: PR26756.

[alexfh]

In D17586#363466, @Eugene.Zelenko wrote:

Sorry for arriving late to party :-)

Thank you for great check! I found a quite lot of such problems in my code base, but I'd like to make suggestion for further improvements: PR26756.

The full link is: http://llvm.org/PR26756

[alexfh]

Shuai, if you have time, could you take a look at http://llvm.org/PR27087?

Thanks!

clang-tools-extra/trunk/clang-tidy/ClangTidyDiagnosticConsumer.h

public:
 
   /// \brief Returns the main file name of the current translation unit.
   StringRef getCurrentFile() const { return CurrentFile; }
 
   /// \brief Sets ASTContext for the current translation unit.
   void setASTContext(ASTContext *Context);
 
   /// \brief Gets the language options from the AST context.
-  LangOptions getLangOpts() const { return LangOpts; }
+  const LangOptions &getLangOpts() const { return LangOpts; }
 
   /// \brief Returns the name of the clang-tidy check which produced this
   /// diagnostic ID.
   StringRef getCheckName(unsigned DiagnosticID) const;
 
   /// \brief Returns check filter for the \c CurrentFile.
   ///
   /// The \c CurrentFile can be changed using \c setCurrentFile.

clang-tools-extra/trunk/clang-tidy/ClangTidyDiagnosticConsumer.cpp

if (DiagLevel == DiagnosticsEngine::Error ||
       LastErrorPassesLineFilter = true;
     }
     bool IsWarningAsError =
         DiagLevel == DiagnosticsEngine::Warning &&
         Context.getWarningAsErrorFilter().contains(CheckName);
     Errors.push_back(ClangTidyError(CheckName, Level, IsWarningAsError));
   }
 
-  // FIXME: Provide correct LangOptions for each file.
-  LangOptions LangOpts;
   ClangTidyDiagnosticRenderer Converter(
-      LangOpts, &Context.DiagEngine->getDiagnosticOptions(), Errors.back());
+      Context.getLangOpts(), &Context.DiagEngine->getDiagnosticOptions(),
+      Errors.back());
   SmallString<100> Message;
   Info.FormatDiagnostic(Message);
   SourceManager *Sources = nullptr;
   if (Info.hasSourceManager())
     Sources = &Info.getSourceManager();
   Converter.emitDiagnostic(Info.getLocation(), DiagLevel, Message,
                            Info.getRanges(), Info.getFixItHints(), Sources);
 

clang-tools-extra/trunk/clang-tidy/readability/CMakeLists.txt

 set(LLVM_LINK_COMPONENTS support)
 
 add_clang_library(clangTidyReadabilityModule
   BracesAroundStatementsCheck.cpp
   ContainerSizeEmptyCheck.cpp
   ElseAfterReturnCheck.cpp
   FunctionSizeCheck.cpp
   IdentifierNamingCheck.cpp
   ImplicitBoolCastCheck.cpp
   InconsistentDeclarationParameterNameCheck.cpp
   NamedParameterCheck.cpp
   NamespaceCommentCheck.cpp
   ReadabilityTidyModule.cpp
   RedundantControlFlowCheck.cpp
   RedundantStringCStrCheck.cpp
   RedundantSmartptrGetCheck.cpp
+  RedundantStringInitCheck.cpp
   SimplifyBooleanExprCheck.cpp
   UniqueptrDeleteReleaseCheck.cpp
 
   LINK_LIBS
   clangAST
   clangASTMatchers
   clangBasic
   clangLex
   clangTidy
   clangTooling
   )

clang-tools-extra/trunk/clang-tidy/readability/ReadabilityTidyModule.cpp

 #include "FunctionSizeCheck.h"
 #include "IdentifierNamingCheck.h"
 #include "ImplicitBoolCastCheck.h"
 #include "InconsistentDeclarationParameterNameCheck.h"
 #include "NamedParameterCheck.h"
 #include "RedundantControlFlowCheck.h"
 #include "RedundantSmartptrGetCheck.h"
 #include "RedundantStringCStrCheck.h"
+#include "RedundantStringInitCheck.h"
 #include "SimplifyBooleanExprCheck.h"
 #include "UniqueptrDeleteReleaseCheck.h"
 
 namespace clang {
 namespace tidy {
 namespace readability {
 
 class ReadabilityModule : public ClangTidyModule {
void addCheckFactories(ClangTidyCheckFactories &CheckFactories) override {
     CheckFactories.registerCheck<readability::NamedParameterCheck>(
         "readability-named-parameter");
     CheckFactories.registerCheck<RedundantControlFlowCheck>(
         "readability-redundant-control-flow");
     CheckFactories.registerCheck<RedundantSmartptrGetCheck>(
         "readability-redundant-smartptr-get");
     CheckFactories.registerCheck<RedundantStringCStrCheck>(
         "readability-redundant-string-cstr");
+    CheckFactories.registerCheck<RedundantStringInitCheck>(
+        "readability-redundant-string-init");
     CheckFactories.registerCheck<SimplifyBooleanExprCheck>(
         "readability-simplify-boolean-expr");
     CheckFactories.registerCheck<UniqueptrDeleteReleaseCheck>(
         "readability-uniqueptr-delete-release");
   }
 };
 
 // Register the ReadabilityModule using this statically initialized variable.

clang-tools-extra/trunk/clang-tidy/readability/RedundantStringInitCheck.h

+//===- RedundantStringInitCheck.h - clang-tidy ------------------*- C++ -*-===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_READABILITY_REDUNDANT_STRING_INIT_H
+#define LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_READABILITY_REDUNDANT_STRING_INIT_H
+
+#include "../ClangTidy.h"
+
+namespace clang {
+namespace tidy {
+namespace readability {
+
+/// Finds unnecessary string initializations.
+class RedundantStringInitCheck : public ClangTidyCheck {
+public:
+  RedundantStringInitCheck(StringRef Name, ClangTidyContext *Context)
+      : ClangTidyCheck(Name, Context) {}
+  void registerMatchers(ast_matchers::MatchFinder *Finder) override;
+  void check(const ast_matchers::MatchFinder::MatchResult &Result) override;
+};
+
+} // namespace readability
+} // namespace tidy
+} // namespace clang
+
+#endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_READABILITY_REDUNDANT_STRING_INIT_H

clang-tools-extra/trunk/clang-tidy/readability/RedundantStringInitCheck.cpp

+//===- RedundantStringInitCheck.cpp - clang-tidy ----------------*- C++ -*-===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+#include "RedundantStringInitCheck.h"
+#include "clang/ASTMatchers/ASTMatchers.h"
+
+using namespace clang::ast_matchers;
+
+namespace clang {
+namespace tidy {
+namespace readability {
+
+namespace {
+
+AST_MATCHER(StringLiteral, lengthIsZero) { return Node.getLength() == 0; }
+
+} // namespace
+
+void RedundantStringInitCheck::registerMatchers(MatchFinder *Finder) {
+  if (!getLangOpts().CPlusPlus)
+    return;
+
+  const auto StringCtorExpr = cxxConstructExpr(
+      hasDeclaration(cxxMethodDecl(hasName("basic_string"))),
+      argumentCountIs(2),
+      hasArgument(0, ignoringParenImpCasts(stringLiteral(lengthIsZero()))),
+      hasArgument(1, cxxDefaultArgExpr()));
+
+  // string foo = "";
+  // OR
+  // string bar("");
+  Finder->addMatcher(
+      namedDecl(varDecl(hasType(cxxRecordDecl(hasName("basic_string"))),
+                        hasInitializer(
+                            expr(anyOf(StringCtorExpr,
+                                       exprWithCleanups(has(expr(anyOf(
+                                           StringCtorExpr,
+                                           cxxConstructExpr(hasArgument(
+                                               0, cxxBindTemporaryExpr(has(
+                                                      StringCtorExpr))))))))))
+                                .bind("expr"))))
+          .bind("decl"),
+      this);
+}
+
+void RedundantStringInitCheck::check(const MatchFinder::MatchResult &Result) {
+  const auto *CtorExpr = Result.Nodes.getNodeAs<Expr>("expr");
+  const auto *Decl = Result.Nodes.getNodeAs<NamedDecl>("decl");
+  diag(CtorExpr->getExprLoc(), "redundant string initialization")
+      << FixItHint::CreateReplacement(CtorExpr->getSourceRange(),
+                                      Decl->getName());
+}
+
+} // namespace readability
+} // namespace tidy
+} // namespace clang

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

.. toctree::
    readability-function-size
    readability-identifier-naming
    readability-implicit-bool-cast
    readability-inconsistent-declaration-parameter-name
    readability-named-parameter
    readability-redundant-control-flow
    readability-redundant-smartptr-get
    readability-redundant-string-cstr
+   readability-redundant-string-init
    readability-simplify-boolean-expr
    readability-uniqueptr-delete-release

clang-tools-extra/trunk/docs/clang-tidy/checks/readability-redundant-string-init.rst

+.. title:: clang-tidy - readability-redundant-string-init
+
+readability-redundant-string-init
+=================================
+
+
+Finds unnecessary string initializations.
+
+Examples:
+
+.. code:: c++
+
+  // Initializing string with empty string literal is unnecessary.
+  std::string a = "";
+  std::string b("");
+

clang-tools-extra/trunk/test/clang-tidy/readability-redundant-string-init.cpp

+// RUN: %check_clang_tidy %s readability-redundant-string-init %t
+
+namespace std {
+template <typename T>
+class allocator {};
+template <typename T>
+class char_traits {};
+template <typename C, typename T = std::char_traits<C>, typename A = std::allocator<C>>
+struct basic_string {
+  basic_string();
+  basic_string(const basic_string&);
+  basic_string(const C *, const A &a = A());
+  ~basic_string();
+};
+typedef basic_string<char> string;
+typedef basic_string<wchar_t> wstring;
+}
+
+void f() {
+  std::string a = "";
+  // CHECK-MESSAGES: [[@LINE-1]]:15: warning: redundant string initialization [readability-redundant-string-init]
+  // CHECK-FIXES: std::string a;
+  std::string b("");
+  // CHECK-MESSAGES: [[@LINE-1]]:15: warning: redundant string initialization
+  // CHECK-FIXES: std::string b;
+  std::string c = R"()";
+  // CHECK-MESSAGES: [[@LINE-1]]:15: warning: redundant string initialization
+  // CHECK-FIXES: std::string c;
+  std::string d(R"()");
+  // CHECK-MESSAGES: [[@LINE-1]]:15: warning: redundant string initialization
+  // CHECK-FIXES: std::string d;
+
+  std::string u = "u";
+  std::string w("w");
+  std::string x = R"(x)";
+  std::string y(R"(y)");
+  std::string z;
+}
+
+void g() {
+  std::wstring a = L"";
+  // CHECK-MESSAGES: [[@LINE-1]]:16: warning: redundant string initialization
+  // CHECK-FIXES: std::wstring a;
+  std::wstring b(L"");
+  // CHECK-MESSAGES: [[@LINE-1]]:16: warning: redundant string initialization
+  // CHECK-FIXES: std::wstring b;
+  std::wstring c = LR"()";
+  // CHECK-MESSAGES: [[@LINE-1]]:16: warning: redundant string initialization
+  // CHECK-FIXES: std::wstring c;
+  std::wstring d(LR"()");
+  // CHECK-MESSAGES: [[@LINE-1]]:16: warning: redundant string initialization
+  // CHECK-FIXES: std::wstring d;
+
+  std::wstring u = L"u";
+  std::wstring w(L"w");
+  std::wstring x = LR"(x)";
+  std::wstring y(LR"(y)");
+  std::wstring z;
+}
+
+template <typename T>
+void templ() {
+  std::string s = "";
+  // CHECK-MESSAGES: [[@LINE-1]]:15: warning: redundant string initialization
+  // CHECK-FIXES: std::string s;
+}
+
+#define M(x) x
+#define N { std::string s = ""; }
+// CHECK-FIXES: #define N { std::string s = ""; }
+
+void h() {
+  templ<int>();
+  templ<double>();
+
+  M({ std::string s = ""; })
+  // CHECK-MESSAGES: [[@LINE-1]]:19: warning: redundant string initialization
+  // CHECK-FIXES: M({ std::string s; })
+
+  N
+  // CHECK-MESSAGES: [[@LINE-1]]:3: warning: redundant string initialization
+  // CHECK-FIXES: N
+  N
+  // CHECK-MESSAGES: [[@LINE-1]]:3: warning: redundant string initialization
+  // CHECK-FIXES: N
+}