Allow coercions from statically sized to dynamically sized arrays

[nrc]

The following should be valid:

fn coerce1(x: &[int, ..5]) {
    let y = x as &[int];
}
fn coerce2(x: ~[int, ..5]) {
    let y = x as ~[int];
}

[aturon]

I wanted to clarify something about the plan with DST. Currently, we allow a third variant of the above:

fn use_slice(s: &[u8]) {}
fn main() {
    let s: [u8, ..3] = [0,1,2];
    use_slice(s);
}

In other words, we coerce from [T, ..n] to &[T]. This rule is inconsistent with our general move away from auto-borrowing coercions.

My question is: as part of the DST coercion work, are you planning to remove this coercion?

Alternatively, I wonder if it might make sense to replace this coercion with &[T, ..n] to &[T] separately from DST, just as we've been removing various other coercions like auto-cross-borrowing to front-load breaking changes?

cc @nikomatsakis @pcwalton

[nikomatsakis]

I believe we should not coerce from [T, ..n] to &[T] but instead just &[T, ..n] to &[T] (that is, the usual sized-to-unsized coercion). It does mean that foo([1, 2, 3]) becomes foo(&[1, 2, 3]), but that seems more consistent with everything else in the language. If we wanted to address the need to write things like map.find(&3), it seems like the right way to do that is across the board with some sort of "autoref" coercion.

[nrc]

This work has landed now.

re the [T, ..n] to &[T] coercion: I agree we should remove it. That is part of a WIP RFC covering coercions which should arrive soon.