Skip to content

[clang-tidy][NFC] Remove regex hacks to match full lines in tests #162293

New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

Sign up for GitHub

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

Merged
merged 4 commits into from
Oct 10, 2025
Merged

[clang-tidy][NFC] Remove regex hacks to match full lines in tests #162293

Show file tree
Hide file tree
Changes from all commits
Commits
Show all changes
4 commits
Select commit Hold shift + click to select a range
05ab6b7
[clang-tidy][NFC] Remove regex hacks to match full lines in tests
localspook Oct 7, 2025
8c69ca3
Indentation and some missing braces
localspook Oct 8, 2025
08a8c94
Don't touch `CHECK-NOTES` or `CHECK-MESSAGES`
localspook Oct 8, 2025
d4bfd8f
Clean up a few more files
localspook Oct 8, 2025
File filter

Filter by extension

Filter by extension
Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
12 changes: 6 additions & 6 deletions clang-tools-extra/test/clang-tidy/checkers/abseil/cleanup-ctad.cpp
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -79,27 +79,27 @@ absl::Cleanup<cleanup_internal::Tag, Callback> MakeCleanup(Callback callback) {
void test() {
auto a = absl::MakeCleanup([] {});
// CHECK-MESSAGES: :[[@LINE-1]]:3: warning: prefer absl::Cleanup's class template argument deduction pattern in C++17 and higher
// CHECK-FIXES: {{^}} absl::Cleanup a = [] {};{{$}}
// CHECK-FIXES: absl::Cleanup a = [] {};

auto b = absl::MakeCleanup(std::function<void()>([] {}));
// CHECK-MESSAGES: :[[@LINE-1]]:3: warning: prefer absl::Cleanup{{.*}}C++17 and higher
// CHECK-FIXES: {{^}} absl::Cleanup b = std::function<void()>([] {});{{$}}
// CHECK-FIXES: absl::Cleanup b = std::function<void()>([] {});

const auto c = absl::MakeCleanup([] {});
// CHECK-MESSAGES: :[[@LINE-1]]:9: warning: prefer absl::Cleanup{{.*}}C++17 and higher
// CHECK-FIXES: {{^}} const absl::Cleanup c = [] {};{{$}}
// CHECK-FIXES: const absl::Cleanup c = [] {};

const auto d = absl::MakeCleanup(std::function<void()>([] {}));
// CHECK-MESSAGES: :[[@LINE-1]]:9: warning: prefer absl::Cleanup{{.*}}C++17 and higher
// CHECK-FIXES: {{^}} const absl::Cleanup d = std::function<void()>([] {});{{$}}
// CHECK-FIXES: const absl::Cleanup d = std::function<void()>([] {});

// Preserves extra parens
auto e = absl::MakeCleanup(([] {}));
// CHECK-MESSAGES: :[[@LINE-1]]:3: warning: prefer absl::Cleanup{{.*}}C++17 and higher
// CHECK-FIXES: {{^}} absl::Cleanup e = ([] {});{{$}}
// CHECK-FIXES: absl::Cleanup e = ([] {});

// Preserves comments
auto f = /* a */ absl::MakeCleanup(/* b */ [] { /* c */ } /* d */) /* e */;
// CHECK-MESSAGES: :[[@LINE-1]]:3: warning: prefer absl::Cleanup{{.*}}C++17 and higher
// CHECK-FIXES: {{^}} absl::Cleanup f = /* a */ /* b */ [] { /* c */ } /* d */ /* e */;{{$}}
// CHECK-FIXES: absl::Cleanup f = /* a */ /* b */ [] { /* c */ } /* d */ /* e */;
}
6 changes: 3 additions & 3 deletions clang-tools-extra/test/clang-tidy/checkers/abseil/str-cat-append.cpp
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -97,7 +97,7 @@ void Bar() {
// CHECK-MESSAGES: [[@LINE-1]]:3: warning: call to 'absl::StrCat' has no effect
A = StrCat(A, B);
// CHECK-MESSAGES: [[@LINE-1]]:3: warning: call 'absl::StrAppend' instead of 'absl::StrCat' when appending to a string to avoid a performance penalty
// CHECK-FIXES: {{^}} absl::StrAppend(&A, B);
// CHECK-FIXES: absl::StrAppend(&A, B);
B = StrCat(A, B);

#define M(X) X = StrCat(X, A)
Expand All @@ -117,13 +117,13 @@ void OutsideAbsl() {
std::string A, B;
A = absl::StrCat(A, B);
// CHECK-MESSAGES: [[@LINE-1]]:3: warning: call 'absl::StrAppend' instead of 'absl::StrCat' when appending to a string to avoid a performance penalty
// CHECK-FIXES: {{^}} absl::StrAppend(&A, B);
// CHECK-FIXES: absl::StrAppend(&A, B);
}

void OutsideUsingAbsl() {
std::string A, B;
using absl::StrCat;
A = StrCat(A, B);
// CHECK-MESSAGES: [[@LINE-1]]:3: warning: call 'absl::StrAppend' instead of 'absl::StrCat' when appending to a string to avoid a performance penalty
// CHECK-FIXES: {{^}} absl::StrAppend(&A, B);
// CHECK-FIXES: absl::StrAppend(&A, B);
}
72 changes: 36 additions & 36 deletions clang-tools-extra/test/clang-tidy/checkers/abseil/string-find-str-contains.cpp
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -70,41 +70,41 @@ void basic_tests() {
std::string ss;
ss.find("a") == std::string::npos;
// CHECK-MESSAGES: :[[@LINE-1]]:3: warning: use !absl::StrContains instead of find() == npos
// CHECK-FIXES: {{^[[:space:]]*}}!absl::StrContains(ss, "a");{{$}}
// CHECK-FIXES: !absl::StrContains(ss, "a");

ss.find("a") != std::string::npos;
// CHECK-MESSAGES: :[[@LINE-1]]:3: warning: use absl::StrContains instead of find() != npos
// CHECK-FIXES: {{^[[:space:]]*}}absl::StrContains(ss, "a");{{$}}
// CHECK-FIXES: absl::StrContains(ss, "a");

std::string::npos != ss.find("a");
// CHECK-MESSAGES: :[[@LINE-1]]:3: warning: use absl::StrContains instead of
// CHECK-FIXES: {{^[[:space:]]*}}absl::StrContains(ss, "a");{{$}}
// CHECK-FIXES: absl::StrContains(ss, "a");

std::string_view ssv;
ssv.find("a") == std::string_view::npos;
// CHECK-MESSAGES: :[[@LINE-1]]:3: warning: use !absl::StrContains instead of
// CHECK-FIXES: {{^[[:space:]]*}}!absl::StrContains(ssv, "a");{{$}}
// CHECK-FIXES: !absl::StrContains(ssv, "a");

ssv.find("a") != std::string_view::npos;
// CHECK-MESSAGES: :[[@LINE-1]]:3: warning: use absl::StrContains instead of
// CHECK-FIXES: {{^[[:space:]]*}}absl::StrContains(ssv, "a");{{$}}
// CHECK-FIXES: absl::StrContains(ssv, "a");

std::string_view::npos != ssv.find("a");
// CHECK-MESSAGES: :[[@LINE-1]]:3: warning: use absl::StrContains instead of
// CHECK-FIXES: {{^[[:space:]]*}}absl::StrContains(ssv, "a");{{$}}
// CHECK-FIXES: absl::StrContains(ssv, "a");

absl::string_view asv;
asv.find("a") == absl::string_view::npos;
// CHECK-MESSAGES: :[[@LINE-1]]:3: warning: use !absl::StrContains instead of
// CHECK-FIXES: {{^[[:space:]]*}}!absl::StrContains(asv, "a");{{$}}
// CHECK-FIXES: !absl::StrContains(asv, "a");

asv.find("a") != absl::string_view::npos;
// CHECK-MESSAGES: :[[@LINE-1]]:3: warning: use absl::StrContains instead of
// CHECK-FIXES: {{^[[:space:]]*}}absl::StrContains(asv, "a");{{$}}
// CHECK-FIXES: absl::StrContains(asv, "a");

absl::string_view::npos != asv.find("a");
// CHECK-MESSAGES: :[[@LINE-1]]:3: warning: use absl::StrContains instead of
// CHECK-FIXES: {{^[[:space:]]*}}absl::StrContains(asv, "a");{{$}}
// CHECK-FIXES: absl::StrContains(asv, "a");
}

// Confirms that it works even if you mix-and-match the type for find and for
Expand All @@ -115,29 +115,29 @@ void mismatched_npos() {
std::string ss;
ss.find("a") == std::string_view::npos;
// CHECK-MESSAGES: :[[@LINE-1]]:3: warning: use !absl::StrContains instead of
// CHECK-FIXES: {{^[[:space:]]*}}!absl::StrContains(ss, "a");{{$}}
// CHECK-FIXES: !absl::StrContains(ss, "a");

ss.find("a") != absl::string_view::npos;
// CHECK-MESSAGES: :[[@LINE-1]]:3: warning: use absl::StrContains instead of
// CHECK-FIXES: {{^[[:space:]]*}}absl::StrContains(ss, "a");{{$}}
// CHECK-FIXES: absl::StrContains(ss, "a");

std::string_view ssv;
ssv.find("a") == absl::string_view::npos;
// CHECK-MESSAGES: :[[@LINE-1]]:3: warning: use !absl::StrContains instead of
// CHECK-FIXES: {{^[[:space:]]*}}!absl::StrContains(ssv, "a");{{$}}
// CHECK-FIXES: !absl::StrContains(ssv, "a");

ssv.find("a") != std::string::npos;
// CHECK-MESSAGES: :[[@LINE-1]]:3: warning: use absl::StrContains instead of
// CHECK-FIXES: {{^[[:space:]]*}}absl::StrContains(ssv, "a");{{$}}
// CHECK-FIXES: absl::StrContains(ssv, "a");

absl::string_view asv;
asv.find("a") == std::string::npos;
// CHECK-MESSAGES: :[[@LINE-1]]:3: warning: use !absl::StrContains instead of
// CHECK-FIXES: {{^[[:space:]]*}}!absl::StrContains(asv, "a");{{$}}
// CHECK-FIXES: !absl::StrContains(asv, "a");

asv.find("a") != std::string_view::npos;
// CHECK-MESSAGES: :[[@LINE-1]]:3: warning: use absl::StrContains instead of
// CHECK-FIXES: {{^[[:space:]]*}}absl::StrContains(asv, "a");{{$}}
// CHECK-FIXES: absl::StrContains(asv, "a");
}

// Confirms that it works even when the needle or the haystack are more
Expand All @@ -146,41 +146,41 @@ void subexpression_tests() {
std::string ss, ss2;
foo_ss(ss).find(ss2) == std::string::npos;
// CHECK-MESSAGES: :[[@LINE-1]]:3: warning: use !absl::StrContains instead of
// CHECK-FIXES: {{^[[:space:]]*}}!absl::StrContains(foo_ss(ss), ss2);{{$}}
// CHECK-FIXES: !absl::StrContains(foo_ss(ss), ss2);

ss.find(foo_ss(ss2)) != std::string::npos;
// CHECK-MESSAGES: :[[@LINE-1]]:3: warning: use absl::StrContains instead of
// CHECK-FIXES: {{^[[:space:]]*}}absl::StrContains(ss, foo_ss(ss2));{{$}}
// CHECK-FIXES: absl::StrContains(ss, foo_ss(ss2));

foo_ss(bar_ss()).find(foo_ss(ss2)) != std::string::npos;
// CHECK-MESSAGES: :[[@LINE-1]]:3: warning: use absl::StrContains instead of
// CHECK-FIXES: {{^[[:space:]]*}}absl::StrContains(foo_ss(bar_ss()), foo_ss(ss2));{{$}}
// CHECK-FIXES: absl::StrContains(foo_ss(bar_ss()), foo_ss(ss2));

std::string_view ssv, ssv2;
foo_ssv(ssv).find(ssv2) == std::string_view::npos;
// CHECK-MESSAGES: :[[@LINE-1]]:3: warning: use !absl::StrContains instead of
// CHECK-FIXES: {{^[[:space:]]*}}!absl::StrContains(foo_ssv(ssv), ssv2);{{$}}
// CHECK-FIXES: !absl::StrContains(foo_ssv(ssv), ssv2);

ssv.find(foo_ssv(ssv2)) != std::string_view::npos;
// CHECK-MESSAGES: :[[@LINE-1]]:3: warning: use absl::StrContains instead of
// CHECK-FIXES: {{^[[:space:]]*}}absl::StrContains(ssv, foo_ssv(ssv2));{{$}}
// CHECK-FIXES: absl::StrContains(ssv, foo_ssv(ssv2));

foo_ssv(bar_ssv()).find(foo_ssv(ssv2)) != std::string_view::npos;
// CHECK-MESSAGES: :[[@LINE-1]]:3: warning: use absl::StrContains instead of
// CHECK-FIXES: {{^[[:space:]]*}}absl::StrContains(foo_ssv(bar_ssv()), foo_ssv(ssv2));{{$}}
// CHECK-FIXES: absl::StrContains(foo_ssv(bar_ssv()), foo_ssv(ssv2));

absl::string_view asv, asv2;
foo_asv(asv).find(asv2) == absl::string_view::npos;
// CHECK-MESSAGES: :[[@LINE-1]]:3: warning: use !absl::StrContains instead of
// CHECK-FIXES: {{^[[:space:]]*}}!absl::StrContains(foo_asv(asv), asv2);{{$}}
// CHECK-FIXES: !absl::StrContains(foo_asv(asv), asv2);

asv.find(foo_asv(asv2)) != absl::string_view::npos;
// CHECK-MESSAGES: :[[@LINE-1]]:3: warning: use absl::StrContains instead of
// CHECK-FIXES: {{^[[:space:]]*}}absl::StrContains(asv, foo_asv(asv2));{{$}}
// CHECK-FIXES: absl::StrContains(asv, foo_asv(asv2));

foo_asv(bar_asv()).find(foo_asv(asv2)) != absl::string_view::npos;
// CHECK-MESSAGES: :[[@LINE-1]]:3: warning: use absl::StrContains instead of
// CHECK-FIXES: {{^[[:space:]]*}}absl::StrContains(foo_asv(bar_asv()), foo_asv(asv2));{{$}}
// CHECK-FIXES: absl::StrContains(foo_asv(bar_asv()), foo_asv(asv2));
}

// Confirms that it works with string literal, char* and const char* parameters.
Expand All @@ -191,58 +191,58 @@ void string_literal_and_char_ptr_tests() {
std::string ss;
ss.find("c") == std::string::npos;
// CHECK-MESSAGES: :[[@LINE-1]]:3: warning: use !absl::StrContains instead of
// CHECK-FIXES: {{^[[:space:]]*}}!absl::StrContains(ss, "c");{{$}}
// CHECK-FIXES: !absl::StrContains(ss, "c");

ss.find(c) == std::string::npos;
// CHECK-MESSAGES: :[[@LINE-1]]:3: warning: use !absl::StrContains instead of
// CHECK-FIXES: {{^[[:space:]]*}}!absl::StrContains(ss, c);{{$}}
// CHECK-FIXES: !absl::StrContains(ss, c);

ss.find(cc) == std::string::npos;
// CHECK-MESSAGES: :[[@LINE-1]]:3: warning: use !absl::StrContains instead of
// CHECK-FIXES: {{^[[:space:]]*}}!absl::StrContains(ss, cc);{{$}}
// CHECK-FIXES: !absl::StrContains(ss, cc);

std::string_view ssv;
ssv.find("c") == std::string_view::npos;
// CHECK-MESSAGES: :[[@LINE-1]]:3: warning: use !absl::StrContains instead of
// CHECK-FIXES: {{^[[:space:]]*}}!absl::StrContains(ssv, "c");{{$}}
// CHECK-FIXES: !absl::StrContains(ssv, "c");

ssv.find(c) == std::string_view::npos;
// CHECK-MESSAGES: :[[@LINE-1]]:3: warning: use !absl::StrContains instead of
// CHECK-FIXES: {{^[[:space:]]*}}!absl::StrContains(ssv, c);{{$}}
// CHECK-FIXES: !absl::StrContains(ssv, c);

ssv.find(cc) == std::string_view::npos;
// CHECK-MESSAGES: :[[@LINE-1]]:3: warning: use !absl::StrContains instead of
// CHECK-FIXES: {{^[[:space:]]*}}!absl::StrContains(ssv, cc);{{$}}
// CHECK-FIXES: !absl::StrContains(ssv, cc);

absl::string_view asv;
asv.find("c") == absl::string_view::npos;
// CHECK-MESSAGES: :[[@LINE-1]]:3: warning: use !absl::StrContains instead of
// CHECK-FIXES: {{^[[:space:]]*}}!absl::StrContains(asv, "c");{{$}}
// CHECK-FIXES: !absl::StrContains(asv, "c");

asv.find(c) == absl::string_view::npos;
// CHECK-MESSAGES: :[[@LINE-1]]:3: warning: use !absl::StrContains instead of
// CHECK-FIXES: {{^[[:space:]]*}}!absl::StrContains(asv, c);{{$}}
// CHECK-FIXES: !absl::StrContains(asv, c);

asv.find(cc) == absl::string_view::npos;
// CHECK-MESSAGES: :[[@LINE-1]]:3: warning: use !absl::StrContains instead of
// CHECK-FIXES: {{^[[:space:]]*}}!absl::StrContains(asv, cc);{{$}}
// CHECK-FIXES: !absl::StrContains(asv, cc);
}

void char_param_tests() {
std::string ss;
ss.find('c') == std::string::npos;
// CHECK-MESSAGES: :[[@LINE-1]]:3: warning: use !absl::StrContains instead of
// CHECK-FIXES: {{^[[:space:]]*}}!absl::StrContains(ss, 'c');{{$}}
// CHECK-FIXES: !absl::StrContains(ss, 'c');

std::string_view ssv;
ssv.find('c') == std::string_view::npos;
// CHECK-MESSAGES: :[[@LINE-1]]:3: warning: use !absl::StrContains instead of
// CHECK-FIXES: {{^[[:space:]]*}}!absl::StrContains(ssv, 'c');{{$}}
// CHECK-FIXES: !absl::StrContains(ssv, 'c');

absl::string_view asv;
asv.find('c') == absl::string_view::npos;
// CHECK-MESSAGES: :[[@LINE-1]]:3: warning: use !absl::StrContains instead of
// CHECK-FIXES: {{^[[:space:]]*}}!absl::StrContains(asv, 'c');{{$}}
// CHECK-FIXES: !absl::StrContains(asv, 'c');
}

#define FOO(a, b, c, d) ((a).find(b) == std::string::npos ? (c) : (d))
Expand Down
2 changes: 1 addition & 1 deletion clang-tools-extra/test/clang-tidy/checkers/bugprone/argument-comment.cpp
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -12,7 +12,7 @@ void g() {
// CHECK-NOTES: [[@LINE+2]]:14: warning: argument name 'z' in comment does not match parameter name 'y'
// CHECK-NOTES: [[@LINE-5]]:19: note: 'y' declared here
f(/*y=*/0, /*z=*/0);
// CHECK-FIXES: {{^}} f(/*y=*/0, /*z=*/0);
// CHECK-FIXES: f(/*y=*/0, /*z=*/0);

f(/*x=*/1, /*y=*/1);

Expand Down
16 changes: 8 additions & 8 deletions clang-tools-extra/test/clang-tidy/checkers/bugprone/inaccurate-erase.cpp
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -51,12 +51,12 @@ struct custom_container {
template <typename T> void g() {
T t;
t.erase(std::remove(t.begin(), t.end(), 10));
// CHECK-FIXES: {{^ }}t.erase(std::remove(t.begin(), t.end(), 10));{{$}}
// CHECK-FIXES: t.erase(std::remove(t.begin(), t.end(), 10));

std::vector<int> v;
v.erase(remove(v.begin(), v.end(), 10));
// CHECK-MESSAGES: :[[@LINE-1]]:3: warning: this call will remove at most one
// CHECK-FIXES: {{^ }}v.erase(remove(v.begin(), v.end(), 10), v.end());{{$}}
// CHECK-FIXES: v.erase(remove(v.begin(), v.end(), 10), v.end());
}

#define ERASE(x, y) x.erase(remove(x.begin(), x.end(), y))
Expand All @@ -67,34 +67,34 @@ int main() {

v.erase(remove(v.begin(), v.end(), 10));
// CHECK-MESSAGES: :[[@LINE-1]]:3: warning: this call will remove at most one item even when multiple items should be removed [bugprone-inaccurate-erase]
// CHECK-FIXES: {{^ }}v.erase(remove(v.begin(), v.end(), 10), v.end());{{$}}
// CHECK-FIXES: v.erase(remove(v.begin(), v.end(), 10), v.end());
v.erase(remove(v.begin(), v.end(), 20), v.end());

auto *p = &v;
p->erase(remove(p->begin(), p->end(), 11));
// CHECK-MESSAGES: :[[@LINE-1]]:3: warning: this call will remove at most one
// CHECK-FIXES: {{^ }}p->erase(remove(p->begin(), p->end(), 11), p->end());{{$}}
// CHECK-FIXES: p->erase(remove(p->begin(), p->end(), 11), p->end());

std::vector_with_const_iterator<int> v2;
v2.erase(remove(v2.begin(), v2.end(), 12));
// CHECK-MESSAGES: :[[@LINE-1]]:3: warning: this call will remove at most one
// CHECK-FIXES: {{^ }}v2.erase(remove(v2.begin(), v2.end(), 12), v2.end());{{$}}
// CHECK-FIXES: v2.erase(remove(v2.begin(), v2.end(), 12), v2.end());

// Fix is not trivial.
auto it = v.end();
v.erase(remove(v.begin(), it, 10));
// CHECK-MESSAGES: :[[@LINE-1]]:3: warning: this call will remove at most one
// CHECK-FIXES: {{^ }}v.erase(remove(v.begin(), it, 10));{{$}}
// CHECK-FIXES: v.erase(remove(v.begin(), it, 10));

g<std::vector<int>>();
g<custom_container>();

ERASE(v, 15);
// CHECK-MESSAGES: :[[@LINE-1]]:9: warning: this call will remove at most one
// CHECK-FIXES: {{^ }}ERASE(v, 15);{{$}}
// CHECK-FIXES: ERASE(v, 15);

std::vector<std::unique_ptr<int>> vupi;
auto iter = vupi.begin();
vupi.erase(iter++);
// CHECK-FIXES: {{^ }}vupi.erase(iter++);{{$}}
// CHECK-FIXES: vupi.erase(iter++);
}
6 changes: 3 additions & 3 deletions ...g-tools-extra/test/clang-tidy/checkers/bugprone/misplaced-operator-in-strlen-in-alloc.cpp
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -17,7 +17,7 @@ size_t strlen(const char *);
void bad_std_malloc_std_strlen(char *name) {
char *new_name = (char *)std::malloc(std::strlen(name + 1));
// CHECK-MESSAGES: :[[@LINE-1]]:28: warning: addition operator is applied to the argument of strlen
// CHECK-FIXES: {{^ char \*new_name = \(char \*\)std::malloc\(}}std::strlen(name) + 1{{\);$}}
// CHECK-FIXES: char *new_name = (char *)std::malloc(std::strlen(name) + 1);
}

void ignore_non_std_malloc_std_strlen(char *name) {
Expand All @@ -35,7 +35,7 @@ void ignore_std_malloc_non_std_strlen(char *name) {
void bad_new_strlen(char *name) {
char *new_name = new char[std::strlen(name + 1)];
// CHECK-MESSAGES: :[[@LINE-1]]:20: warning: addition operator is applied to the argument of strlen
// CHECK-FIXES: {{^ char \*new_name = new char\[}}std::strlen(name) + 1{{\];$}}
// CHECK-FIXES: char *new_name = new char[std::strlen(name) + 1];
}

void good_new_strlen(char *name) {
Expand All @@ -54,5 +54,5 @@ class C {
void bad_custom_new_strlen(char *name) {
C *new_name = new C[std::strlen(name + 1)];
// CHECK-MESSAGES: :[[@LINE-1]]:17: warning: addition operator is applied to the argument of strlen
// CHECK-FIXES: {{^ C \*new_name = new C\[}}std::strlen(name) + 1{{\];$}}
// CHECK-FIXES: C *new_name = new C[std::strlen(name) + 1];
}
12 changes: 6 additions & 6 deletions clang-tools-extra/test/clang-tidy/checkers/bugprone/reserved-identifier-invert.cpp
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -12,16 +12,16 @@ void __f() {}

void f();
// CHECK-MESSAGES: :[[@LINE-1]]:6: warning: declaration uses identifier 'f', which is not a reserved identifier [bugprone-reserved-identifier]
// CHECK-FIXES: {{^}}void __f();{{$}}
// CHECK-FIXES: void __f();
struct helper {};
// CHECK-MESSAGES: :[[@LINE-1]]:8: warning: declaration uses identifier 'helper', which is not a reserved identifier [bugprone-reserved-identifier]
// CHECK-FIXES: {{^}}struct __helper {};{{$}}
// CHECK-FIXES: struct __helper {};
struct Helper {};
// CHECK-MESSAGES: :[[@LINE-1]]:8: warning: declaration uses identifier 'Helper', which is not a reserved identifier [bugprone-reserved-identifier]
// CHECK-FIXES: {{^}}struct _Helper {};{{$}}
// CHECK-FIXES: struct _Helper {};
struct _helper2 {};
// CHECK-MESSAGES: :[[@LINE-1]]:8: warning: declaration uses identifier '_helper2', which is not a reserved identifier [bugprone-reserved-identifier]
// CHECK-FIXES: {{^}}struct __helper2 {};{{$}}
// CHECK-FIXES: struct __helper2 {};

template <class _Tp>
class reference_wrapper {
Expand Down Expand Up @@ -53,11 +53,11 @@ ref(reference_wrapper<_Tp> __t) noexcept {

template <class Up>
// CHECK-MESSAGES: :[[@LINE-1]]:17: warning: declaration uses identifier 'Up', which is not a reserved identifier [bugprone-reserved-identifier]
// CHECK-FIXES: {{^}}template <class _Up>{{$}}
// CHECK-FIXES: template <class _Up>
inline reference_wrapper<const Up>
cref(const Up &u) noexcept {
// CHECK-MESSAGES: :[[@LINE-1]]:16: warning: declaration uses identifier 'u', which is not a reserved identifier [bugprone-reserved-identifier]
// CHECK-FIXES: {{^}}cref(const _Up &__u) noexcept {{{$}}
// CHECK-FIXES: cref(const _Up &__u) noexcept {
return reference_wrapper<const Up>(u);
}

Expand Down
Loading