"this expression will panic at run-time" warnings can't be suppressed

[emilio]

Here's a reduced test-case:

let a = [0u8; 2usize];
println!("{}", a[0]);
println!("{}", a[1]);

if a.len() == 3 {
    println!("{}", a[2]);
}

Now some background.

In Servo we generate large amounts of rust code using different systems. Today @upsuper was trying to generate shared code for two different structs that have different fields, let's simplify it as:

struct Foo {
    bar: [u8; 2],
}

struct Bar {
    bar: [u8; 3],
}

To generate shared code for both, he wanted to do something like:

let instance = ${var}; // Instance is either `Foo` or `Bar`, we'll expand this twice.
do_something_with(instance.bar[0]);
do_something_with(instance.bar[1]);
if instance.bar.len() == 3 {
    do_something_with(instance.bar[2]);
}

However, that generates an unsuppresable warning like:

^^^^ index out of bounds: the len is 2 but the index is 2

So it seems that Rust doesn't account for that code being unreachable in the Foo case.

In any case, being able to suppress that warning would've made this code straight-forward. Instead of that we probably need to work around it with something like:

#[inline(always)]
fn doit(a: &[u8]) {
    do_something_with(a[0]);
    do_something_with(a[1]);
    if a.len() == 3 {
        do_something_with(a[2]);
    }
}

doit(&instance.bar)

Which is not great.

[upsuper]

Another way to workaround it is probably something like

let len = a.len();
if len == 3 {
  do_something(&a[len - 1]);
}

It has fewer boilerplate than the approach mentioned above, but could still be annoying...

[SimonSapin]

In servo/servo#19227 I’ve replaced this:

if a.len() == 3 {
    println!("{}", a[2]);
}

With this:

if let Some(third) = a.get(2) {
    println!("{}", third);
}