Rollup merge of rust-lang#134536 - Urgau:fn-ptr-option, r=compiler-errors,traviscross

workingjubilee · web-flow · commit 5f6a730d97bc · 2025-06-11T22:11:10.000-07:00
Lint on fn pointers comparisons in external macros This PR extends the recently stabilized `unpredictable_function_pointer_comparisons` lint ~~to also lint on `Option<{function pointer}>` and~~ as well as linting in external macros (as to catch `assert_eq!` and others). ```rust assert_eq!(Some::<FnPtr>(func), Some(func as unsafe extern "C" fn())); //~^ WARN function pointer comparisons #[derive(PartialEq, Eq)] struct A { f: fn(), //~^ WARN function pointer comparisons } ``` Fixes rust-lang#134527
diff --git a/compiler/rustc_lint/src/types.rs b/compiler/rustc_lint/src/types.rs
@@ -196,7 +196,8 @@ declare_lint! {
     /// same address after being merged together.
     UNPREDICTABLE_FUNCTION_POINTER_COMPARISONS,
     Warn,
-    "detects unpredictable function pointer comparisons"
+    "detects unpredictable function pointer comparisons",
+    report_in_external_macro
 }
 
 #[derive(Copy, Clone, Default)]
diff --git a/library/core/src/task/wake.rs b/library/core/src/task/wake.rs
@@ -104,6 +104,7 @@ impl RawWaker {
 /// synchronization. This is because [`LocalWaker`] is not thread safe itself, so it cannot
 /// be sent across threads.
 #[stable(feature = "futures_api", since = "1.36.0")]
+#[cfg_attr(not(bootstrap), allow(unpredictable_function_pointer_comparisons))]
 #[derive(PartialEq, Copy, Clone, Debug)]
 pub struct RawWakerVTable {
     /// This function will be called when the [`RawWaker`] gets cloned, e.g. when
diff --git a/tests/ui/issues/issue-28561.rs b/tests/ui/issues/issue-28561.rs
@@ -37,6 +37,7 @@ struct Array<T> {
 }
 
 #[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
+#[allow(unpredictable_function_pointer_comparisons)]
 struct Fn<A, B, C, D, E, F, G, H, I, J, K, L> {
     f00: fn(),
     f01: fn(A),
diff --git a/tests/ui/lint/fn-ptr-comparisons-some.rs b/tests/ui/lint/fn-ptr-comparisons-some.rs
@@ -12,6 +12,6 @@ fn main() {
     let _ = Some::<FnPtr>(func) == Some(func as unsafe extern "C" fn());
     //~^ WARN function pointer comparisons
 
-    // Undecided as of https://github.com/rust-lang/rust/pull/134536
     assert_eq!(Some::<FnPtr>(func), Some(func as unsafe extern "C" fn()));
+    //~^ WARN function pointer comparisons
 }
diff --git a/tests/ui/lint/fn-ptr-comparisons-some.stderr b/tests/ui/lint/fn-ptr-comparisons-some.stderr
@@ -9,5 +9,16 @@ LL |     let _ = Some::<FnPtr>(func) == Some(func as unsafe extern "C" fn());
    = note: for more information visit <https://doc.rust-lang.org/nightly/core/ptr/fn.fn_addr_eq.html>
    = note: `#[warn(unpredictable_function_pointer_comparisons)]` on by default
 
-warning: 1 warning emitted
+warning: function pointer comparisons do not produce meaningful results since their addresses are not guaranteed to be unique
+  --> $DIR/fn-ptr-comparisons-some.rs:15:5
+   |
+LL |     assert_eq!(Some::<FnPtr>(func), Some(func as unsafe extern "C" fn()));
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+   = note: the address of the same function can vary between different codegen units
+   = note: furthermore, different functions could have the same address after being merged together
+   = note: for more information visit <https://doc.rust-lang.org/nightly/core/ptr/fn.fn_addr_eq.html>
+   = note: this warning originates in the macro `assert_eq` (in Nightly builds, run with -Z macro-backtrace for more info)
+
+warning: 2 warnings emitted
 
diff --git a/tests/ui/lint/fn-ptr-comparisons-weird.rs b/tests/ui/lint/fn-ptr-comparisons-weird.rs
@@ -1,5 +1,23 @@
 //@ check-pass
 
+#[derive(PartialEq, Eq)]
+struct A {
+    f: fn(),
+    //~^ WARN function pointer comparisons
+}
+
+#[allow(unpredictable_function_pointer_comparisons)]
+#[derive(PartialEq, Eq)]
+struct AllowedAbove {
+    f: fn(),
+}
+
+#[derive(PartialEq, Eq)]
+#[allow(unpredictable_function_pointer_comparisons)]
+struct AllowedBelow {
+    f: fn(),
+}
+
 fn main() {
     let f: fn() = main;
     let g: fn() = main;
@@ -12,4 +30,8 @@ fn main() {
     //~^ WARN function pointer comparisons
     let _ = f < g;
     //~^ WARN function pointer comparisons
+    let _ = assert_eq!(g, g);
+    //~^ WARN function pointer comparisons
+    let _ = assert_ne!(g, g);
+    //~^ WARN function pointer comparisons
 }
diff --git a/tests/ui/lint/fn-ptr-comparisons-weird.stderr b/tests/ui/lint/fn-ptr-comparisons-weird.stderr
@@ -1,16 +1,29 @@
 warning: function pointer comparisons do not produce meaningful results since their addresses are not guaranteed to be unique
-  --> $DIR/fn-ptr-comparisons-weird.rs:7:13
+  --> $DIR/fn-ptr-comparisons-weird.rs:5:5
+   |
+LL | #[derive(PartialEq, Eq)]
+   |          --------- in this derive macro expansion
+LL | struct A {
+LL |     f: fn(),
+   |     ^^^^^^^
+   |
+   = note: the address of the same function can vary between different codegen units
+   = note: furthermore, different functions could have the same address after being merged together
+   = note: for more information visit <https://doc.rust-lang.org/nightly/core/ptr/fn.fn_addr_eq.html>
+   = note: `#[warn(unpredictable_function_pointer_comparisons)]` on by default
+
+warning: function pointer comparisons do not produce meaningful results since their addresses are not guaranteed to be unique
+  --> $DIR/fn-ptr-comparisons-weird.rs:25:13
    |
 LL |     let _ = f > g;
    |             ^^^^^
    |
    = note: the address of the same function can vary between different codegen units
    = note: furthermore, different functions could have the same address after being merged together
    = note: for more information visit <https://doc.rust-lang.org/nightly/core/ptr/fn.fn_addr_eq.html>
-   = note: `#[warn(unpredictable_function_pointer_comparisons)]` on by default
 
 warning: function pointer comparisons do not produce meaningful results since their addresses are not guaranteed to be unique
-  --> $DIR/fn-ptr-comparisons-weird.rs:9:13
+  --> $DIR/fn-ptr-comparisons-weird.rs:27:13
    |
 LL |     let _ = f >= g;
    |             ^^^^^^
@@ -20,7 +33,7 @@ LL |     let _ = f >= g;
    = note: for more information visit <https://doc.rust-lang.org/nightly/core/ptr/fn.fn_addr_eq.html>
 
 warning: function pointer comparisons do not produce meaningful results since their addresses are not guaranteed to be unique
-  --> $DIR/fn-ptr-comparisons-weird.rs:11:13
+  --> $DIR/fn-ptr-comparisons-weird.rs:29:13
    |
 LL |     let _ = f <= g;
    |             ^^^^^^
@@ -30,7 +43,7 @@ LL |     let _ = f <= g;
    = note: for more information visit <https://doc.rust-lang.org/nightly/core/ptr/fn.fn_addr_eq.html>
 
 warning: function pointer comparisons do not produce meaningful results since their addresses are not guaranteed to be unique
-  --> $DIR/fn-ptr-comparisons-weird.rs:13:13
+  --> $DIR/fn-ptr-comparisons-weird.rs:31:13
    |
 LL |     let _ = f < g;
    |             ^^^^^
@@ -39,5 +52,27 @@ LL |     let _ = f < g;
    = note: furthermore, different functions could have the same address after being merged together
    = note: for more information visit <https://doc.rust-lang.org/nightly/core/ptr/fn.fn_addr_eq.html>
 
-warning: 4 warnings emitted
+warning: function pointer comparisons do not produce meaningful results since their addresses are not guaranteed to be unique
+  --> $DIR/fn-ptr-comparisons-weird.rs:33:13
+   |
+LL |     let _ = assert_eq!(g, g);
+   |             ^^^^^^^^^^^^^^^^
+   |
+   = note: the address of the same function can vary between different codegen units
+   = note: furthermore, different functions could have the same address after being merged together
+   = note: for more information visit <https://doc.rust-lang.org/nightly/core/ptr/fn.fn_addr_eq.html>
+   = note: this warning originates in the macro `assert_eq` (in Nightly builds, run with -Z macro-backtrace for more info)
+
+warning: function pointer comparisons do not produce meaningful results since their addresses are not guaranteed to be unique
+  --> $DIR/fn-ptr-comparisons-weird.rs:35:13
+   |
+LL |     let _ = assert_ne!(g, g);
+   |             ^^^^^^^^^^^^^^^^
+   |
+   = note: the address of the same function can vary between different codegen units
+   = note: furthermore, different functions could have the same address after being merged together
+   = note: for more information visit <https://doc.rust-lang.org/nightly/core/ptr/fn.fn_addr_eq.html>
+   = note: this warning originates in the macro `assert_ne` (in Nightly builds, run with -Z macro-backtrace for more info)
+
+warning: 7 warnings emitted
 
diff --git a/tests/ui/lint/fn-ptr-comparisons.fixed b/tests/ui/lint/fn-ptr-comparisons.fixed
@@ -11,7 +11,6 @@ extern "C" fn c() {}
 
 extern "C" fn args(_a: i32) -> i32 { 0 }
 
-#[derive(PartialEq, Eq)]
 struct A {
     f: fn(),
 }
@@ -52,7 +51,6 @@ fn main() {
     let _ = std::ptr::fn_addr_eq(t, test as unsafe extern "C" fn());
     //~^ WARN function pointer comparisons
 
-    let _ = a1 == a2; // should not warn
     let _ = std::ptr::fn_addr_eq(a1.f, a2.f);
     //~^ WARN function pointer comparisons
 }
diff --git a/tests/ui/lint/fn-ptr-comparisons.rs b/tests/ui/lint/fn-ptr-comparisons.rs
@@ -11,7 +11,6 @@ extern "C" fn c() {}
 
 extern "C" fn args(_a: i32) -> i32 { 0 }
 
-#[derive(PartialEq, Eq)]
 struct A {
     f: fn(),
 }
@@ -52,7 +51,6 @@ fn main() {
     let _ = t == test;
     //~^ WARN function pointer comparisons
 
-    let _ = a1 == a2; // should not warn
     let _ = a1.f == a2.f;
     //~^ WARN function pointer comparisons
 }
diff --git a/tests/ui/lint/fn-ptr-comparisons.stderr b/tests/ui/lint/fn-ptr-comparisons.stderr
@@ -1,5 +1,5 @@
 warning: function pointer comparisons do not produce meaningful results since their addresses are not guaranteed to be unique
-  --> $DIR/fn-ptr-comparisons.rs:26:13
+  --> $DIR/fn-ptr-comparisons.rs:25:13
    |
 LL |     let _ = f == a;
    |             ^^^^^^
@@ -15,7 +15,7 @@ LL +     let _ = std::ptr::fn_addr_eq(f, a as fn());
    |
 
 warning: function pointer comparisons do not produce meaningful results since their addresses are not guaranteed to be unique
-  --> $DIR/fn-ptr-comparisons.rs:28:13
+  --> $DIR/fn-ptr-comparisons.rs:27:13
    |
 LL |     let _ = f != a;
    |             ^^^^^^
@@ -30,7 +30,7 @@ LL +     let _ = !std::ptr::fn_addr_eq(f, a as fn());
    |
 
 warning: function pointer comparisons do not produce meaningful results since their addresses are not guaranteed to be unique
-  --> $DIR/fn-ptr-comparisons.rs:30:13
+  --> $DIR/fn-ptr-comparisons.rs:29:13
    |
 LL |     let _ = f == g;
    |             ^^^^^^
@@ -45,7 +45,7 @@ LL +     let _ = std::ptr::fn_addr_eq(f, g);
    |
 
 warning: function pointer comparisons do not produce meaningful results since their addresses are not guaranteed to be unique
-  --> $DIR/fn-ptr-comparisons.rs:32:13
+  --> $DIR/fn-ptr-comparisons.rs:31:13
    |
 LL |     let _ = f == f;
    |             ^^^^^^
@@ -60,7 +60,7 @@ LL +     let _ = std::ptr::fn_addr_eq(f, f);
    |
 
 warning: function pointer comparisons do not produce meaningful results since their addresses are not guaranteed to be unique
-  --> $DIR/fn-ptr-comparisons.rs:34:13
+  --> $DIR/fn-ptr-comparisons.rs:33:13
    |
 LL |     let _ = g == g;
    |             ^^^^^^
@@ -75,7 +75,7 @@ LL +     let _ = std::ptr::fn_addr_eq(g, g);
    |
 
 warning: function pointer comparisons do not produce meaningful results since their addresses are not guaranteed to be unique
-  --> $DIR/fn-ptr-comparisons.rs:36:13
+  --> $DIR/fn-ptr-comparisons.rs:35:13
    |
 LL |     let _ = g == g;
    |             ^^^^^^
@@ -90,7 +90,7 @@ LL +     let _ = std::ptr::fn_addr_eq(g, g);
    |
 
 warning: function pointer comparisons do not produce meaningful results since their addresses are not guaranteed to be unique
-  --> $DIR/fn-ptr-comparisons.rs:38:13
+  --> $DIR/fn-ptr-comparisons.rs:37:13
    |
 LL |     let _ = &g == &g;
    |             ^^^^^^^^
@@ -105,7 +105,7 @@ LL +     let _ = std::ptr::fn_addr_eq(g, g);
    |
 
 warning: function pointer comparisons do not produce meaningful results since their addresses are not guaranteed to be unique
-  --> $DIR/fn-ptr-comparisons.rs:40:13
+  --> $DIR/fn-ptr-comparisons.rs:39:13
    |
 LL |     let _ = a as fn() == g;
    |             ^^^^^^^^^^^^^^
@@ -120,7 +120,7 @@ LL +     let _ = std::ptr::fn_addr_eq(a as fn(), g);
    |
 
 warning: function pointer comparisons do not produce meaningful results since their addresses are not guaranteed to be unique
-  --> $DIR/fn-ptr-comparisons.rs:44:13
+  --> $DIR/fn-ptr-comparisons.rs:43:13
    |
 LL |     let _ = cfn == c;
    |             ^^^^^^^^
@@ -135,7 +135,7 @@ LL +     let _ = std::ptr::fn_addr_eq(cfn, c as extern "C" fn());
    |
 
 warning: function pointer comparisons do not produce meaningful results since their addresses are not guaranteed to be unique
-  --> $DIR/fn-ptr-comparisons.rs:48:13
+  --> $DIR/fn-ptr-comparisons.rs:47:13
    |
 LL |     let _ = argsfn == args;
    |             ^^^^^^^^^^^^^^
@@ -150,7 +150,7 @@ LL +     let _ = std::ptr::fn_addr_eq(argsfn, args as extern "C" fn(i32) -> i32)
    |
 
 warning: function pointer comparisons do not produce meaningful results since their addresses are not guaranteed to be unique
-  --> $DIR/fn-ptr-comparisons.rs:52:13
+  --> $DIR/fn-ptr-comparisons.rs:51:13
    |
 LL |     let _ = t == test;
    |             ^^^^^^^^^
@@ -165,7 +165,7 @@ LL +     let _ = std::ptr::fn_addr_eq(t, test as unsafe extern "C" fn());
    |
 
 warning: function pointer comparisons do not produce meaningful results since their addresses are not guaranteed to be unique
-  --> $DIR/fn-ptr-comparisons.rs:56:13
+  --> $DIR/fn-ptr-comparisons.rs:54:13
    |
 LL |     let _ = a1.f == a2.f;
    |             ^^^^^^^^^^^^
diff --git a/tests/ui/mir/mir_refs_correct.rs b/tests/ui/mir/mir_refs_correct.rs
@@ -1,6 +1,8 @@
 //@ run-pass
 //@ aux-build:mir_external_refs.rs
 
+#![allow(unpredictable_function_pointer_comparisons)]
+
 extern crate mir_external_refs as ext;
 
 struct S(#[allow(dead_code)] u8);
diff --git a/tests/ui/nullable-pointer-iotareduction.rs b/tests/ui/nullable-pointer-iotareduction.rs
@@ -8,6 +8,8 @@
 // trying to get assert failure messages that at least identify which case
 // failed.
 
+#![allow(unpredictable_function_pointer_comparisons)]
+
 enum E<T> { Thing(isize, T), #[allow(dead_code)] Nothing((), ((), ()), [i8; 0]) }
 impl<T> E<T> {
     fn is_none(&self) -> bool {

Original file line number	Diff line number	Diff line change
`@@ -196,7 +196,8 @@ declare_lint! {`
`196`	`196`	`/// same address after being merged together.`
`197`	`197`	`UNPREDICTABLE_FUNCTION_POINTER_COMPARISONS,`
`198`	`198`	`Warn,`
`199`		`- "detects unpredictable function pointer comparisons"`
	`199`	`+ "detects unpredictable function pointer comparisons",`
	`200`	`+ report_in_external_macro`
`200`	`201`	`}`
`201`	`202`
`202`	`203`	`#[derive(Copy, Clone, Default)]`
Original file line number	Diff line number	Diff line change
`@@ -37,6 +37,7 @@ struct Array<T> {`
`37`	`37`	`}`
`38`	`38`
`39`	`39`	`#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]`
	`40`	`+#[allow(unpredictable_function_pointer_comparisons)]`
`40`	`41`	`struct Fn<A, B, C, D, E, F, G, H, I, J, K, L> {`
`41`	`42`	`f00: fn(),`
`42`	`43`	`f01: fn(A),`
Original file line number	Diff line number	Diff line change
`@@ -12,6 +12,6 @@ fn main() {`
`12`	`12`	`let _ = Some::<FnPtr>(func) == Some(func as unsafe extern "C" fn());`
`13`	`13`	`//~^ WARN function pointer comparisons`
`14`	`14`
`15`		`- // Undecided as of https://github.com/rust-lang/rust/pull/134536`
`16`	`15`	`assert_eq!(Some::<FnPtr>(func), Some(func as unsafe extern "C" fn()));`
	`16`	`+ //~^ WARN function pointer comparisons`
`17`	`17`	`}`
Original file line number	Diff line number	Diff line change
`@@ -11,7 +11,6 @@ extern "C" fn c() {}`
`11`	`11`
`12`	`12`	`extern "C" fn args(_a: i32) -> i32 { 0 }`
`13`	`13`
`14`		`-#[derive(PartialEq, Eq)]`
`15`	`14`	`struct A {`
`16`	`15`	`f: fn(),`
`17`	`16`	`}`
`@@ -52,7 +51,6 @@ fn main() {`
`52`	`51`	`let _ = std::ptr::fn_addr_eq(t, test as unsafe extern "C" fn());`
`53`	`52`	`//~^ WARN function pointer comparisons`
`54`	`53`
`55`		`- let _ = a1 == a2; // should not warn`
`56`	`54`	`let _ = std::ptr::fn_addr_eq(a1.f, a2.f);`
`57`	`55`	`//~^ WARN function pointer comparisons`
`58`	`56`	`}`
Original file line number	Diff line number	Diff line change
`@@ -1,5 +1,5 @@`
`1`	`1`	`warning: function pointer comparisons do not produce meaningful results since their addresses are not guaranteed to be unique`
`2`		`- --> $DIR/fn-ptr-comparisons.rs:26:13`
	`2`	`+ --> $DIR/fn-ptr-comparisons.rs:25:13`
`3`	`3`	`\|`
`4`	`4`	`LL \| let _ = f == a;`
`5`	`5`	`\| ^^^^^^`
`@@ -15,7 +15,7 @@ LL + let _ = std::ptr::fn_addr_eq(f, a as fn());`
`15`	`15`	`\|`
`16`	`16`
`17`	`17`	`warning: function pointer comparisons do not produce meaningful results since their addresses are not guaranteed to be unique`
`18`		`- --> $DIR/fn-ptr-comparisons.rs:28:13`
	`18`	`+ --> $DIR/fn-ptr-comparisons.rs:27:13`
`19`	`19`	`\|`
`20`	`20`	`LL \| let _ = f != a;`
`21`	`21`	`\| ^^^^^^`
`@@ -30,7 +30,7 @@ LL + let _ = !std::ptr::fn_addr_eq(f, a as fn());`
`30`	`30`	`\|`
`31`	`31`
`32`	`32`	`warning: function pointer comparisons do not produce meaningful results since their addresses are not guaranteed to be unique`
`33`		`- --> $DIR/fn-ptr-comparisons.rs:30:13`
	`33`	`+ --> $DIR/fn-ptr-comparisons.rs:29:13`
`34`	`34`	`\|`
`35`	`35`	`LL \| let _ = f == g;`
`36`	`36`	`\| ^^^^^^`
`@@ -45,7 +45,7 @@ LL + let _ = std::ptr::fn_addr_eq(f, g);`
`45`	`45`	`\|`
`46`	`46`
`47`	`47`	`warning: function pointer comparisons do not produce meaningful results since their addresses are not guaranteed to be unique`
`48`		`- --> $DIR/fn-ptr-comparisons.rs:32:13`
	`48`	`+ --> $DIR/fn-ptr-comparisons.rs:31:13`
`49`	`49`	`\|`
`50`	`50`	`LL \| let _ = f == f;`
`51`	`51`	`\| ^^^^^^`
`@@ -60,7 +60,7 @@ LL + let _ = std::ptr::fn_addr_eq(f, f);`
`60`	`60`	`\|`
`61`	`61`
`62`	`62`	`warning: function pointer comparisons do not produce meaningful results since their addresses are not guaranteed to be unique`
`63`		`- --> $DIR/fn-ptr-comparisons.rs:34:13`
	`63`	`+ --> $DIR/fn-ptr-comparisons.rs:33:13`
`64`	`64`	`\|`
`65`	`65`	`LL \| let _ = g == g;`
`66`	`66`	`\| ^^^^^^`
`@@ -75,7 +75,7 @@ LL + let _ = std::ptr::fn_addr_eq(g, g);`
`75`	`75`	`\|`
`76`	`76`
`77`	`77`	`warning: function pointer comparisons do not produce meaningful results since their addresses are not guaranteed to be unique`
`78`		`- --> $DIR/fn-ptr-comparisons.rs:36:13`
	`78`	`+ --> $DIR/fn-ptr-comparisons.rs:35:13`
`79`	`79`	`\|`
`80`	`80`	`LL \| let _ = g == g;`
`81`	`81`	`\| ^^^^^^`
`@@ -90,7 +90,7 @@ LL + let _ = std::ptr::fn_addr_eq(g, g);`
`90`	`90`	`\|`
`91`	`91`
`92`	`92`	`warning: function pointer comparisons do not produce meaningful results since their addresses are not guaranteed to be unique`
`93`		`- --> $DIR/fn-ptr-comparisons.rs:38:13`
	`93`	`+ --> $DIR/fn-ptr-comparisons.rs:37:13`
`94`	`94`	`\|`
`95`	`95`	`LL \| let _ = &g == &g;`
`96`	`96`	`\| ^^^^^^^^`
`@@ -105,7 +105,7 @@ LL + let _ = std::ptr::fn_addr_eq(g, g);`
`105`	`105`	`\|`
`106`	`106`
`107`	`107`	`warning: function pointer comparisons do not produce meaningful results since their addresses are not guaranteed to be unique`
`108`		`- --> $DIR/fn-ptr-comparisons.rs:40:13`
	`108`	`+ --> $DIR/fn-ptr-comparisons.rs:39:13`
`109`	`109`	`\|`
`110`	`110`	`LL \| let _ = a as fn() == g;`
`111`	`111`	`\| ^^^^^^^^^^^^^^`
`@@ -120,7 +120,7 @@ LL + let _ = std::ptr::fn_addr_eq(a as fn(), g);`
`120`	`120`	`\|`
`121`	`121`
`122`	`122`	`warning: function pointer comparisons do not produce meaningful results since their addresses are not guaranteed to be unique`
`123`		`- --> $DIR/fn-ptr-comparisons.rs:44:13`
	`123`	`+ --> $DIR/fn-ptr-comparisons.rs:43:13`
`124`	`124`	`\|`
`125`	`125`	`LL \| let _ = cfn == c;`
`126`	`126`	`\| ^^^^^^^^`
`@@ -135,7 +135,7 @@ LL + let _ = std::ptr::fn_addr_eq(cfn, c as extern "C" fn());`
`135`	`135`	`\|`
`136`	`136`
`137`	`137`	`warning: function pointer comparisons do not produce meaningful results since their addresses are not guaranteed to be unique`
`138`		`- --> $DIR/fn-ptr-comparisons.rs:48:13`
	`138`	`+ --> $DIR/fn-ptr-comparisons.rs:47:13`
`139`	`139`	`\|`
`140`	`140`	`LL \| let _ = argsfn == args;`
`141`	`141`	`\| ^^^^^^^^^^^^^^`
`@@ -150,7 +150,7 @@ LL + let _ = std::ptr::fn_addr_eq(argsfn, args as extern "C" fn(i32) -> i32)`
`150`	`150`	`\|`
`151`	`151`
`152`	`152`	`warning: function pointer comparisons do not produce meaningful results since their addresses are not guaranteed to be unique`
`153`		`- --> $DIR/fn-ptr-comparisons.rs:52:13`
	`153`	`+ --> $DIR/fn-ptr-comparisons.rs:51:13`
`154`	`154`	`\|`
`155`	`155`	`LL \| let _ = t == test;`
`156`	`156`	`\| ^^^^^^^^^`
`@@ -165,7 +165,7 @@ LL + let _ = std::ptr::fn_addr_eq(t, test as unsafe extern "C" fn());`
`165`	`165`	`\|`
`166`	`166`
`167`	`167`	`warning: function pointer comparisons do not produce meaningful results since their addresses are not guaranteed to be unique`
`168`		`- --> $DIR/fn-ptr-comparisons.rs:56:13`
	`168`	`+ --> $DIR/fn-ptr-comparisons.rs:54:13`
`169`	`169`	`\|`
`170`	`170`	`LL \| let _ = a1.f == a2.f;`
`171`	`171`	`\| ^^^^^^^^^^^^`