Another false positive: `match_same_arms` vs. `&Any`

[llogiq]

If the two arms do not have the same actual type, pulling them together with | will fail. The lint should not trigger if the actual types of the match arms differ.

E.g.

enum Foo<'a> {
    Bar(&'a FooBar),
    Baz(&'a Buzz),
}

let x: &Any = match foo {
    Bar(ref bar) => bar,
    Baz(ref bar) => bar,
}

Changing it to

let x: &Any = match foo {
    Bar(ref bar) |
    Baz(ref bar) => bar,
}

will fail with a type error.

[mcarton]

Weird, I'm pretty sure types are checked exactly for that kind of things.

[mcarton]

Found it: https://github.com/Manishearth/rust-clippy/blob/master/tests/compile-fail/copies.rs#L273-L277

(took me much longer than I like to admit to find something I wrote 😅)

[llogiq]

There's a difference in that different types are usually not returned from the match – in fact the type system usually doesn't permit it. However there's the &Any escape hatch, which your test does not appear to cover; your bar(T) function is generic, not dynamic (I'm not sure if the problem lies with the dynamic dispatch or with returning a ref to a potentially unsized value).

[mcarton]

Yup, I was just pointing out the insufficient test.

[mcarton]

@llogiq can you provide a MCVE? I can't reproduce.

[PartiallyUntyped]

This is the closest I could get to reproducing it maybe I am missing something?

use std::any::*;

#[derive(Debug)]
struct FooBar;
#[derive(Debug)]
struct Buzz;

enum Foo<'a> {
    Bar(&'a FooBar),
    Baz(&'a Buzz),
}


fn main() {
    let fb = FooBar{};
    let _ = Foo::Baz(&Buzz{});
    let x: &dyn Any = match Foo::Bar(&fb) {
        Foo::Bar(bar) => bar as &dyn Any,
        Foo::Baz(bar) => bar as &dyn Any,
    };
    println!("{:?}", x);
}

https://play.rust-lang.org/?version=stable&mode=debug&edition=2021&gist=b9738d5a54c5980a3e97727b6a6e8310

[samueltardieu]

I can't reproduce it.

Can we close this, or add a reproducer?