Re: [PATCH] D20196: [clang-tidy] Inefficient string operation
bittnerbarni updated this revision to Diff 65384.
bittnerbarni marked an inline comment as done.
https://reviews.llvm.org/D20196
Files:
clang-tidy/performance/CMakeLists.txt
clang-tidy/performance/InefficientStringConcatenationCheck.cpp
clang-tidy/performance/InefficientStringConcatenationCheck.h
clang-tidy/performance/PerformanceTidyModule.cpp
docs/ReleaseNotes.rst
docs/clang-tidy/checks/list.rst
docs/clang-tidy/checks/performance-inefficient-string-concatenation.rst
test/clang-tidy/performance-inefficient-string-concatenation.cpp
Index: test/clang-tidy/performance-inefficient-string-concatenation.cpp
===
--- /dev/null
+++ test/clang-tidy/performance-inefficient-string-concatenation.cpp
@@ -0,0 +1,44 @@
+// RUN: %check_clang_tidy %s performance-inefficient-string-concatenation %t
+
+namespace std {
+template
+class basic_string {
+public:
+ basic_string() {}
+ ~basic_string() {}
+ basic_string *operator+=(const basic_string &) {}
+ friend basic_string operator+(const basic_string &, const basic_string &) {}
+};
+typedef basic_string string;
+typedef basic_string wstring;
+}
+
+void f(std::string) {}
+std::string g(std::string) {}
+
+int main() {
+ std::string mystr1, mystr2;
+ std::wstring mywstr1, mywstr2;
+
+ for (int i = 0; i < 10; ++i) {
+f(mystr1 + mystr2 + mystr1);
+// CHECK-MESSAGES: :[[@LINE-1]]:23: warning: string concatenation results in allocation of unnecessary temporary strings; consider using 'operator+=' or 'string::append()' instead
+mystr1 = mystr1 + mystr2;
+// CHECK-MESSAGES: :[[@LINE-1]]:5: warning: string concatenation
+mystr1 = mystr2 + mystr2 + mystr2;
+// CHECK-MESSAGES: :[[@LINE-1]]:30: warning: string concatenation
+mystr1 = mystr2 + mystr1;
+// CHECK-MESSAGES: :[[@LINE-1]]:5: warning: string concatenation
+mywstr1 = mywstr2 + mywstr1;
+// CHECK-MESSAGES: :[[@LINE-1]]:5: warning: string concatenation
+mywstr1 = mywstr2 + mywstr2 + mywstr2;
+// CHECK-MESSAGES: :[[@LINE-1]]:33: warning: string concatenation
+
+mywstr1 = mywstr2 + mywstr2;
+mystr1 = mystr2 + mystr2;
+mystr1 += mystr2;
+f(mystr2 + mystr1);
+mystr1 = g(mystr1);
+ }
+ return 0;
+}
Index: docs/clang-tidy/checks/performance-inefficient-string-concatenation.rst
===
--- /dev/null
+++ docs/clang-tidy/checks/performance-inefficient-string-concatenation.rst
@@ -0,0 +1,49 @@
+.. title:: clang-tidy - performance-inefficient-string-concatenation
+
+performance-inefficient-string-concatenation
+
+
+This check warns about the performance overhead arising from concatenating strings using the ``operator+``, for instance:
+
+.. code:: c++
+
+std::string a("Foo"), b("Bar");
+a = a + b;
+
+Instead of this structure you should use ``operator+=`` or ``std::string``'s (``std::basic_string``) class member function ``append()``. For instance:
+
+.. code:: c++
+
+ std::string a("Foo"), b("Baz");
+ for (int i = 0; i < 2; ++i) {
+ a = a + "Bar" + b;
+ }
+
+Could be rewritten in a greatly more efficient way like:
+
+.. code:: c++
+
+ std::string a("Foo"), b("Baz");
+ for (int i = 0; i < 2; ++i) {
+ a.append("Bar").append(b);
+ }
+
+And this can be rewritten too:
+
+.. code:: c++
+
+ void f(const std::string&) {}
+ std::string a("Foo"), b("Baz");
+ void g() {
+ f(a + "Bar" + b);
+ }
+
+In a slightly more efficient way like:
+
+.. code:: c++
+
+ void f(const std::string&) {}
+ std::string a("Foo"), b("Baz");
+ void g() {
+ f(std::string(a).append("Bar").append(b));
+ }
Index: docs/clang-tidy/checks/list.rst
===
--- docs/clang-tidy/checks/list.rst
+++ docs/clang-tidy/checks/list.rst
@@ -102,6 +102,7 @@
performance-faster-string-find
performance-for-range-copy
performance-implicit-cast-in-loop
+ performance-inefficient-string-concatenation
performance-unnecessary-copy-initialization
performance-unnecessary-value-param
readability-avoid-const-params-in-decls
Index: docs/ReleaseNotes.rst
===
--- docs/ReleaseNotes.rst
+++ docs/ReleaseNotes.rst
@@ -184,6 +184,12 @@
Warns about range-based loop with a loop variable of const ref type where the
type of the variable does not match the one returned by the iterator.
+- New `performance-inefficient-string-concatenation
+ `_ check
+
+ This check is to warn about the performance overhead arising from concatenating
+ strings, using the ``operator+``, instead of ``operator+=``.
+
- New `performance-unnecessary-value-param
`_
Re: [PATCH] D20196: [clang-tidy] Inefficient string operation
bittnerbarni added inline comments.
Comment at: clang-tidy/performance/InefficientStringConcatenationCheck.cpp:55
@@ +54,3 @@
+ hasDeclaration(decl(equalsBoundNode("lhsStrT"))),
+ hasDescendant(BasicStringPlusOperator));
+
Yes this is the result of clang-format.
https://reviews.llvm.org/D20196
___
cfe-commits mailing list
cfe-commits@lists.llvm.org
http://lists.llvm.org/cgi-bin/mailman/listinfo/cfe-commits
Re: [PATCH] D20196: [clang-tidy] Inefficient string operation
bittnerbarni updated this revision to Diff 65606.
https://reviews.llvm.org/D20196
Files:
clang-tidy/performance/CMakeLists.txt
clang-tidy/performance/InefficientStringConcatenationCheck.cpp
clang-tidy/performance/InefficientStringConcatenationCheck.h
clang-tidy/performance/PerformanceTidyModule.cpp
docs/ReleaseNotes.rst
docs/clang-tidy/checks/list.rst
docs/clang-tidy/checks/performance-inefficient-string-concatenation.rst
test/clang-tidy/performance-inefficient-string-concatenation.cpp
Index: test/clang-tidy/performance-inefficient-string-concatenation.cpp
===
--- /dev/null
+++ test/clang-tidy/performance-inefficient-string-concatenation.cpp
@@ -0,0 +1,44 @@
+// RUN: %check_clang_tidy %s performance-inefficient-string-concatenation %t
+
+namespace std {
+template
+class basic_string {
+public:
+ basic_string() {}
+ ~basic_string() {}
+ basic_string *operator+=(const basic_string &) {}
+ friend basic_string operator+(const basic_string &, const basic_string &) {}
+};
+typedef basic_string string;
+typedef basic_string wstring;
+}
+
+void f(std::string) {}
+std::string g(std::string) {}
+
+int main() {
+ std::string mystr1, mystr2;
+ std::wstring mywstr1, mywstr2;
+
+ for (int i = 0; i < 10; ++i) {
+f(mystr1 + mystr2 + mystr1);
+// CHECK-MESSAGES: :[[@LINE-1]]:23: warning: string concatenation results in allocation of unnecessary temporary strings; consider using 'operator+=' or 'string::append()' instead
+mystr1 = mystr1 + mystr2;
+// CHECK-MESSAGES: :[[@LINE-1]]:5: warning: string concatenation
+mystr1 = mystr2 + mystr2 + mystr2;
+// CHECK-MESSAGES: :[[@LINE-1]]:30: warning: string concatenation
+mystr1 = mystr2 + mystr1;
+// CHECK-MESSAGES: :[[@LINE-1]]:5: warning: string concatenation
+mywstr1 = mywstr2 + mywstr1;
+// CHECK-MESSAGES: :[[@LINE-1]]:5: warning: string concatenation
+mywstr1 = mywstr2 + mywstr2 + mywstr2;
+// CHECK-MESSAGES: :[[@LINE-1]]:33: warning: string concatenation
+
+mywstr1 = mywstr2 + mywstr2;
+mystr1 = mystr2 + mystr2;
+mystr1 += mystr2;
+f(mystr2 + mystr1);
+mystr1 = g(mystr1);
+ }
+ return 0;
+}
Index: docs/clang-tidy/checks/performance-inefficient-string-concatenation.rst
===
--- /dev/null
+++ docs/clang-tidy/checks/performance-inefficient-string-concatenation.rst
@@ -0,0 +1,49 @@
+.. title:: clang-tidy - performance-inefficient-string-concatenation
+
+performance-inefficient-string-concatenation
+
+
+This check warns about the performance overhead arising from concatenating strings using the ``operator+``, for instance:
+
+.. code:: c++
+
+std::string a("Foo"), b("Bar");
+a = a + b;
+
+Instead of this structure you should use ``operator+=`` or ``std::string``'s (``std::basic_string``) class member function ``append()``. For instance:
+
+.. code:: c++
+
+ std::string a("Foo"), b("Baz");
+ for (int i = 0; i < 2; ++i) {
+ a = a + "Bar" + b;
+ }
+
+Could be rewritten in a greatly more efficient way like:
+
+.. code:: c++
+
+ std::string a("Foo"), b("Baz");
+ for (int i = 0; i < 2; ++i) {
+ a.append("Bar").append(b);
+ }
+
+And this can be rewritten too:
+
+.. code:: c++
+
+ void f(const std::string&) {}
+ std::string a("Foo"), b("Baz");
+ void g() {
+ f(a + "Bar" + b);
+ }
+
+In a slightly more efficient way like:
+
+.. code:: c++
+
+ void f(const std::string&) {}
+ std::string a("Foo"), b("Baz");
+ void g() {
+ f(std::string(a).append("Bar").append(b));
+ }
Index: docs/clang-tidy/checks/list.rst
===
--- docs/clang-tidy/checks/list.rst
+++ docs/clang-tidy/checks/list.rst
@@ -102,6 +102,7 @@
performance-faster-string-find
performance-for-range-copy
performance-implicit-cast-in-loop
+ performance-inefficient-string-concatenation
performance-unnecessary-copy-initialization
performance-unnecessary-value-param
readability-avoid-const-params-in-decls
Index: docs/ReleaseNotes.rst
===
--- docs/ReleaseNotes.rst
+++ docs/ReleaseNotes.rst
@@ -184,6 +184,12 @@
Warns about range-based loop with a loop variable of const ref type where the
type of the variable does not match the one returned by the iterator.
+- New `performance-inefficient-string-concatenation
+ `_ check
+
+ This check is to warn about the performance overhead arising from concatenating
+ strings, using the ``operator+``, instead of ``operator+=``.
+
- New `performance-unnecessary-value-param
`_ check
Index: clang-tidy/performance/Performa
Re: [PATCH] D20196: [clang-tidy] Inefficient string operation
bittnerbarni updated this revision to Diff 66492.
https://reviews.llvm.org/D20196
Files:
clang-tidy/performance/CMakeLists.txt
clang-tidy/performance/InefficientStringConcatenationCheck.cpp
clang-tidy/performance/InefficientStringConcatenationCheck.h
clang-tidy/performance/PerformanceTidyModule.cpp
docs/ReleaseNotes.rst
docs/clang-tidy/checks/list.rst
docs/clang-tidy/checks/performance-inefficient-string-concatenation.rst
test/clang-tidy/performance-inefficient-string-concatenation.cpp
Index: test/clang-tidy/performance-inefficient-string-concatenation.cpp
===
--- /dev/null
+++ test/clang-tidy/performance-inefficient-string-concatenation.cpp
@@ -0,0 +1,44 @@
+// RUN: %check_clang_tidy %s performance-inefficient-string-concatenation %t
+
+namespace std {
+template
+class basic_string {
+public:
+ basic_string() {}
+ ~basic_string() {}
+ basic_string *operator+=(const basic_string &) {}
+ friend basic_string operator+(const basic_string &, const basic_string &) {}
+};
+typedef basic_string string;
+typedef basic_string wstring;
+}
+
+void f(std::string) {}
+std::string g(std::string) {}
+
+int main() {
+ std::string mystr1, mystr2;
+ std::wstring mywstr1, mywstr2;
+
+ for (int i = 0; i < 10; ++i) {
+f(mystr1 + mystr2 + mystr1);
+// CHECK-MESSAGES: :[[@LINE-1]]:23: warning: string concatenation results in allocation of unnecessary temporary strings; consider using 'operator+=' or 'string::append()' instead
+mystr1 = mystr1 + mystr2;
+// CHECK-MESSAGES: :[[@LINE-1]]:5: warning: string concatenation
+mystr1 = mystr2 + mystr2 + mystr2;
+// CHECK-MESSAGES: :[[@LINE-1]]:30: warning: string concatenation
+mystr1 = mystr2 + mystr1;
+// CHECK-MESSAGES: :[[@LINE-1]]:5: warning: string concatenation
+mywstr1 = mywstr2 + mywstr1;
+// CHECK-MESSAGES: :[[@LINE-1]]:5: warning: string concatenation
+mywstr1 = mywstr2 + mywstr2 + mywstr2;
+// CHECK-MESSAGES: :[[@LINE-1]]:33: warning: string concatenation
+
+mywstr1 = mywstr2 + mywstr2;
+mystr1 = mystr2 + mystr2;
+mystr1 += mystr2;
+f(mystr2 + mystr1);
+mystr1 = g(mystr1);
+ }
+ return 0;
+}
Index: docs/clang-tidy/checks/performance-inefficient-string-concatenation.rst
===
--- /dev/null
+++ docs/clang-tidy/checks/performance-inefficient-string-concatenation.rst
@@ -0,0 +1,49 @@
+.. title:: clang-tidy - performance-inefficient-string-concatenation
+
+performance-inefficient-string-concatenation
+
+
+This check warns about the performance overhead arising from concatenating strings using the ``operator+``, for instance:
+
+.. code:: c++
+
+std::string a("Foo"), b("Bar");
+a = a + b;
+
+Instead of this structure you should use ``operator+=`` or ``std::string``'s (``std::basic_string``) class member function ``append()``. For instance:
+
+.. code:: c++
+
+ std::string a("Foo"), b("Baz");
+ for (int i = 0; i < 2; ++i) {
+ a = a + "Bar" + b;
+ }
+
+Could be rewritten in a greatly more efficient way like:
+
+.. code:: c++
+
+ std::string a("Foo"), b("Baz");
+ for (int i = 0; i < 2; ++i) {
+ a.append("Bar").append(b);
+ }
+
+And this can be rewritten too:
+
+.. code:: c++
+
+ void f(const std::string&) {}
+ std::string a("Foo"), b("Baz");
+ void g() {
+ f(a + "Bar" + b);
+ }
+
+In a slightly more efficient way like:
+
+.. code:: c++
+
+ void f(const std::string&) {}
+ std::string a("Foo"), b("Baz");
+ void g() {
+ f(std::string(a).append("Bar").append(b));
+ }
Index: docs/clang-tidy/checks/list.rst
===
--- docs/clang-tidy/checks/list.rst
+++ docs/clang-tidy/checks/list.rst
@@ -102,6 +102,7 @@
performance-faster-string-find
performance-for-range-copy
performance-implicit-cast-in-loop
+ performance-inefficient-string-concatenation
performance-unnecessary-copy-initialization
performance-unnecessary-value-param
readability-avoid-const-params-in-decls
Index: docs/ReleaseNotes.rst
===
--- docs/ReleaseNotes.rst
+++ docs/ReleaseNotes.rst
@@ -184,6 +184,12 @@
Warns about range-based loop with a loop variable of const ref type where the
type of the variable does not match the one returned by the iterator.
+- New `performance-inefficient-string-concatenation
+ `_ check
+
+ This check is to warn about the performance overhead arising from concatenating
+ strings, using the ``operator+``, instead of ``operator+=``.
+
- New `performance-unnecessary-value-param
`_ check
Index: clang-tidy/performance/Performa
Re: [PATCH] D20196: [clang-tidy] Inefficient string operation
bittnerbarni marked 14 inline comments as done. bittnerbarni added a comment. https://reviews.llvm.org/D20196 ___ cfe-commits mailing list cfe-commits@lists.llvm.org http://lists.llvm.org/cgi-bin/mailman/listinfo/cfe-commits
Re: [PATCH] D20196: [clang-tidy] Inefficient string operation
bittnerbarni added a comment. Thank you for all the assistance. Could you please do that? https://reviews.llvm.org/D20196 ___ cfe-commits mailing list cfe-commits@lists.llvm.org http://lists.llvm.org/cgi-bin/mailman/listinfo/cfe-commits
Re: [PATCH] D20196: [clang-tidy] Inefficient string operation
bittnerbarni added a comment. I'm planning to submit more patches in the future, as I have time for them. So it wouldn't be in vain :) https://reviews.llvm.org/D20196 ___ cfe-commits mailing list cfe-commits@lists.llvm.org http://lists.llvm.org/cgi-bin/mailman/listinfo/cfe-commits
Re: [PATCH] D20196: [clang-tidy] Inefficient string operation
bittnerbarni updated this revision to Diff 57172.
http://reviews.llvm.org/D20196
Files:
clang-tidy/performance/InefficientStringAdditionCheck.cpp
docs/ReleaseNotes.rst
docs/clang-tidy/checks/performance-inefficient-string-addition.rst
test/clang-tidy/performance-inefficient-string-addition.cpp
Index: test/clang-tidy/performance-inefficient-string-addition.cpp
===
--- test/clang-tidy/performance-inefficient-string-addition.cpp
+++ test/clang-tidy/performance-inefficient-string-addition.cpp
@@ -1,4 +1,4 @@
-// RUN: %check_clang_tidy %s performance-inefficient-string-addition %t -- -- -std=c++11
+// RUN: %check_clang_tidy %s performance-inefficient-string-addition %t
namespace std {
template
@@ -24,11 +24,11 @@
f(mystr1 + mystr2 + mystr1);
// CHECK-MESSAGES: :[[@LINE-1]]:23: warning: Inefficient string concatenation
mystr1 = mystr1 + mystr2;
-// CHECK-MESSAGES: :[[@LINE-1]]:2: warning: Ineff
+// CHECK-MESSAGES: :[[@LINE-1]]:5: warning: Ineff
mystr1 = mystr2 + mystr2 + mystr2;
-// CHECK-MESSAGES: :[[@LINE-1]]:27: warning: Ineff
+// CHECK-MESSAGES: :[[@LINE-1]]:30: warning: Ineff
mystr1 = mystr2 + mystr1;
-// CHECK-MESSAGES: :[[@LINE-1]]:2: warning: Ineff
+// CHECK-MESSAGES: :[[@LINE-1]]:5: warning: Ineff
mywstr1 = mywstr2 + mywstr1;
// CHECK-MESSAGES: :[[@LINE-1]]:5: warning: Ineff
mywstr1 = mywstr2 + mywstr2 + mywstr2;
@@ -41,4 +41,4 @@
mystr1 = g(mystr1);
}
return 0;
-}
\ No newline at end of file
+}
Index: docs/clang-tidy/checks/performance-inefficient-string-addition.rst
===
--- docs/clang-tidy/checks/performance-inefficient-string-addition.rst
+++ docs/clang-tidy/checks/performance-inefficient-string-addition.rst
@@ -1,24 +1,22 @@
.. title:: clang-tidy - performance-inefficient-string-addition
performance-inefficient-string-addition
-=
+===
The problem
---
+---
This check is to warn about the performance overhead arising from concatenating strings, using the operator+, for instance:
.. code:: c++
-
-std::string a = "Foo", b = "Bar";
+std::string a("Foo"), b("Bar");
a = a + b;
-Instead of this structure you should use **operator+=** or std::string's (std::basic_string) class member function **append**. For instance:
+Instead of this structure you should use `operator+=` or std::string's (std::basic_string) class member function `append`. For instance:
.. code:: c++
-
- std::string a = "Foo", b = "Baz";
+ std::string a("Foo"), b("Baz");
for(int i = 0; i < 2; ++i)
{
a = a + "Bar" + b;
@@ -28,7 +26,7 @@
.. code:: c++
- std::string a = "Foo", b = "Baz";
+ std::string a("Foo"), b("Baz");
for(int i = 0; i < 2; ++i)
{
a.append("Bar").append(b);
@@ -39,19 +37,19 @@
.. code:: c++
void f(const std::string&){}
- std::string a = "Foo", b = "Baz";
+ std::string a("Foo"), b("Baz");
void g()
{
- f(a+"Bar"+b);
+ f(a + "Bar" + b);
}
In a slightly more efficient way like:
.. code:: c++
void f(const std::string&){}
- std::string a = "Foo", b = "Baz";
+ std::string a("Foo"), b("Baz");
void g()
{
f(std::string(a).append("Bar").append(b));
- }
\ No newline at end of file
+ }
Index: docs/ReleaseNotes.rst
===
--- docs/ReleaseNotes.rst
+++ docs/ReleaseNotes.rst
@@ -184,6 +184,12 @@
Warns about range-based loop with a loop variable of const ref type where the
type of the variable does not match the one returned by the iterator.
+- New `performance-inefficient-string-addition
+ `_ check
+
+ This check is to warn about the performance overhead arising from concatenating
+ strings, using the operator+, instead of operator+=.
+
- New `performance-unnecessary-value-param
`_ check
Index: clang-tidy/performance/InefficientStringAdditionCheck.cpp
===
--- clang-tidy/performance/InefficientStringAdditionCheck.cpp
+++ clang-tidy/performance/InefficientStringAdditionCheck.cpp
@@ -28,22 +28,22 @@
IsStrictMode(Options.get("isStrictMode", 0)) {}
void InefficientStringAdditionCheck::registerMatchers(MatchFinder *Finder) {
- auto BasicStringType = hasType(cxxRecordDecl(hasName("::std::basic_string")));
+ const auto BasicStringType = hasType(cxxRecordDecl(hasName("::std::basic_string")));
- auto BasicStringPlusOperator =
+ const auto BasicStringPlusOperator =
cxxOperatorCallExpr(hasAnyArgument(ignoringImpCasts(declRefExpr(Bas
Re: [PATCH] D20196: [clang-tidy] Inefficient string operation
bittnerbarni updated this revision to Diff 57185. http://reviews.llvm.org/D20196 Files: docs/clang-tidy/checks/performance-inefficient-string-addition.rst Index: docs/clang-tidy/checks/performance-inefficient-string-addition.rst === --- docs/clang-tidy/checks/performance-inefficient-string-addition.rst +++ docs/clang-tidy/checks/performance-inefficient-string-addition.rst @@ -5,7 +5,7 @@ The problem --- -This check is to warn about the performance overhead arising from concatenating strings, using the operator+, for instance: +This check is to warn about the performance overhead arising from concatenating strings, using the ``operator+``, for instance: .. code:: c++ Index: docs/clang-tidy/checks/performance-inefficient-string-addition.rst === --- docs/clang-tidy/checks/performance-inefficient-string-addition.rst +++ docs/clang-tidy/checks/performance-inefficient-string-addition.rst @@ -5,7 +5,7 @@ The problem --- -This check is to warn about the performance overhead arising from concatenating strings, using the operator+, for instance: +This check is to warn about the performance overhead arising from concatenating strings, using the ``operator+``, for instance: .. code:: c++ ___ cfe-commits mailing list cfe-commits@lists.llvm.org http://lists.llvm.org/cgi-bin/mailman/listinfo/cfe-commits
Re: [PATCH] D20196: [clang-tidy] Inefficient string operation
bittnerbarni updated this revision to Diff 57181.
http://reviews.llvm.org/D20196
Files:
docs/clang-tidy/checks/performance-inefficient-string-addition.rst
Index: docs/clang-tidy/checks/performance-inefficient-string-addition.rst
===
--- docs/clang-tidy/checks/performance-inefficient-string-addition.rst
+++ docs/clang-tidy/checks/performance-inefficient-string-addition.rst
@@ -12,7 +12,7 @@
std::string a("Foo"), b("Bar");
a = a + b;
-Instead of this structure you should use `operator+=` or std::string's
(std::basic_string) class member function `append`. For instance:
+Instead of this structure you should use ``operator+=`` or std::string's
(std::basic_string) class member function ``append``. For instance:
.. code:: c++
Index: docs/clang-tidy/checks/performance-inefficient-string-addition.rst
===
--- docs/clang-tidy/checks/performance-inefficient-string-addition.rst
+++ docs/clang-tidy/checks/performance-inefficient-string-addition.rst
@@ -12,7 +12,7 @@
std::string a("Foo"), b("Bar");
a = a + b;
-Instead of this structure you should use `operator+=` or std::string's (std::basic_string) class member function `append`. For instance:
+Instead of this structure you should use ``operator+=`` or std::string's (std::basic_string) class member function ``append``. For instance:
.. code:: c++
___
cfe-commits mailing list
cfe-commits@lists.llvm.org
http://lists.llvm.org/cgi-bin/mailman/listinfo/cfe-commits
Re: [PATCH] D20196: [clang-tidy] Inefficient string operation
bittnerbarni updated this revision to Diff 57294.
bittnerbarni added a comment.
Sorry for uploading 2 line long diffs. I uploaded the whole diff now.
http://reviews.llvm.org/D20196
Files:
clang-tidy/performance/CMakeLists.txt
clang-tidy/performance/InefficientStringAdditionCheck.cpp
clang-tidy/performance/InefficientStringAdditionCheck.h
clang-tidy/performance/PerformanceTidyModule.cpp
docs/ReleaseNotes.rst
docs/clang-tidy/checks/list.rst
docs/clang-tidy/checks/performance-inefficient-string-addition.rst
test/clang-tidy/performance-inefficient-string-addition.cpp
Index: test/clang-tidy/performance-inefficient-string-addition.cpp
===
--- /dev/null
+++ test/clang-tidy/performance-inefficient-string-addition.cpp
@@ -0,0 +1,44 @@
+// RUN: %check_clang_tidy %s performance-inefficient-string-addition %t
+
+namespace std {
+template
+class basic_string {
+public:
+ basic_string() {}
+ ~basic_string() {}
+ basic_string *operator+=(const basic_string &) {}
+ friend basic_string operator+(const basic_string &, const basic_string &) {}
+};
+typedef basic_string string;
+typedef basic_string wstring;
+}
+
+void f(std::string) {}
+std::string g(std::string) {}
+
+int main() {
+ std::string mystr1, mystr2;
+ std::wstring mywstr1, mywstr2;
+
+ for (int i = 0; i < 10; ++i) {
+f(mystr1 + mystr2 + mystr1);
+// CHECK-MESSAGES: :[[@LINE-1]]:23: warning: Inefficient string concatenation
+mystr1 = mystr1 + mystr2;
+// CHECK-MESSAGES: :[[@LINE-1]]:5: warning: Ineff
+mystr1 = mystr2 + mystr2 + mystr2;
+// CHECK-MESSAGES: :[[@LINE-1]]:30: warning: Ineff
+mystr1 = mystr2 + mystr1;
+// CHECK-MESSAGES: :[[@LINE-1]]:5: warning: Ineff
+mywstr1 = mywstr2 + mywstr1;
+// CHECK-MESSAGES: :[[@LINE-1]]:5: warning: Ineff
+mywstr1 = mywstr2 + mywstr2 + mywstr2;
+// CHECK-MESSAGES: :[[@LINE-1]]:33: warning: Ineff
+
+mywstr1 = mywstr2 + mywstr2;
+mystr1 = mystr2 + mystr2;
+mystr1 += mystr2;
+f(mystr2 + mystr1);
+mystr1 = g(mystr1);
+ }
+ return 0;
+}
Index: docs/clang-tidy/checks/performance-inefficient-string-addition.rst
===
--- /dev/null
+++ docs/clang-tidy/checks/performance-inefficient-string-addition.rst
@@ -0,0 +1,55 @@
+.. title:: clang-tidy - performance-inefficient-string-addition
+
+performance-inefficient-string-addition
+===
+
+The problem
+---
+This check is to warn about the performance overhead arising from concatenating strings, using the ``operator+``, for instance:
+
+.. code:: c++
+
+std::string a("Foo"), b("Bar");
+a = a + b;
+
+Instead of this structure you should use ``operator+=`` or std::string's (std::basic_string) class member function ``append``. For instance:
+
+.. code:: c++
+
+ std::string a("Foo"), b("Baz");
+ for(int i = 0; i < 2; ++i)
+ {
+ a = a + "Bar" + b;
+ }
+
+Could be rewritten in a greatly more efficient way like:
+
+.. code:: c++
+
+ std::string a("Foo"), b("Baz");
+ for(int i = 0; i < 2; ++i)
+ {
+ a.append("Bar").append(b);
+ }
+
+And this can be rewritten too:
+
+ .. code:: c++
+
+ void f(const std::string&){}
+ std::string a("Foo"), b("Baz");
+ void g()
+ {
+ f(a + "Bar" + b);
+ }
+
+In a slightly more efficient way like:
+
+.. code:: c++
+
+ void f(const std::string&){}
+ std::string a("Foo"), b("Baz");
+ void g()
+ {
+ f(std::string(a).append("Bar").append(b));
+ }
Index: docs/clang-tidy/checks/list.rst
===
--- docs/clang-tidy/checks/list.rst
+++ docs/clang-tidy/checks/list.rst
@@ -102,6 +102,7 @@
performance-faster-string-find
performance-for-range-copy
performance-implicit-cast-in-loop
+ performance-inefficient-string-addition
performance-unnecessary-copy-initialization
performance-unnecessary-value-param
readability-avoid-const-params-in-decls
Index: docs/ReleaseNotes.rst
===
--- docs/ReleaseNotes.rst
+++ docs/ReleaseNotes.rst
@@ -184,6 +184,12 @@
Warns about range-based loop with a loop variable of const ref type where the
type of the variable does not match the one returned by the iterator.
+- New `performance-inefficient-string-addition
+ `_ check
+
+ This check is to warn about the performance overhead arising from concatenating
+ strings, using the operator+, instead of operator+=.
+
- New `performance-unnecessary-value-param
`_ check
Index: clang-tidy/performance/PerformanceTidyModule.cpp
===
--- clang-tidy/performance/Performa
Re: [PATCH] D20196: [clang-tidy] Inefficient string operation
bittnerbarni updated this revision to Diff 57346.
http://reviews.llvm.org/D20196
Files:
clang-tidy/performance/CMakeLists.txt
clang-tidy/performance/InefficientStringAdditionCheck.cpp
clang-tidy/performance/InefficientStringAdditionCheck.h
clang-tidy/performance/PerformanceTidyModule.cpp
docs/ReleaseNotes.rst
docs/clang-tidy/checks/list.rst
docs/clang-tidy/checks/performance-inefficient-string-addition.rst
test/clang-tidy/performance-inefficient-string-addition.cpp
Index: test/clang-tidy/performance-inefficient-string-addition.cpp
===
--- /dev/null
+++ test/clang-tidy/performance-inefficient-string-addition.cpp
@@ -0,0 +1,44 @@
+// RUN: %check_clang_tidy %s performance-inefficient-string-addition %t
+
+namespace std {
+template
+class basic_string {
+public:
+ basic_string() {}
+ ~basic_string() {}
+ basic_string *operator+=(const basic_string &) {}
+ friend basic_string operator+(const basic_string &, const basic_string &) {}
+};
+typedef basic_string string;
+typedef basic_string wstring;
+}
+
+void f(std::string) {}
+std::string g(std::string) {}
+
+int main() {
+ std::string mystr1, mystr2;
+ std::wstring mywstr1, mywstr2;
+
+ for (int i = 0; i < 10; ++i) {
+f(mystr1 + mystr2 + mystr1);
+// CHECK-MESSAGES: :[[@LINE-1]]:23: warning: Inefficient string concatenation
+mystr1 = mystr1 + mystr2;
+// CHECK-MESSAGES: :[[@LINE-1]]:5: warning: Ineff
+mystr1 = mystr2 + mystr2 + mystr2;
+// CHECK-MESSAGES: :[[@LINE-1]]:30: warning: Ineff
+mystr1 = mystr2 + mystr1;
+// CHECK-MESSAGES: :[[@LINE-1]]:5: warning: Ineff
+mywstr1 = mywstr2 + mywstr1;
+// CHECK-MESSAGES: :[[@LINE-1]]:5: warning: Ineff
+mywstr1 = mywstr2 + mywstr2 + mywstr2;
+// CHECK-MESSAGES: :[[@LINE-1]]:33: warning: Ineff
+
+mywstr1 = mywstr2 + mywstr2;
+mystr1 = mystr2 + mystr2;
+mystr1 += mystr2;
+f(mystr2 + mystr1);
+mystr1 = g(mystr1);
+ }
+ return 0;
+}
Index: docs/clang-tidy/checks/performance-inefficient-string-addition.rst
===
--- /dev/null
+++ docs/clang-tidy/checks/performance-inefficient-string-addition.rst
@@ -0,0 +1,55 @@
+.. title:: clang-tidy - performance-inefficient-string-addition
+
+performance-inefficient-string-addition
+===
+
+The problem
+---
+This check is to warn about the performance overhead arising from concatenating strings, using the ``operator+``, for instance:
+
+.. code:: c++
+
+std::string a("Foo"), b("Bar");
+a = a + b;
+
+Instead of this structure you should use ``operator+=`` or std::string's (std::basic_string) class member function ``append``. For instance:
+
+.. code:: c++
+
+ std::string a("Foo"), b("Baz");
+ for(int i = 0; i < 2; ++i)
+ {
+ a = a + "Bar" + b;
+ }
+
+Could be rewritten in a greatly more efficient way like:
+
+.. code:: c++
+
+ std::string a("Foo"), b("Baz");
+ for(int i = 0; i < 2; ++i)
+ {
+ a.append("Bar").append(b);
+ }
+
+And this can be rewritten too:
+
+ .. code:: c++
+
+ void f(const std::string&){}
+ std::string a("Foo"), b("Baz");
+ void g()
+ {
+ f(a + "Bar" + b);
+ }
+
+In a slightly more efficient way like:
+
+.. code:: c++
+
+ void f(const std::string&){}
+ std::string a("Foo"), b("Baz");
+ void g()
+ {
+ f(std::string(a).append("Bar").append(b));
+ }
Index: docs/clang-tidy/checks/list.rst
===
--- docs/clang-tidy/checks/list.rst
+++ docs/clang-tidy/checks/list.rst
@@ -102,6 +102,7 @@
performance-faster-string-find
performance-for-range-copy
performance-implicit-cast-in-loop
+ performance-inefficient-string-addition
performance-unnecessary-copy-initialization
performance-unnecessary-value-param
readability-avoid-const-params-in-decls
Index: docs/ReleaseNotes.rst
===
--- docs/ReleaseNotes.rst
+++ docs/ReleaseNotes.rst
@@ -184,6 +184,12 @@
Warns about range-based loop with a loop variable of const ref type where the
type of the variable does not match the one returned by the iterator.
+- New `performance-inefficient-string-addition
+ `_ check
+
+ This check is to warn about the performance overhead arising from concatenating
+ strings, using the operator+, instead of operator+=.
+
- New `performance-unnecessary-value-param
`_ check
Index: clang-tidy/performance/PerformanceTidyModule.cpp
===
--- clang-tidy/performance/PerformanceTidyModule.cpp
+++ clang-tidy/performance/PerformanceTidyModule.cpp
@@ -10,6 +10,7 @@
#include "..
Re: [PATCH] D20196: [clang-tidy] Inefficient string operation
bittnerbarni updated this revision to Diff 57894.
http://reviews.llvm.org/D20196
Files:
clang-tidy/performance/CMakeLists.txt
clang-tidy/performance/InefficientStringAdditionCheck.cpp
clang-tidy/performance/InefficientStringAdditionCheck.h
clang-tidy/performance/PerformanceTidyModule.cpp
docs/ReleaseNotes.rst
docs/clang-tidy/checks/list.rst
docs/clang-tidy/checks/performance-inefficient-string-addition.rst
test/clang-tidy/performance-inefficient-string-addition.cpp
Index: test/clang-tidy/performance-inefficient-string-addition.cpp
===
--- /dev/null
+++ test/clang-tidy/performance-inefficient-string-addition.cpp
@@ -0,0 +1,44 @@
+// RUN: %check_clang_tidy %s performance-inefficient-string-addition %t
+
+namespace std {
+template
+class basic_string {
+public:
+ basic_string() {}
+ ~basic_string() {}
+ basic_string *operator+=(const basic_string &) {}
+ friend basic_string operator+(const basic_string &, const basic_string &) {}
+};
+typedef basic_string string;
+typedef basic_string wstring;
+}
+
+void f(std::string) {}
+std::string g(std::string) {}
+
+int main() {
+ std::string mystr1, mystr2;
+ std::wstring mywstr1, mywstr2;
+
+ for (int i = 0; i < 10; ++i) {
+f(mystr1 + mystr2 + mystr1);
+// CHECK-MESSAGES: :[[@LINE-1]]:23: warning: inefficient string concatenation
+mystr1 = mystr1 + mystr2;
+// CHECK-MESSAGES: :[[@LINE-1]]:5: warning: ineff
+mystr1 = mystr2 + mystr2 + mystr2;
+// CHECK-MESSAGES: :[[@LINE-1]]:30: warning: ineff
+mystr1 = mystr2 + mystr1;
+// CHECK-MESSAGES: :[[@LINE-1]]:5: warning: ineff
+mywstr1 = mywstr2 + mywstr1;
+// CHECK-MESSAGES: :[[@LINE-1]]:5: warning: ineff
+mywstr1 = mywstr2 + mywstr2 + mywstr2;
+// CHECK-MESSAGES: :[[@LINE-1]]:33: warning: ineff
+
+mywstr1 = mywstr2 + mywstr2;
+mystr1 = mystr2 + mystr2;
+mystr1 += mystr2;
+f(mystr2 + mystr1);
+mystr1 = g(mystr1);
+ }
+ return 0;
+}
Index: docs/clang-tidy/checks/performance-inefficient-string-addition.rst
===
--- /dev/null
+++ docs/clang-tidy/checks/performance-inefficient-string-addition.rst
@@ -0,0 +1,55 @@
+.. title:: clang-tidy - performance-inefficient-string-addition
+
+performance-inefficient-string-addition
+===
+
+The problem
+---
+This check is to warn about the performance overhead arising from concatenating strings, using the ``operator+``, for instance:
+
+.. code:: c++
+
+std::string a("Foo"), b("Bar");
+a = a + b;
+
+Instead of this structure you should use ``operator+=`` or std::string's (std::basic_string) class member function ``append``. For instance:
+
+.. code:: c++
+
+ std::string a("Foo"), b("Baz");
+ for(int i = 0; i < 2; ++i)
+ {
+ a = a + "Bar" + b;
+ }
+
+Could be rewritten in a greatly more efficient way like:
+
+.. code:: c++
+
+ std::string a("Foo"), b("Baz");
+ for(int i = 0; i < 2; ++i)
+ {
+ a.append("Bar").append(b);
+ }
+
+And this can be rewritten too:
+
+ .. code:: c++
+
+ void f(const std::string&){}
+ std::string a("Foo"), b("Baz");
+ void g()
+ {
+ f(a + "Bar" + b);
+ }
+
+In a slightly more efficient way like:
+
+.. code:: c++
+
+ void f(const std::string&){}
+ std::string a("Foo"), b("Baz");
+ void g()
+ {
+ f(std::string(a).append("Bar").append(b));
+ }
Index: docs/clang-tidy/checks/list.rst
===
--- docs/clang-tidy/checks/list.rst
+++ docs/clang-tidy/checks/list.rst
@@ -102,6 +102,7 @@
performance-faster-string-find
performance-for-range-copy
performance-implicit-cast-in-loop
+ performance-inefficient-string-addition
performance-unnecessary-copy-initialization
performance-unnecessary-value-param
readability-avoid-const-params-in-decls
Index: docs/ReleaseNotes.rst
===
--- docs/ReleaseNotes.rst
+++ docs/ReleaseNotes.rst
@@ -184,6 +184,12 @@
Warns about range-based loop with a loop variable of const ref type where the
type of the variable does not match the one returned by the iterator.
+- New `performance-inefficient-string-addition
+ `_ check
+
+ This check is to warn about the performance overhead arising from concatenating
+ strings, using the ``operator+``, instead of ``operator+=``.
+
- New `performance-unnecessary-value-param
`_ check
Index: clang-tidy/performance/PerformanceTidyModule.cpp
===
--- clang-tidy/performance/PerformanceTidyModule.cpp
+++ clang-tidy/performance/PerformanceTidyModule.cpp
@@ -10,6 +10,7 @@
#inc
Re: [PATCH] D20196: [clang-tidy] Inefficient string operation
bittnerbarni updated this revision to Diff 58054.
http://reviews.llvm.org/D20196
Files:
clang-tidy/performance/CMakeLists.txt
clang-tidy/performance/InefficientStringConcatenationCheck.cpp
clang-tidy/performance/InefficientStringConcatenationCheck.h
clang-tidy/performance/PerformanceTidyModule.cpp
docs/ReleaseNotes.rst
docs/clang-tidy/checks/list.rst
docs/clang-tidy/checks/performance-inefficient-string-concatenation.rst
test/clang-tidy/performance-inefficient-string-concatenation.cpp
Index: test/clang-tidy/performance-inefficient-string-concatenation.cpp
===
--- /dev/null
+++ test/clang-tidy/performance-inefficient-string-concatenation.cpp
@@ -0,0 +1,44 @@
+// RUN: %check_clang_tidy %s performance-inefficient-string-concatenation %t
+
+namespace std {
+template
+class basic_string {
+public:
+ basic_string() {}
+ ~basic_string() {}
+ basic_string *operator+=(const basic_string &) {}
+ friend basic_string operator+(const basic_string &, const basic_string &) {}
+};
+typedef basic_string string;
+typedef basic_string wstring;
+}
+
+void f(std::string) {}
+std::string g(std::string) {}
+
+int main() {
+ std::string mystr1, mystr2;
+ std::wstring mywstr1, mywstr2;
+
+ for (int i = 0; i < 10; ++i) {
+f(mystr1 + mystr2 + mystr1);
+// CHECK-MESSAGES: :[[@LINE-1]]:23: warning: string concatenation results in allocation of unnecessary temporary strings; consider using 'operator+=' or 'string::append()' instead
+mystr1 = mystr1 + mystr2;
+// CHECK-MESSAGES: :[[@LINE-1]]:5: warning: string concatenation
+mystr1 = mystr2 + mystr2 + mystr2;
+// CHECK-MESSAGES: :[[@LINE-1]]:30: warning: string concatenation
+mystr1 = mystr2 + mystr1;
+// CHECK-MESSAGES: :[[@LINE-1]]:5: warning: string concatenation
+mywstr1 = mywstr2 + mywstr1;
+// CHECK-MESSAGES: :[[@LINE-1]]:5: warning: string concatenation
+mywstr1 = mywstr2 + mywstr2 + mywstr2;
+// CHECK-MESSAGES: :[[@LINE-1]]:33: warning: string concatenation
+
+mywstr1 = mywstr2 + mywstr2;
+mystr1 = mystr2 + mystr2;
+mystr1 += mystr2;
+f(mystr2 + mystr1);
+mystr1 = g(mystr1);
+ }
+ return 0;
+}
Index: docs/clang-tidy/checks/performance-inefficient-string-concatenation.rst
===
--- /dev/null
+++ docs/clang-tidy/checks/performance-inefficient-string-concatenation.rst
@@ -0,0 +1,55 @@
+.. title:: clang-tidy - performance-inefficient-string-concatenation
+
+performance-inefficient-string-concatenation
+
+
+The problem
+---
+This check is to warn about the performance overhead arising from concatenating strings, using the ``operator+``, for instance:
+
+.. code:: c++
+
+std::string a("Foo"), b("Bar");
+a = a + b;
+
+Instead of this structure you should use ``operator+=`` or ``std::string``'s (``std::basic_string``) class member function ``append()``. For instance:
+
+.. code:: c++
+
+ std::string a("Foo"), b("Baz");
+ for(int i = 0; i < 2; ++i)
+ {
+ a = a + "Bar" + b;
+ }
+
+Could be rewritten in a greatly more efficient way like:
+
+.. code:: c++
+
+ std::string a("Foo"), b("Baz");
+ for(int i = 0; i < 2; ++i)
+ {
+ a.append("Bar").append(b);
+ }
+
+And this can be rewritten too:
+
+ .. code:: c++
+
+ void f(const std::string&){}
+ std::string a("Foo"), b("Baz");
+ void g()
+ {
+ f(a + "Bar" + b);
+ }
+
+In a slightly more efficient way like:
+
+.. code:: c++
+
+ void f(const std::string&){}
+ std::string a("Foo"), b("Baz");
+ void g()
+ {
+ f(std::string(a).append("Bar").append(b));
+ }
Index: docs/clang-tidy/checks/list.rst
===
--- docs/clang-tidy/checks/list.rst
+++ docs/clang-tidy/checks/list.rst
@@ -102,6 +102,7 @@
performance-faster-string-find
performance-for-range-copy
performance-implicit-cast-in-loop
+ performance-inefficient-string-concatenation
performance-unnecessary-copy-initialization
performance-unnecessary-value-param
readability-avoid-const-params-in-decls
Index: docs/ReleaseNotes.rst
===
--- docs/ReleaseNotes.rst
+++ docs/ReleaseNotes.rst
@@ -184,6 +184,12 @@
Warns about range-based loop with a loop variable of const ref type where the
type of the variable does not match the one returned by the iterator.
+- New `performance-inefficient-string-concatenation
+ `_ check
+
+ This check is to warn about the performance overhead arising from concatenating
+ strings, using the ``operator+``, instead of ``operator+=``.
+
- New `performance-unnecessary-value-param
`_
Re: [PATCH] D20196: [clang-tidy] Inefficient string operation
bittnerbarni updated this revision to Diff 59661.
bittnerbarni marked 6 inline comments as done.
bittnerbarni added a comment.
Removed the unnecessary hasDescendant calls and simplified the checker as
suggested. Tested on LLVM codebase, with minor improvements in speed (~1%).
http://reviews.llvm.org/D20196
Files:
clang-tidy/performance/CMakeLists.txt
clang-tidy/performance/InefficientStringConcatenationCheck.cpp
clang-tidy/performance/InefficientStringConcatenationCheck.h
clang-tidy/performance/PerformanceTidyModule.cpp
docs/ReleaseNotes.rst
docs/clang-tidy/checks/list.rst
docs/clang-tidy/checks/performance-inefficient-string-concatenation.rst
test/clang-tidy/performance-inefficient-string-concatenation.cpp
Index: test/clang-tidy/performance-inefficient-string-concatenation.cpp
===
--- /dev/null
+++ test/clang-tidy/performance-inefficient-string-concatenation.cpp
@@ -0,0 +1,44 @@
+// RUN: %check_clang_tidy %s performance-inefficient-string-concatenation %t
+
+namespace std {
+template
+class basic_string {
+public:
+ basic_string() {}
+ ~basic_string() {}
+ basic_string *operator+=(const basic_string &) {}
+ friend basic_string operator+(const basic_string &, const basic_string &) {}
+};
+typedef basic_string string;
+typedef basic_string wstring;
+}
+
+void f(std::string) {}
+std::string g(std::string) {}
+
+int main() {
+ std::string mystr1, mystr2;
+ std::wstring mywstr1, mywstr2;
+
+ for (int i = 0; i < 10; ++i) {
+f(mystr1 + mystr2 + mystr1);
+// CHECK-MESSAGES: :[[@LINE-1]]:23: warning: string concatenation results in allocation of unnecessary temporary strings; consider using 'operator+=' or 'string::append()' instead
+mystr1 = mystr1 + mystr2;
+// CHECK-MESSAGES: :[[@LINE-1]]:5: warning: string concatenation
+mystr1 = mystr2 + mystr2 + mystr2;
+// CHECK-MESSAGES: :[[@LINE-1]]:30: warning: string concatenation
+mystr1 = mystr2 + mystr1;
+// CHECK-MESSAGES: :[[@LINE-1]]:5: warning: string concatenation
+mywstr1 = mywstr2 + mywstr1;
+// CHECK-MESSAGES: :[[@LINE-1]]:5: warning: string concatenation
+mywstr1 = mywstr2 + mywstr2 + mywstr2;
+// CHECK-MESSAGES: :[[@LINE-1]]:33: warning: string concatenation
+
+mywstr1 = mywstr2 + mywstr2;
+mystr1 = mystr2 + mystr2;
+mystr1 += mystr2;
+f(mystr2 + mystr1);
+mystr1 = g(mystr1);
+ }
+ return 0;
+}
Index: docs/clang-tidy/checks/performance-inefficient-string-concatenation.rst
===
--- /dev/null
+++ docs/clang-tidy/checks/performance-inefficient-string-concatenation.rst
@@ -0,0 +1,49 @@
+.. title:: clang-tidy - performance-inefficient-string-concatenation
+
+performance-inefficient-string-concatenation
+
+
+This check warns about the performance overhead arising from concatenating strings using the ``operator+``, for instance:
+
+.. code:: c++
+
+std::string a("Foo"), b("Bar");
+a = a + b;
+
+Instead of this structure you should use ``operator+=`` or ``std::string``'s (``std::basic_string``) class member function ``append()``. For instance:
+
+.. code:: c++
+
+ std::string a("Foo"), b("Baz");
+ for (int i = 0; i < 2; ++i) {
+ a = a + "Bar" + b;
+ }
+
+Could be rewritten in a greatly more efficient way like:
+
+.. code:: c++
+
+ std::string a("Foo"), b("Baz");
+ for (int i = 0; i < 2; ++i) {
+ a.append("Bar").append(b);
+ }
+
+And this can be rewritten too:
+
+.. code:: c++
+
+ void f(const std::string&) {}
+ std::string a("Foo"), b("Baz");
+ void g() {
+ f(a + "Bar" + b);
+ }
+
+In a slightly more efficient way like:
+
+.. code:: c++
+
+ void f(const std::string&) {}
+ std::string a("Foo"), b("Baz");
+ void g() {
+ f(std::string(a).append("Bar").append(b));
+ }
Index: docs/clang-tidy/checks/list.rst
===
--- docs/clang-tidy/checks/list.rst
+++ docs/clang-tidy/checks/list.rst
@@ -102,6 +102,7 @@
performance-faster-string-find
performance-for-range-copy
performance-implicit-cast-in-loop
+ performance-inefficient-string-concatenation
performance-unnecessary-copy-initialization
performance-unnecessary-value-param
readability-avoid-const-params-in-decls
Index: docs/ReleaseNotes.rst
===
--- docs/ReleaseNotes.rst
+++ docs/ReleaseNotes.rst
@@ -184,6 +184,12 @@
Warns about range-based loop with a loop variable of const ref type where the
type of the variable does not match the one returned by the iterator.
+- New `performance-inefficient-string-concatenation
+ `_ check
+
+ This check is to warn about the performance overhead arising from concatenating
+ strings, using the `
Re: [PATCH] D20196: [clang-tidy] Inefficient string operation
bittnerbarni added inline comments. Comment at: clang-tidy/performance/InefficientStringConcatenationCheck.cpp:67 @@ +66,3 @@ +Finder->addMatcher( +exprWithCleanups(anyOf(hasDescendant(AssingOperator), + hasDescendant(PlusOperatorMatcher))), alexfh wrote: > 1. The `anyOf(hasAncestor(A), hasAncestor(B), ...)` construct is still there. > Please replace it with `hasAncestor(anyOf(A, B, ...))`. > 2. Is there really no way to change from hasDescendant / hasAncestor to more > strict patterns? I believe, running the check on LLVM doesn't help finding > performance issues, since LLVM specifically avoids this pattern by using > Twine. # I was trying to write it like you suggested since the beginning, but it says it cannot deduce the template parameter that way, what's more interesting is that clang-query accepts it. # It seems to me that the assignment operator is (always?) direct child of `exprWithCleanups`, but I'm not totally sure of that. As for the + operator it could be anywhere among the children. http://reviews.llvm.org/D20196 ___ cfe-commits mailing list cfe-commits@lists.llvm.org http://lists.llvm.org/cgi-bin/mailman/listinfo/cfe-commits
Re: [PATCH] D20196: [clang-tidy] Inefficient string operation
bittnerbarni updated this revision to Diff 61893.
http://reviews.llvm.org/D20196
Files:
clang-tidy/performance/CMakeLists.txt
clang-tidy/performance/InefficientStringConcatenationCheck.cpp
clang-tidy/performance/InefficientStringConcatenationCheck.h
clang-tidy/performance/PerformanceTidyModule.cpp
docs/ReleaseNotes.rst
docs/clang-tidy/checks/list.rst
docs/clang-tidy/checks/performance-inefficient-string-concatenation.rst
test/clang-tidy/performance-inefficient-string-concatenation.cpp
Index: test/clang-tidy/performance-inefficient-string-concatenation.cpp
===
--- /dev/null
+++ test/clang-tidy/performance-inefficient-string-concatenation.cpp
@@ -0,0 +1,44 @@
+// RUN: %check_clang_tidy %s performance-inefficient-string-concatenation %t
+
+namespace std {
+template
+class basic_string {
+public:
+ basic_string() {}
+ ~basic_string() {}
+ basic_string *operator+=(const basic_string &) {}
+ friend basic_string operator+(const basic_string &, const basic_string &) {}
+};
+typedef basic_string string;
+typedef basic_string wstring;
+}
+
+void f(std::string) {}
+std::string g(std::string) {}
+
+int main() {
+ std::string mystr1, mystr2;
+ std::wstring mywstr1, mywstr2;
+
+ for (int i = 0; i < 10; ++i) {
+f(mystr1 + mystr2 + mystr1);
+// CHECK-MESSAGES: :[[@LINE-1]]:23: warning: string concatenation results in allocation of unnecessary temporary strings; consider using 'operator+=' or 'string::append()' instead
+mystr1 = mystr1 + mystr2;
+// CHECK-MESSAGES: :[[@LINE-1]]:5: warning: string concatenation
+mystr1 = mystr2 + mystr2 + mystr2;
+// CHECK-MESSAGES: :[[@LINE-1]]:30: warning: string concatenation
+mystr1 = mystr2 + mystr1;
+// CHECK-MESSAGES: :[[@LINE-1]]:5: warning: string concatenation
+mywstr1 = mywstr2 + mywstr1;
+// CHECK-MESSAGES: :[[@LINE-1]]:5: warning: string concatenation
+mywstr1 = mywstr2 + mywstr2 + mywstr2;
+// CHECK-MESSAGES: :[[@LINE-1]]:33: warning: string concatenation
+
+mywstr1 = mywstr2 + mywstr2;
+mystr1 = mystr2 + mystr2;
+mystr1 += mystr2;
+f(mystr2 + mystr1);
+mystr1 = g(mystr1);
+ }
+ return 0;
+}
Index: docs/clang-tidy/checks/performance-inefficient-string-concatenation.rst
===
--- /dev/null
+++ docs/clang-tidy/checks/performance-inefficient-string-concatenation.rst
@@ -0,0 +1,49 @@
+.. title:: clang-tidy - performance-inefficient-string-concatenation
+
+performance-inefficient-string-concatenation
+
+
+This check warns about the performance overhead arising from concatenating strings using the ``operator+``, for instance:
+
+.. code:: c++
+
+std::string a("Foo"), b("Bar");
+a = a + b;
+
+Instead of this structure you should use ``operator+=`` or ``std::string``'s (``std::basic_string``) class member function ``append()``. For instance:
+
+.. code:: c++
+
+ std::string a("Foo"), b("Baz");
+ for (int i = 0; i < 2; ++i) {
+ a = a + "Bar" + b;
+ }
+
+Could be rewritten in a greatly more efficient way like:
+
+.. code:: c++
+
+ std::string a("Foo"), b("Baz");
+ for (int i = 0; i < 2; ++i) {
+ a.append("Bar").append(b);
+ }
+
+And this can be rewritten too:
+
+.. code:: c++
+
+ void f(const std::string&) {}
+ std::string a("Foo"), b("Baz");
+ void g() {
+ f(a + "Bar" + b);
+ }
+
+In a slightly more efficient way like:
+
+.. code:: c++
+
+ void f(const std::string&) {}
+ std::string a("Foo"), b("Baz");
+ void g() {
+ f(std::string(a).append("Bar").append(b));
+ }
Index: docs/clang-tidy/checks/list.rst
===
--- docs/clang-tidy/checks/list.rst
+++ docs/clang-tidy/checks/list.rst
@@ -102,6 +102,7 @@
performance-faster-string-find
performance-for-range-copy
performance-implicit-cast-in-loop
+ performance-inefficient-string-concatenation
performance-unnecessary-copy-initialization
performance-unnecessary-value-param
readability-avoid-const-params-in-decls
Index: docs/ReleaseNotes.rst
===
--- docs/ReleaseNotes.rst
+++ docs/ReleaseNotes.rst
@@ -184,6 +184,12 @@
Warns about range-based loop with a loop variable of const ref type where the
type of the variable does not match the one returned by the iterator.
+- New `performance-inefficient-string-concatenation
+ `_ check
+
+ This check is to warn about the performance overhead arising from concatenating
+ strings, using the ``operator+``, instead of ``operator+=``.
+
- New `performance-unnecessary-value-param
`_ check
Index: clang-tidy/performance/Performan
Re: [PATCH] D20196: [clang-tidy] Inefficient string operation
bittnerbarni updated this revision to Diff 63098.
bittnerbarni added a comment.
Thank you, for your valuable comments Alexander!
http://reviews.llvm.org/D20196
Files:
clang-tidy/performance/CMakeLists.txt
clang-tidy/performance/InefficientStringConcatenationCheck.cpp
clang-tidy/performance/InefficientStringConcatenationCheck.h
clang-tidy/performance/PerformanceTidyModule.cpp
docs/ReleaseNotes.rst
docs/clang-tidy/checks/list.rst
docs/clang-tidy/checks/performance-inefficient-string-concatenation.rst
test/clang-tidy/performance-inefficient-string-concatenation.cpp
Index: test/clang-tidy/performance-inefficient-string-concatenation.cpp
===
--- /dev/null
+++ test/clang-tidy/performance-inefficient-string-concatenation.cpp
@@ -0,0 +1,44 @@
+// RUN: %check_clang_tidy %s performance-inefficient-string-concatenation %t
+
+namespace std {
+template
+class basic_string {
+public:
+ basic_string() {}
+ ~basic_string() {}
+ basic_string *operator+=(const basic_string &) {}
+ friend basic_string operator+(const basic_string &, const basic_string &) {}
+};
+typedef basic_string string;
+typedef basic_string wstring;
+}
+
+void f(std::string) {}
+std::string g(std::string) {}
+
+int main() {
+ std::string mystr1, mystr2;
+ std::wstring mywstr1, mywstr2;
+
+ for (int i = 0; i < 10; ++i) {
+f(mystr1 + mystr2 + mystr1);
+// CHECK-MESSAGES: :[[@LINE-1]]:23: warning: string concatenation results in allocation of unnecessary temporary strings; consider using 'operator+=' or 'string::append()' instead
+mystr1 = mystr1 + mystr2;
+// CHECK-MESSAGES: :[[@LINE-1]]:5: warning: string concatenation
+mystr1 = mystr2 + mystr2 + mystr2;
+// CHECK-MESSAGES: :[[@LINE-1]]:30: warning: string concatenation
+mystr1 = mystr2 + mystr1;
+// CHECK-MESSAGES: :[[@LINE-1]]:5: warning: string concatenation
+mywstr1 = mywstr2 + mywstr1;
+// CHECK-MESSAGES: :[[@LINE-1]]:5: warning: string concatenation
+mywstr1 = mywstr2 + mywstr2 + mywstr2;
+// CHECK-MESSAGES: :[[@LINE-1]]:33: warning: string concatenation
+
+mywstr1 = mywstr2 + mywstr2;
+mystr1 = mystr2 + mystr2;
+mystr1 += mystr2;
+f(mystr2 + mystr1);
+mystr1 = g(mystr1);
+ }
+ return 0;
+}
Index: docs/clang-tidy/checks/performance-inefficient-string-concatenation.rst
===
--- /dev/null
+++ docs/clang-tidy/checks/performance-inefficient-string-concatenation.rst
@@ -0,0 +1,49 @@
+.. title:: clang-tidy - performance-inefficient-string-concatenation
+
+performance-inefficient-string-concatenation
+
+
+This check warns about the performance overhead arising from concatenating strings using the ``operator+``, for instance:
+
+.. code:: c++
+
+std::string a("Foo"), b("Bar");
+a = a + b;
+
+Instead of this structure you should use ``operator+=`` or ``std::string``'s (``std::basic_string``) class member function ``append()``. For instance:
+
+.. code:: c++
+
+ std::string a("Foo"), b("Baz");
+ for (int i = 0; i < 2; ++i) {
+ a = a + "Bar" + b;
+ }
+
+Could be rewritten in a greatly more efficient way like:
+
+.. code:: c++
+
+ std::string a("Foo"), b("Baz");
+ for (int i = 0; i < 2; ++i) {
+ a.append("Bar").append(b);
+ }
+
+And this can be rewritten too:
+
+.. code:: c++
+
+ void f(const std::string&) {}
+ std::string a("Foo"), b("Baz");
+ void g() {
+ f(a + "Bar" + b);
+ }
+
+In a slightly more efficient way like:
+
+.. code:: c++
+
+ void f(const std::string&) {}
+ std::string a("Foo"), b("Baz");
+ void g() {
+ f(std::string(a).append("Bar").append(b));
+ }
Index: docs/clang-tidy/checks/list.rst
===
--- docs/clang-tidy/checks/list.rst
+++ docs/clang-tidy/checks/list.rst
@@ -102,6 +102,7 @@
performance-faster-string-find
performance-for-range-copy
performance-implicit-cast-in-loop
+ performance-inefficient-string-concatenation
performance-unnecessary-copy-initialization
performance-unnecessary-value-param
readability-avoid-const-params-in-decls
Index: docs/ReleaseNotes.rst
===
--- docs/ReleaseNotes.rst
+++ docs/ReleaseNotes.rst
@@ -184,6 +184,12 @@
Warns about range-based loop with a loop variable of const ref type where the
type of the variable does not match the one returned by the iterator.
+- New `performance-inefficient-string-concatenation
+ `_ check
+
+ This check is to warn about the performance overhead arising from concatenating
+ strings, using the ``operator+``, instead of ``operator+=``.
+
- New `performance-unnecessary-value-param
