Matching struct-like enum with wildcard is broken

[gifnksm]

fun1 and fun2 should return same value.

enum Enum {
    Foo { foo: uint },
    Bar { bar: uint }
}

fn fun1(e1: &Enum, e2: &Enum) -> uint {
    match (e1, e2) {
        (&Foo { foo: _ }, &Foo { foo: _ }) => 0,
        (&Foo { foo: _ }, &Bar { bar: _ }) => 1,
        (&Bar { bar: _ }, &Bar { bar: _ }) => 2,
        (&Bar { bar: _ }, &Foo { foo: _ }) => 3,
    }
}

fn fun2(e1: &Enum, e2: &Enum) -> uint {
    match (e1, e2) {
        (&Foo { foo: _ }, &Foo { foo: _ }) => 0,
        (&Foo { foo: _ }, _              ) => 1,
        (&Bar { bar: _ }, &Bar { bar: _ }) => 2,
        (&Bar { bar: _ }, _              ) => 3,
    }
}

fn main() {
    let foo = Foo { foo: 1 };
    let bar = Bar { bar: 1 };

    assert_eq!(fun1(&foo, &foo), 0);
    assert_eq!(fun1(&foo, &bar), 1);
    assert_eq!(fun1(&bar, &bar), 2);
    assert_eq!(fun1(&bar, &foo), 3);

    assert_eq!(fun2(&foo, &foo), 0);
    assert_eq!(fun2(&foo, &bar), 1); // fun2 returns 0
    assert_eq!(fun2(&bar, &bar), 2);
    assert_eq!(fun2(&bar, &foo), 3); // fun2 returns 2
}

$ ./test
rust: task failed at 'expected: 1, given: 0', ./test.rs:34
rust: domain main @0x25b79c0 root task failed

[catamorphism]

This works now. I'll check in the test case.

[catamorphism]

Hmm, it passed for me but failed on the Linux bot. Nominating for milestone 5, production-ready

[pnkfelix]

I get a failure on Mac OS X:

% ./iss5530-a
rust: task failed at 'left: 0 does not equal right: 1', iss5530-a.rs:34
rust: domain main @0x7fb6f2813c10 root task failed

(line 34 is the case: assert_eq!(fun2(&foo, &bar), 1); // fun2 returns 0)

[smvv]

The following program fails: the match returns true, but should return false.

enum AB {
    None,
    A { a: int },
    B { b: int }
}

fn main() {
    let b = Some(B {b: 1});
    assert!(!match b {
        Some(A { a: _ }) => true,
        _ => false
    })
}

I believe the cause of the failure is similar to the failures described in this issue.

[graydon]

Incoming PR, will fix when landed (hopefully)