False positive with trivially_copy_pass_by_ref

[XAMPPRocky]

The following code falsely assumes that value can be converted from reference to value when the value is returned as a reference by the function.

https://github.com/CraneStation/cranelift/blob/01de6842b1a3230db645a00f4ecf0176b5fdc65f/lib/codegen/src/regalloc/virtregs.rs#L100-L106

ref_slice

https://github.com/CraneStation/cranelift/blob/fb4acf8b5aaf63a96b9364d9b6f8d373fd8913c8/lib/codegen/src/ref_slice.rs#L12-L14

[flip1995]

See #2951. It's partially fixed and the bug you're describing is (will be) in the known problems section of the lint. Still a bug though, that needs to be fixed somtimes.

I don't see a problem with the second link you posted?

[XAMPPRocky]

@flip1995 There's no problem with the second line of code, I just wanted to provide the context of what the signature of ref_slice which uses value was.

[mati865]

False positive in Rust code:
https://github.com/rust-lang/rust/blob/master/src/libcore/fmt/mod.rs#L271-L273

    fn show_usize(x: &usize, f: &mut Formatter<'_>) -> Result {
        Display::fmt(x, f)
    }

The error:

warning: this argument (8 byte) is passed by reference, but would be more efficient if passed by value (limit: 8 byte)
   --> src/libcore/fmt/mod.rs:271:22
    |
271 |     fn show_usize(x: &usize, f: &mut Formatter<'_>) -> Result {
    |                      ^^^^^^ help: consider passing by value instead: `usize`
    |
    = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#trivially_copy_pass_by_ref

Display::fmt definition:
https://github.com/rust-lang/rust/blob/a24f636e60a5da57ab641d800ac5952bbde98b65/src/libcore/fmt/mod.rs#L631

fn fmt(&self, f: &mut Formatter<'_>) -> Result;

Quoting @eddyb from Discord:

is this tripping a lint?
if so it should look at the lifetime and check if the lifetime is in the return type
because then it probably matters for the argument to be by-ref

[eddyb]

@mati865 In that case, the x: &usize doesn't actually have any lifetime relationships (between arguments and return type), so what I was saying is inapplicable.

What's happening is that we need that signature elsewhere (because we turn that function into a pointer). It should #[allow] the lint (which is fair given how much of a hack show_usize actually is).

[RobbieClarken]

Possibly related false positive when a function is async (playground):

pub async fn foo(x: &u8) -> &u8 { x }

This code fails trivially_copy_pass_by_ref but only if the function is async.