Associated constants inside array repeat expression don't use implied bounds from impl header during well-formedness checking

[typesanitizer]

I tried this code: (try it in a playground)

use std::hash::BuildHasher;
use std::collections::HashMap;

trait H: Send + Sync + Clone + BuildHasher { }

struct I<'i, RS: H> {
    h: &'i HashMap<i32, i32, RS>,
    s: VeryVeryLongTypeName
}
impl<'i, RS: H> I<'i, RS> {
    const CHUNK_SIZE: usize = VeryVeryLongTypeName::CHUNK_SIZE;
    fn go(&mut self) {
        self.s.chunks.push(Box::new([0; Self::CHUNK_SIZE])); // ERROR
    }
}

struct VeryVeryLongTypeName {
    chunks: Vec<Box<[u8; Self::CHUNK_SIZE]>>
}
impl VeryVeryLongTypeName {
    const CHUNK_SIZE: usize = 69;
}

I expect this code to either compile fine or provide a warning similar to #76200.

However, I see an error:

11 | impl<'i, RS: H> I<'i, RS> {
   |          --- help: consider adding an explicit lifetime bound...: `RS: 'i +`
...
15 |         self.s.chunks.push(Box::new([0; Self::CHUNK_SIZE]));
   |                                         ^^^^ ...so that the type `RS` will meet its required lifetime bounds

I don't understand why RS: 'i is needed for accessing a constant off of Self. As one might expect, replacing Self::CHUNK_SIZE with VeryVeryLongTypeName::CHUNK_SIZE works around the issue.

Tested with stable 1.55.0 and 1.57.0-nightly (2021-09-23 2b862bed9889808b6962).

[fmease]

Hmm, I expected #120019 to fix this similar to #83014 but apparently it didn't. I need to think a bit if your code works as intended or not.

[fmease]

Revisiting this, I think this is a duplicate of #105495. For struct I and subsequently {impl#0} we have the implied bound RS: 'i but it's not used when trying to check I::go for well-formedness.

[fmease]

Actually I'm not sure if it's a duplicate of that issue. This probably a separate issue.

[fmease]

So, interestingly the following code compiles successfully:

struct S<'a, T>(&'a T);

impl<'a, T> S<'a, T> {
    const K: usize = 0;
    fn f() { let _ = Self::K; }
}

However, once you place the Self::K into the array repeat expr, it fails:

struct S<'a, T>(&'a T);

impl<'a, T> S<'a, T> {
    const K: usize = 0;
    fn f() { let _ = [(); Self::K]; } //~ ERROR type parameter `T` may not live long enough
}

[fmease]

Note: I wrote "well-formedness checking" but haven't actually double-checked if this is true or if this obligation failure stems from some other system in the compiler.