Slicing after `str::starts_with` performs unnecessary checks

[jhpratt]

Without unsafe (playground)

pub struct Foo<'a> {
    string: &'a str,
}

impl Foo<'_> {
    pub fn bar(&mut self) -> Option<&str> {
        if self.string.starts_with("[[") {
            let bracket = &self.string[..1];
            self.string = &self.string[2..];
            Some(bracket)
        } else {
            None
        }
    }
}

With unsafe (playground)

pub struct Foo<'a> {
    string: &'a str,
}

impl Foo<'_> {
    pub fn bar(&mut self) -> Option<&str> {
        if self.string.starts_with("[[") {
            let bracket = unsafe { self.string.get_unchecked(..1) };
            self.string = unsafe { self.string.get_unchecked(2..) };
            Some(bracket)
        } else {
            None
        }
    }
}

I'm not terribly familiar with assembly, but the compiler is clearly performing checks where they aren't necessary. Given the knowledge that the string starts with a literal (in this case two ASCII bytes), we should be able to slice without any additional performance costs.

[the8472]

Assuming you don't need a &str pointing into the original string you could you could use strip_prefix once it becomes stable. And for now split_at could at least offer one less bound check.

[jhpratt]

I don't strictly need the returned value to be a slice of the original, but I tested it and it generated slightly less assembly.

I just created this issue because the bounds & Unicode boundary checks aren't necessary, given we already know the partial contents. I presume this would be an optimization done in MIR.