Skip to content

Commit 05ab6b7

Browse files
localspooklocalspook
committed
[clang-tidy][NFC] Remove regex hacks to match full lines in tests
1 parent e84dcba commit 05ab6b7

File tree

88 files changed

+2545
-2547
lines changed

Some content is hidden

Large Commits have some content hidden by default. Use the searchbox below for content that may be hidden.

88 files changed

+2545
-2547
lines changed

‎clang-tools-extra/test/clang-tidy/checkers/abseil/cleanup-ctad.cpp‎

Lines changed: 6 additions & 6 deletions
Original file line numberDiff line numberDiff line change
@@ -79,27 +79,27 @@ absl::Cleanup<cleanup_internal::Tag, Callback> MakeCleanup(Callback callback) {
7979
void test() {
8080
auto a = absl::MakeCleanup([] {});
8181
// CHECK-MESSAGES: :[[@LINE-1]]:3: warning: prefer absl::Cleanup's class template argument deduction pattern in C++17 and higher
82-
// CHECK-FIXES: {{^}} absl::Cleanup a = [] {};{{$}}
82+
// CHECK-FIXES: absl::Cleanup a = [] {};
8383

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

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

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

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

101101
// Preserves comments
102102
auto f = /* a */ absl::MakeCleanup(/* b */ [] { /* c */ } /* d */) /* e */;
103103
// CHECK-MESSAGES: :[[@LINE-1]]:3: warning: prefer absl::Cleanup{{.*}}C++17 and higher
104-
// CHECK-FIXES: {{^}} absl::Cleanup f = /* a */ /* b */ [] { /* c */ } /* d */ /* e */;{{$}}
104+
// CHECK-FIXES: absl::Cleanup f = /* a */ /* b */ [] { /* c */ } /* d */ /* e */;
105105
}

‎clang-tools-extra/test/clang-tidy/checkers/abseil/str-cat-append.cpp‎

Lines changed: 3 additions & 3 deletions
Original file line numberDiff line numberDiff line change
@@ -97,7 +97,7 @@ void Bar() {
9797
// CHECK-MESSAGES: [[@LINE-1]]:3: warning: call to 'absl::StrCat' has no effect
9898
A = StrCat(A, B);
9999
// CHECK-MESSAGES: [[@LINE-1]]:3: warning: call 'absl::StrAppend' instead of 'absl::StrCat' when appending to a string to avoid a performance penalty
100-
// CHECK-FIXES: {{^}} absl::StrAppend(&A, B);
100+
// CHECK-FIXES: absl::StrAppend(&A, B);
101101
B = StrCat(A, B);
102102

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

123123
void OutsideUsingAbsl() {
124124
std::string A, B;
125125
using absl::StrCat;
126126
A = StrCat(A, B);
127127
// CHECK-MESSAGES: [[@LINE-1]]:3: warning: call 'absl::StrAppend' instead of 'absl::StrCat' when appending to a string to avoid a performance penalty
128-
// CHECK-FIXES: {{^}} absl::StrAppend(&A, B);
128+
// CHECK-FIXES: absl::StrAppend(&A, B);
129129
}

‎clang-tools-extra/test/clang-tidy/checkers/abseil/string-find-str-contains.cpp‎

Lines changed: 36 additions & 36 deletions
Original file line numberDiff line numberDiff line change
@@ -70,41 +70,41 @@ void basic_tests() {
7070
std::string ss;
7171
ss.find("a") == std::string::npos;
7272
// CHECK-MESSAGES: :[[@LINE-1]]:3: warning: use !absl::StrContains instead of find() == npos
73-
// CHECK-FIXES: {{^[[:space:]]*}}!absl::StrContains(ss, "a");{{$}}
73+
// CHECK-FIXES: !absl::StrContains(ss, "a");
7474

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

248248
#define FOO(a, b, c, d) ((a).find(b) == std::string::npos ? (c) : (d))

‎clang-tools-extra/test/clang-tidy/checkers/bugprone/argument-comment.cpp‎

Lines changed: 1 addition & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -12,7 +12,7 @@ void g() {
1212
// CHECK-NOTES: [[@LINE+2]]:14: warning: argument name 'z' in comment does not match parameter name 'y'
1313
// CHECK-NOTES: [[@LINE-5]]:19: note: 'y' declared here
1414
f(/*y=*/0, /*z=*/0);
15-
// CHECK-FIXES: {{^}} f(/*y=*/0, /*z=*/0);
15+
// CHECK-FIXES: f(/*y=*/0, /*z=*/0);
1616

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

‎clang-tools-extra/test/clang-tidy/checkers/bugprone/easily-swappable-parameters-implicits.c‎

Lines changed: 7 additions & 7 deletions
Original file line numberDiff line numberDiff line change
@@ -30,19 +30,19 @@ void numericConversion1(int I, double D) { numericConversion1(D, I); }
3030
// CHECK-MESSAGES: :[[@LINE-1]]:25: warning: 2 adjacent parameters of 'numericConversion1' of convertible types are easily swapped by mistake [bugprone-easily-swappable-parameters]
3131
// CHECK-MESSAGES: :[[@LINE-2]]:29: note: the first parameter in the range is 'I'
3232
// CHECK-MESSAGES: :[[@LINE-3]]:39: note: the last parameter in the range is 'D'
33-
// CHECK-MESSAGES: :[[@LINE-4]]:32: note: 'int' and 'double' may be implicitly converted{{$}}
33+
// CHECK-MESSAGES: :[[@LINE-4]]:32: note: 'int' and 'double' may be implicitly converted
3434

3535
void numericConversion2(int I, short S) { numericConversion2(S, I); }
3636
// CHECK-MESSAGES: :[[@LINE-1]]:25: warning: 2 adjacent parameters of 'numericConversion2' of convertible types
3737
// CHECK-MESSAGES: :[[@LINE-2]]:29: note: the first parameter in the range is 'I'
3838
// CHECK-MESSAGES: :[[@LINE-3]]:38: note: the last parameter in the range is 'S'
39-
// CHECK-MESSAGES: :[[@LINE-4]]:32: note: 'int' and 'short' may be implicitly converted{{$}}
39+
// CHECK-MESSAGES: :[[@LINE-4]]:32: note: 'int' and 'short' may be implicitly converted
4040

4141
void numericConversion3(float F, unsigned long UL) { numericConversion3(UL, F); }
4242
// CHECK-MESSAGES: :[[@LINE-1]]:25: warning: 2 adjacent parameters of 'numericConversion3' of convertible types
4343
// CHECK-MESSAGES: :[[@LINE-2]]:31: note: the first parameter in the range is 'F'
4444
// CHECK-MESSAGES: :[[@LINE-3]]:48: note: the last parameter in the range is 'UL'
45-
// CHECK-MESSAGES: :[[@LINE-4]]:34: note: 'float' and 'unsigned long' may be implicitly converted{{$}}
45+
// CHECK-MESSAGES: :[[@LINE-4]]:34: note: 'float' and 'unsigned long' may be implicitly converted
4646

4747
enum Unscoped { U_A,
4848
U_B };
@@ -53,25 +53,25 @@ void numericConversion4(int I, enum Unscoped U) { numericConversion4(U, I); }
5353
// CHECK-MESSAGES: :[[@LINE-1]]:25: warning: 2 adjacent parameters of 'numericConversion4' of convertible types
5454
// CHECK-MESSAGES: :[[@LINE-2]]:29: note: the first parameter in the range is 'I'
5555
// CHECK-MESSAGES: :[[@LINE-3]]:46: note: the last parameter in the range is 'U'
56-
// CHECK-MESSAGES: :[[@LINE-4]]:32: note: 'int' and 'enum Unscoped' may be implicitly converted{{$}}
56+
// CHECK-MESSAGES: :[[@LINE-4]]:32: note: 'int' and 'enum Unscoped' may be implicitly converted
5757

5858
void numericConversion5(int I, enum UnscopedFixed UF) { numericConversion5(UF, I); }
5959
// CHECK-MESSAGES: :[[@LINE-1]]:25: warning: 2 adjacent parameters of 'numericConversion5' of convertible types
6060
// CHECK-MESSAGES: :[[@LINE-2]]:29: note: the first parameter in the range is 'I'
6161
// CHECK-MESSAGES: :[[@LINE-3]]:51: note: the last parameter in the range is 'UF'
62-
// CHECK-MESSAGES: :[[@LINE-4]]:32: note: 'int' and 'enum UnscopedFixed' may be implicitly converted{{$}}
62+
// CHECK-MESSAGES: :[[@LINE-4]]:32: note: 'int' and 'enum UnscopedFixed' may be implicitly converted
6363

6464
void numericConversion7(double D, enum Unscoped U) { numericConversion7(U, D); }
6565
// CHECK-MESSAGES: :[[@LINE-1]]:25: warning: 2 adjacent parameters of 'numericConversion7' of convertible types
6666
// CHECK-MESSAGES: :[[@LINE-2]]:32: note: the first parameter in the range is 'D'
6767
// CHECK-MESSAGES: :[[@LINE-3]]:49: note: the last parameter in the range is 'U'
68-
// CHECK-MESSAGES: :[[@LINE-4]]:35: note: 'double' and 'enum Unscoped' may be implicitly converted{{$}}
68+
// CHECK-MESSAGES: :[[@LINE-4]]:35: note: 'double' and 'enum Unscoped' may be implicitly converted
6969

7070
void numericConversion8(double D, enum UnscopedFixed UF) { numericConversion8(UF, D); }
7171
// CHECK-MESSAGES: :[[@LINE-1]]:25: warning: 2 adjacent parameters of 'numericConversion8' of convertible types
7272
// CHECK-MESSAGES: :[[@LINE-2]]:32: note: the first parameter in the range is 'D'
7373
// CHECK-MESSAGES: :[[@LINE-3]]:54: note: the last parameter in the range is 'UF'
74-
// CHECK-MESSAGES: :[[@LINE-4]]:35: note: 'double' and 'enum UnscopedFixed' may be implicitly converted{{$}}
74+
// CHECK-MESSAGES: :[[@LINE-4]]:35: note: 'double' and 'enum UnscopedFixed' may be implicitly converted
7575

7676
void pointeeConversion(int *IP, double *DP) { pointeeConversion(DP, IP); }
7777
// NO-WARN: Even though this is possible in C, a swap is diagnosed by the compiler.

0 commit comments

Comments
 (0)