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.

[pnkfelix]

Visiting for bug triage, email 2013-07-29

The enumVariant as uint case described by jdm is semi-addressed by ba9c3eb

But this is nonetheless still a bug.

[alexcrichton]

The test case of

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

now passes, but I was unable to get the test case of

enum State { ST_NULL, ST_WHITESPACE }

fn SomeFunction () {
    ~[ST_NULL, ..(ST_WHITESPACE as uint)];
}

fn main() {}

so this may still be an open issue. The error I'm getting is:

foo.rs:4:17: 4:41 error: expected constant integer for repeat count but found variable

[pnkfelix]

If one explicitly initializes the enum values for State, then the code compiles:

enum State { ST_NULL = 0, ST_WHITESPACE=1 }

fn SomeFunction () {
    ~[ST_NULL, ..(ST_WHITESPACE as uint)];
}

fn main() {}

I claim that this strikes the right balance, and thus this issue can probably be closed.

[catamorphism]

This appears to be fixed -- adding needstest label. (I think the "error: expected constant integer for repeat count but found variable" should be a compile-fail test, and Felix's example can be the run-pass test.)

[omasanori]

I tried to add test cases for this issue and found that ST_NULL = 0 is not needed to pass the code. The code:

enum State { ST_NULL, ST_WHITESPACE=1 }
// ...

seems enough. Is it correct?