Can't compare unsafe function pointers

[steveklabnik]

Issue by jdm
Monday Apr 07, 2014 at 20:28 GMT

For earlier discussion, see rust-lang/rust#13385

This issue was labelled with: in the Rust repository

---

type JSPropertyOp = extern "C" fn();
type JSPropertyOp2 = extern "C" unsafe fn();

extern fn foo() {
}

fn main() {
    let bar: JSPropertyOp = foo;
    if bar == foo {
    }

    let bar: JSPropertyOp2 = foo;
    if bar == foo {
    }
}

yields

[jdm@rosencrantz rust-mozjs]$ rustc /tmp/unsafe.rs 
/tmp/unsafe.rs:13:8: 13:18 error: binary operation `==` cannot be applied to type `extern "C" unsafe fn()`
/tmp/unsafe.rs:13     if bar == foo {
                         ^~~~~~~~~~
error: aborting due to previous error

[petrochenkov]

If the title is correct, then this is resolved by rust-lang/rust#28268, if the example is correct, then some kind of heterogeneous comparison between safe function items and unsafe function pointers is wanted. The example is probably incorrect.

[gkoz]

Is there a reason extern fn doesn't coerce to unsafe extern fn? If it did would the example work?

[petrochenkov]

@gkoz
extern fn() does coerce to unsafe extern fn(), but:

1. transitive coercions are not implemented, so extern fn() {foo} doesn't coerce to unsafe extern fn() despite extern fn() {foo} coercing to extern fn() and extern fn() coercing to unsafe extern fn().
2. Due to the way how method resolution works arguments of == are not... equal. The coerced argument should be to the right from the operator.

type SafeFnPtr = extern fn();
type UnsafeFnPtr = unsafe extern fn();

extern fn foo() {}

fn main() {
    let a: SafeFnPtr = foo;
    let b: UnsafeFnPtr = a;
    b == a; // Works!
    // a == b; // Doesn't work
}

So, if 1) is fixed, then the @jdm's example should actually work, even if doesn't correspond to the issue title

[gkoz]

@petrochenkov thanks for the clarification!

[petrochenkov]

The example in #718 (comment) compiles now.

[jdm]

It doesn't on the 2/19 nightly. Is there a more recent change that addressed it?

[petrochenkov]

@jdm
It compiles even on stable 1.15 if you fix the incorrect syntax extern "C" unsafe -> unsafe extern "C".

[jdm]

Ah, whoops! This can be closed, in that case.