Lifetime bound error when using the indexing operator with an associated type containing a lifetime

[koute]

Please consider the following code:

use std::marker::PhantomData;
use std::ops::Index;

pub trait Context: Clone {
    type Container: ?Sized;
    fn foobar_1( container: &Self::Container ) -> &str;
    fn foobar_2( container: &Self::Container ) -> &str;
    fn foobar_3( container: &Self::Container ) -> &str;
}

#[derive(Clone)]
struct Foobar<'a> {
    phantom: PhantomData<&'a ()>
}

impl<'a> Context for Foobar<'a> {
    type Container = [&'a str];

    fn foobar_1<'r>( container: &'r [&'a str] ) -> &'r str {
        // This compiles fine.
        container[0]
    }

    fn foobar_2<'r>( container: &'r Self::Container ) -> &'r str {
        // This also compiles fine.
        container.index( 0 )
    }

    fn foobar_3<'r>( container: &'r Self::Container ) -> &'r str {
        // error: `*container[..]` does not live long enough
        container[0]
    }
}

fn main() {}

which fails with the following error:

test.rs:31:9: 31:21 error: `*container[..]` does not live long enough
test.rs:31         container[0]
                   ^~~~~~~~~~~~
test.rs:29:66: 32:6 note: reference must be valid for the lifetime 'r as defined on the block at 29:65...
test.rs:29     fn foobar_3<'r>( container: &'r Self::Container ) -> &'r str {
test.rs:30         // error: `*container[..]` does not live long enough
test.rs:31         container[0]
test.rs:32     }
test.rs:29:66: 32:6 note: ...but borrowed value is only valid for the lifetime 'a as defined on the block at 29:65
test.rs:29     fn foobar_3<'r>( container: &'r Self::Container ) -> &'r str {
test.rs:30         // error: `*container[..]` does not live long enough
test.rs:31         container[0]
test.rs:32     }
error: aborting due to previous error

So if I use .index() and use an associated type it compiles fine. If I use [] and replace the associated type with the underlying type it also compiles fine. Logic would have it that if I use [] and I'll leave the associated type as-is it should also compile fine, but alas, I get an error, which doesn't really make any sense.

Rust version: rustc 1.9.0-nightly (b12b4e4 2016-03-17)

This is a regression; this code used to compile on at least 1.4, 1.5 and 1.6; it broke at 1.7.

[alexcrichton]

cc @nikomatsakis

[alexcrichton]

also @rust-lang/compiler

[pnkfelix]

I will look at this.

[pnkfelix]

marking as P-medium nonetheless, since I am not convinced this needs to high priority...

[nikomatsakis]

OK, so, I think this is related to the implied bounds that we compute. We must be somehow failing to add the implied 'a: 'r bound because it is obscured by the Self::Contained (which must not be normalized at the right time or something). I'll have to dig a bit in the code to see why this is the case though.

[nikomatsakis]

Well, that doesn't quite explain why the manual call to index works, I guess. Maybe my hypothesis is wrong. I would guess though there's a problem where using the [] operator must be inducing some invariance perhaps?

[Mark-Simulacrum]

@pnkfelix You are currently assigned to this, are you still investigating?

[eddyb]

cc @nikomatsakis as well

[JelteF]

I'm running into this issue as well when trying to convert get().unwrap() to an index operation on this line:
https://github.com/JelteF/derive_more/blob/2e37e7f8181ba333df9503088222772b77c83d91/src/from.rs#L103

It indeed works fine when manually calling index().

[pnkfelix]

I just tried this out with the 2018 edition and it works there. Or on the nightly compiler, one can add #![feature(nll)] to get the fix.

We should add a regression test before closing though.

[pnkfelix]

#54812 added the test.