‘reference to packed field is unaligned’ in nested field of `match` pattern

[Sirraide]

Consider (https://godbolt.org/z/x39GzMKz4):

#[repr(packed)]
#[derive(PartialEq)]
pub struct Packed(i32);

enum Y {
    Foo { id: Packed, },
    Bar(i32)
}

fn pred(_: &i32) -> bool {
    return true;
}

fn f(x: Y) {
    match &x {
        Y::Foo { id: Packed(4), .. } => {},
        Y::Bar(s) if pred(s) => {},
        _ => {}
    }
}

This results in an error:

error[E0793]: reference to packed field is unaligned
  --> <source>:14:11
   |
14 |     match &x {
   |           ^^
   |

I don’t really know what the problem is here, but it might be the match on the id field in the first match arm that triggers the error. Moving Packed(4) into a local variable works, but if I declare it as a const variable instead the error resurfaces. Alternatively, removing the Y::Bar match arm for some reason also makes the error go away.

This currently errors on nightly and some testing on godbolt shows that this code results in an error since Rust 1.62. Before that, we still get the same diagnostic; it’s just treated as a warning instead.

[theemathas]

What do you mean by "Moving Packed(4) into a local variable works"? Could you provide example code?

[Sirraide]

What do you mean by "Moving Packed(4) into a local variable works"? Could you provide example code?

Sure, what I mean is that if I modify f like this, then it compiles just fine (https://godbolt.org/z/cfWoWYPWM):

fn f(x: Y) {
    let foo = Packed(4);
    match &x {
        Y::Foo { id: foo, .. } => {},
        Y::Bar(s) if pred(s) => {},
        _ => {}
    }
}

But if I then replace the let w/ const, it goes back to not compiling.

[theemathas]

This modified code you provided does not do what you want. It declares a second variable also named foo and assigns the contents of the id field to it, regardless of whether it's 4 or some other value.

[Sirraide]

Right, because the behaviour of that syntax is different depending on whether the identifier to the right of the colon names a constant or not; not the first time this has confused me. Well, I suppose that explains why that ‘fixes’ it, but it’s still weird that it errors when I try to match against a constant.

[theemathas]

Smaller reproduction of this issue:

#[repr(packed)]
pub struct Packed(i32);

fn f(x: Packed) {
    match &x {
        Packed(4) => {},
        _ if true => {},
        _ => {}
    }
}

Yes, the if true is needed to reproduce the issue for some reason.

Even changing the code to match x gives the same error???

#[repr(packed)]
pub struct Packed(i32);

fn f(x: Packed) {
    match x {
        Packed(4) => {},
        _ if true => {},
        _ => {}
    }
}