"as uint" works on bare constructors of non-C-like enums

[kmcallister]

rustc 0.13.0-dev (222ae8b 2014-10-18 00:47:22 +0000)

enum Tag {
    Dynamic,
    Inline(u8),
    Static,
}

#[test]
fn f() {
    assert_eq!(Inline as uint, 1);
}

compiles and produces

task 'f' failed at 'assertion failed: `(left == right) && (right == left)` (left: `140041300628448`, right: `1`)', foo.rs:9

I think it's casting the constructor function itself as a function pointer? But this is super confusing behavior (caused a segfault in unsafe code) when I just refactored an enum to be not C-like and I want to get rid of remaining occurrences of as uint.

Also it doesn't warn for as u8, even though it's too small for a function pointer.

[kmcallister]

Nominating.

[kmcallister]

Casting the nullary constructors is already forbidden.

[kmcallister]

Hm, I now feel like this should be a lint, because it's a kind of heuristic syntactic thing rather than a typechecking rule. We would reasonably expect this code to work:

let f: fn(u8) -> Tag = Inline;
// ...
let n = f as uint;

Only when a literal enum constructor appears in the cast can we reasonably guess that the behavior is unintended.

[brson]

P-high, not 1.0. Ugly wart, and we'd love someone to fix.

[nikomatsakis]

One possible solution is restricting casts from function pointers to uint. We could just say that is not legal but it is legal to cast to a function pointer to an unsafe pointer, and then (continue to) permit unsafe pointers to cast to uints.

One of the main reasons we allow these wacky casts with as, for reference, is constant expressions, where transmute is not possible.

[bombless]

One possible solution is restricting casts from function pointers to uint. We could just say that is not legal but it is legal to cast to a function pointer to an unsafe pointer, and then (continue to) permit unsafe pointers to cast to uints.

+1 for this, but I guess it's too late for 1.0.x