Revert "[clang-tidy] Give readability-redundant-string-init a customizable... (47bd7c57) · Commits · llvm-doe / llvm-project

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

+9 −34

Original line number	Diff line number	Diff line
		@@ -8,7 +8,6 @@

		#include "RedundantStringInitCheck.h"
		#include "../utils/Matchers.h"
		#include "../utils/OptionsUtils.h"
		#include "clang/ASTMatchers/ASTMatchers.h"

		using namespace clang::ast_matchers;
		@@ -18,42 +17,18 @@ namespace clang {
		namespace tidy {
		namespace readability {

		const char DefaultStringNames[] = "::std::basic_string";

		RedundantStringInitCheck::RedundantStringInitCheck(StringRef Name,
		ClangTidyContext *Context)
		: ClangTidyCheck(Name, Context),
		StringNames(utils::options::parseStringList(
		Options.get("StringNames", DefaultStringNames))) {}

		void RedundantStringInitCheck::storeOptions(ClangTidyOptions::OptionMap &Opts) {
		Options.store(Opts, "StringNames", DefaultStringNames);
		}

		void RedundantStringInitCheck::registerMatchers(MatchFinder *Finder) {
		if (!getLangOpts().CPlusPlus)
		return;
		const auto hasStringTypeName = hasAnyName(
		SmallVector<StringRef, 3>(StringNames.begin(), StringNames.end()));

		// Version of StringNames with namespaces removed
		std::vector<std::string> stringNamesNoNamespace;
		for (const std::string &name : StringNames) {
		std::string::size_type colonPos = name.rfind(':');
		stringNamesNoNamespace.push_back(
		name.substr(colonPos == std::string::npos ? 0 : colonPos + 1));
		}
		const auto hasStringCtorName = hasAnyName(SmallVector<StringRef, 3>(
		stringNamesNoNamespace.begin(), stringNamesNoNamespace.end()));

		// Match string constructor.
		const auto StringConstructorExpr = expr(
		anyOf(cxxConstructExpr(argumentCountIs(1),
		hasDeclaration(cxxMethodDecl(hasStringCtorName))),
		// If present, the second argument is the alloc object which must
		// not be present explicitly.
		const auto StringConstructorExpr = expr(anyOf(
		cxxConstructExpr(argumentCountIs(1),
		hasDeclaration(cxxMethodDecl(hasName("basic_string")))),
		// If present, the second argument is the alloc object which must not
		// be present explicitly.
		cxxConstructExpr(argumentCountIs(2),
		hasDeclaration(cxxMethodDecl(hasStringCtorName)),
		hasDeclaration(cxxMethodDecl(hasName("basic_string"))),
		hasArgument(1, cxxDefaultArgExpr()))));

		// Match a string constructor expression with an empty string literal.
		@@ -73,7 +48,7 @@ void RedundantStringInitCheck::registerMatchers(MatchFinder *Finder) {
		namedDecl(
		varDecl(
		hasType(hasUnqualifiedDesugaredType(recordType(
		hasDeclaration(cxxRecordDecl(hasStringTypeName))))),
		hasDeclaration(cxxRecordDecl(hasName("basic_string")))))),
		hasInitializer(expr(ignoringImplicit(anyOf(
		EmptyStringCtorExpr, EmptyStringCtorExprWithTemporaries)))))
		.bind("vardecl"),

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

+2 −7

Original line number	Diff line number	Diff line
		@@ -10,8 +10,6 @@
		#define LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_READABILITY_REDUNDANT_STRING_INIT_H

		#include "../ClangTidyCheck.h"
		#include <string>
		#include <vector>

		namespace clang {
		namespace tidy {
		@@ -20,13 +18,10 @@ namespace readability {
		/// Finds unnecessary string initializations.
		class RedundantStringInitCheck : public ClangTidyCheck {
		public:
		RedundantStringInitCheck(StringRef Name, ClangTidyContext *Context);
		void storeOptions(ClangTidyOptions::OptionMap &Opts) override;
		RedundantStringInitCheck(StringRef Name, ClangTidyContext *Context)
		: ClangTidyCheck(Name, Context) {}
		void registerMatchers(ast_matchers::MatchFinder *Finder) override;
		void check(const ast_matchers::MatchFinder::MatchResult &Result) override;

		private:
		std::vector<std::string> StringNames;
		};

		} // namespace readability

clang-tools-extra/docs/ReleaseNotes.rst

+0 −4

Original line number	Diff line number	Diff line
		@@ -164,10 +164,6 @@ Improvements to clang-tidy
		Finds non-static member functions that can be made ``const``
		because the functions don't use ``this`` in a non-const way.

		- The :doc:`readability-redundant-string-init
		<clang-tidy/checks/readability-redundant-string-init>` check now supports a
		`StringNames` option enabling its application to custom string classes.

		Improvements to include-fixer
		-----------------------------

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

+1 −14

Original line number	Diff line number	Diff line
		@@ -5,8 +5,7 @@ readability-redundant-string-init

		Finds unnecessary string initializations.

		Examples
		--------
		Examples:

		.. code-block:: c++

		@@ -18,15 +17,3 @@ Examples

		std::string a;
		std::string b;

		Options
		-------

		.. option:: StringNames

		Default is `::std::basic_string`.

		Semicolon-delimited list of class names to apply this check to.
		By default `::std::basic_string` applies to ``std::string`` and
		``std::wstring``. Set to e.g. `::std::basic_string;llvm::StringRef;QString`
		to perform this check on custom classes.

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

+1 −85

Original line number	Diff line number	Diff line
		// RUN: %check_clang_tidy -std=c++11,c++14 %s readability-redundant-string-init %t \
		// RUN: -config="{CheckOptions: \
		// RUN: [{key: readability-redundant-string-init.StringNames, \
		// RUN: value: "::std::basic_string;our::TestString"}] \
		// RUN: }"
		// FIXME: Fix the checker to work in C++17 mode.
		// RUN: %check_clang_tidy %s readability-redundant-string-init %t

		namespace std {
		template <typename T>
		@@ -148,82 +143,3 @@ extern void Param2(const std::string& param = "");
		void Param3(std::string param = "") {}
		void Param4(STRING param = "") {}

		namespace our {
		struct TestString {
		TestString();
		TestString(const TestString &);
		TestString(const char *);
		~TestString();
		};
		}

		void ourTestStringTests() {
		our::TestString a = "";
		// CHECK-MESSAGES: [[@LINE-1]]:19: warning: redundant string initialization
		// CHECK-FIXES: our::TestString a;
		our::TestString b("");
		// CHECK-MESSAGES: [[@LINE-1]]:19: warning: redundant string initialization
		// CHECK-FIXES: our::TestString b;
		our::TestString c = R"()";
		// CHECK-MESSAGES: [[@LINE-1]]:19: warning: redundant string initialization
		// CHECK-FIXES: our::TestString c;
		our::TestString d(R"()");
		// CHECK-MESSAGES: [[@LINE-1]]:19: warning: redundant string initialization
		// CHECK-FIXES: our::TestString d;

		our::TestString u = "u";
		our::TestString w("w");
		our::TestString x = R"(x)";
		our::TestString y(R"(y)");
		our::TestString z;
		}

		namespace their {
		using TestString = our::TestString;
		}

		// their::TestString is the same type so should warn / fix
		void theirTestStringTests() {
		their::TestString a = "";
		// CHECK-MESSAGES: [[@LINE-1]]:21: warning: redundant string initialization
		// CHECK-FIXES: their::TestString a;
		their::TestString b("");
		// CHECK-MESSAGES: [[@LINE-1]]:21: warning: redundant string initialization
		// CHECK-FIXES: their::TestString b;
		}

		namespace other {
		// Identical declarations to above but different type
		struct TestString {
		TestString();
		TestString(const TestString &);
		TestString(const char *);
		~TestString();
		};

		// Identical declarations to above but different type
		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;
		}

		// other::TestString, other::string, other::wstring are unrelated to the types
		// being checked. No warnings / fixes should be produced for these types.
		void otherTestStringTests() {
		other::TestString a = "";
		other::TestString b("");
		other::string c = "";
		other::string d("");
		other::wstring e = L"";
		other::wstring f(L"");
		}