Non-constant repeat count expr causes ICE

[therealgymmy]

Current (minimized) example of breakage:

(courtesy of youknowone; see comments below)

fn main() { let _a = [0, ..1 as uint]; }

Original Report:

The following code causes the crash

enum State { ST_NULL, ST_WHITESPACE }

priv fn SomeFunction () -> StateTable {
    StateTable { entry: ~[mut ~[mut ST_NULL, ..ST_WHITESPACE], ..128] }
}

The error messages are as follows:

error: internal compiler error: unexpected failure
note: the compiler hit an unexpected failure path. this is a bug

It seems that the compiler does not understand entry: ~[mut ~[mut ST_NULL, ..ST_WHITESPACE], ..128].

[catamorphism]

The error happens because you're using ST_WHITESPACE as the repeat count; enum variants are never considered constants, and the repeat count has to be constant. It might be reasonable to consider C-like enums to be constants, but in this case I suspect it's not what you intended.

Of course, the error message needs to be improved. Changing the title to reflect that.

[therealgymmy]

Hi, as I don't see any documentation on this. Is there a way to use an enum (or a similar thing to C enums) as a repeat count (to force it to be a constant)?

[catamorphism]

I tried doing:

enum State { ST_NULL, ST_WHITESPACE }

struct StateTable {
    entry: ~[mut ~[mut State]],
}

priv fn SomeFunction () -> StateTable {
    StateTable { entry: ~[mut ~[mut ST_NULL, ..(ST_WHITESPACE as uint)], ..128] }
}

(note the addition of as uint) -- but that yielded:

error: internal compiler error: node_id_to_type: no type for node `expr ST_WHITESPACE as uint (id=22)`

Noting this so it can be fixed too.

[catamorphism]

I think a better way to do what you're trying to do would be to use the vec::from_elem function.

[catamorphism]

However, as a third thing to fix as part of this bug, I'll note that vector repeat expressions should be documented.

[catamorphism]

For the question of using enums as constants, see #3934

[therealgymmy]

Thanks. :-)

Another thing I want to point out (possibly already pointed out by others) is that there seems to be no way to directly compare two enums.
As in, I cannot do something like if ST_NULL == GetSomeEnum().
I have to explicitly cast enum to some comparable type such as uint, so I have to do this instead if ST_NULL as uint == GetSomeEnum() as uint.

I find this not very intuitive, but I may be missing something here. Again, comparison between enum's don't seem to be documented.

[catamorphism]

At least right now, you have to write an Eq impl if you want equality on a particular enum type. For an example, see src/libcore/option.rs.

Once deriving is fully implemented, this will be easier.

[therealgymmy]

Awesome!
I'm looking forward to the next release :-)

[therealgymmy]

Another internal error related to using enum in an expression expecting constant.

The following code also causes the compiler to emit an internal error

for [0, ..(ST_WHITESPACE as uint + 1)].each |i| {
    // do stuff
}

This is the error message

error: internal compiler error: node_id_to_type:
no type for node `expr ST_WHITESPACE as uint (id=350)`

[youknowone]

Original issue is duplication of #3645

The minimal case of commented new one is:

fn main() { let a = [0, ..1 as uint]; }

[pnkfelix]

Not critical for 0.6; de-milestoning

[pnkfelix]

Despite the claim in an earlier comment that this is a duplicate of #3645 (which was closed), it appears to me like the described minimal case readily duplicates in 0.6 (18fca3e 2013-05-22).

The easy workaround for that minimal case is to use 1u instead of 1 as uint; but the point here really is that there are contexts where one wants to use the cast-expression form for a constant (e.g. an identifier).

[jdm]

One compelling case is that as is necessary for casting an enum to an integer value.