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 1 commit
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
14 changes: 7 additions & 7 deletions clang-tools-extra/test/clang-tidy/checkers/bugprone/easily-swappable-parameters-implicits.c
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -30,19 +30,19 @@ void numericConversion1(int I, double D) { numericConversion1(D, I); }
// CHECK-MESSAGES: :[[@LINE-1]]:25: warning: 2 adjacent parameters of 'numericConversion1' of convertible types are easily swapped by mistake [bugprone-easily-swappable-parameters]
// CHECK-MESSAGES: :[[@LINE-2]]:29: note: the first parameter in the range is 'I'
// CHECK-MESSAGES: :[[@LINE-3]]:39: note: the last parameter in the range is 'D'
// CHECK-MESSAGES: :[[@LINE-4]]:32: note: 'int' and 'double' may be implicitly converted{{$}}
// CHECK-MESSAGES: :[[@LINE-4]]:32: note: 'int' and 'double' may be implicitly converted

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

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

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

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

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

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

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