Helper trait hack const generics ICE

[est31]

In #60466 (comment), @rodrimati1992 shared a snippet to implement a trait only for numbers > 0. After a few modifications done by me, it gives you an ICE (playground):

#![feature(const_generics)] 

trait Foo {
    fn foo() -> Self;
}
impl<T, const N: usize> Foo for [T; N] 
where 
    Self:FooImpl<{N==0}>
{
    fn foo()->Self{
        Self::default_impl()
    }
}

trait FooImpl<const IS_ZERO:bool>{
    fn default_impl()->Self;
}

impl<T> FooImpl<{0u8==0u8}> for [T;0] {
    fn default_impl()->Self{
        []
    }
}

impl<T,const N:usize> FooImpl<{0u8!=0u8}> for [T;N] 
where
    T:Default,
{
    fn default_impl()->Self{
        [T::default(); N]
    }
}

Compiler error message

error: internal compiler error: unexpected const parent in type_of_def_id(): TraitRef(TraitRef { path: path(FooImpl<>), hir_ref_id: HirId { owner: DefIndex(23), local_id: 10 } })

error: internal compiler error: cat_expr Errd
  --> src/main.rs:19:17
   |
19 | impl<T> FooImpl<{0u8==0u8}> for [T;0] {
   |                 ^^^^^^^^^^

error: internal compiler error: unexpected const parent in type_of_def_id(): TraitRef(TraitRef { path: path(FooImpl<>), hir_ref_id: HirId { owner: DefIndex(28), local_id: 17 } })

error: internal compiler error: cat_expr Errd
  --> src/main.rs:25:31
   |
25 | impl<T,const N:usize> FooImpl<{0u8!=0u8}> for [T;N] 
   |                               ^^^^^^^^^^

error: internal compiler error: unexpected const parent in type_of_def_id(): TraitRef(TraitRef { path: path(FooImpl<>), hir_ref_id: HirId { owner: DefIndex(14), local_id: 16 } })

error: internal compiler error: cat_expr Errd
 --> src/main.rs:8:18
  |
8 |     Self:FooImpl<{N==0}>
  |                  ^^^^^^

error: internal compiler error: cat_expr Errd
  --> src/main.rs:29:28
   |
29 |       fn default_impl()->Self{
   |  ____________________________^
30 | |         [T::default(); N]
31 | |     }
   | |_____^

error: internal compiler error: cat_expr Errd
  --> src/main.rs:30:9
   |
30 |         [T::default(); N]
   |         ^^^^^^^^^^^^^^^^^

error: internal compiler error: mir_const_qualif: MIR had errors
 --> src/main.rs:8:18
  |
8 |     Self:FooImpl<{N==0}>
  |                  ^^^^^^

error: internal compiler error: QualifyAndPromoteConstants: MIR had errors
 --> src/main.rs:8:18
  |
8 |     Self:FooImpl<{N==0}>
  |                  ^^^^^^

error: internal compiler error: broken MIR in DefId(0:17 ~ playground[e253]::{{impl}}[0]::{{constant}}[0]) ("return type"): bad type [type error]
 --> src/main.rs:8:18
  |
8 |     Self:FooImpl<{N==0}>
  |                  ^^^^^^

error: internal compiler error: broken MIR in DefId(0:17 ~ playground[e253]::{{impl}}[0]::{{constant}}[0]) (LocalDecl { mutability: Mut, is_user_variable: None, internal: false, is_block_tail: None, ty: [type error], user_ty: UserTypeProjections { contents: [] }, name: None, source_info: SourceInfo { span: src/main.rs:8:18: 8:24, scope: scope[0] }, visibility_scope: scope[0] }): bad type [type error]
 --> src/main.rs:8:18
  |
8 |     Self:FooImpl<{N==0}>
  |                  ^^^^^^

error: internal compiler error: mir_const_qualif: MIR had errors
  --> src/main.rs:19:17
   |
19 | impl<T> FooImpl<{0u8==0u8}> for [T;0] {
   |                 ^^^^^^^^^^

error: internal compiler error: QualifyAndPromoteConstants: MIR had errors
  --> src/main.rs:19:17
   |
19 | impl<T> FooImpl<{0u8==0u8}> for [T;0] {
   |                 ^^^^^^^^^^

error: internal compiler error: broken MIR in DefId(0:25 ~ playground[e253]::{{impl}}[1]::{{constant}}[0]) ("return type"): bad type [type error]
  --> src/main.rs:19:17
   |
19 | impl<T> FooImpl<{0u8==0u8}> for [T;0] {
   |                 ^^^^^^^^^^

error: internal compiler error: broken MIR in DefId(0:25 ~ playground[e253]::{{impl}}[1]::{{constant}}[0]) (LocalDecl { mutability: Mut, is_user_variable: None, internal: false, is_block_tail: None, ty: [type error], user_ty: UserTypeProjections { contents: [] }, name: None, source_info: SourceInfo { span: src/main.rs:19:17: 19:27, scope: scope[0] }, visibility_scope: scope[0] }): bad type [type error]
  --> src/main.rs:19:17
   |
19 | impl<T> FooImpl<{0u8==0u8}> for [T;0] {
   |                 ^^^^^^^^^^

error: internal compiler error: mir_const_qualif: MIR had errors
  --> src/main.rs:25:31
   |
25 | impl<T,const N:usize> FooImpl<{0u8!=0u8}> for [T;N] 
   |                               ^^^^^^^^^^

error: internal compiler error: QualifyAndPromoteConstants: MIR had errors
  --> src/main.rs:25:31
   |
25 | impl<T,const N:usize> FooImpl<{0u8!=0u8}> for [T;N] 
   |                               ^^^^^^^^^^

error: internal compiler error: broken MIR in DefId(0:31 ~ playground[e253]::{{impl}}[2]::{{constant}}[0]) ("return type"): bad type [type error]
  --> src/main.rs:25:31
   |
25 | impl<T,const N:usize> FooImpl<{0u8!=0u8}> for [T;N] 
   |                               ^^^^^^^^^^

error: internal compiler error: broken MIR in DefId(0:31 ~ playground[e253]::{{impl}}[2]::{{constant}}[0]) (LocalDecl { mutability: Mut, is_user_variable: None, internal: false, is_block_tail: None, ty: [type error], user_ty: UserTypeProjections { contents: [] }, name: None, source_info: SourceInfo { span: src/main.rs:25:31: 25:41, scope: scope[0] }, visibility_scope: scope[0] }): bad type [type error]
  --> src/main.rs:25:31
   |
25 | impl<T,const N:usize> FooImpl<{0u8!=0u8}> for [T;N] 
   |                               ^^^^^^^^^^

error: internal compiler error: QualifyAndPromoteConstants: MIR had errors
  --> src/main.rs:29:5
   |
29 | /     fn default_impl()->Self{
30 | |         [T::default(); N]
31 | |     }
   | |_____^

error: internal compiler error: broken MIR in DefId(0:33 ~ playground[e253]::{{impl}}[2]::default_impl[0]) ("return type"): bad type [type error]
  --> src/main.rs:29:5
   |
29 | /     fn default_impl()->Self{
30 | |         [T::default(); N]
31 | |     }
   | |_____^

error: internal compiler error: broken MIR in DefId(0:33 ~ playground[e253]::{{impl}}[2]::default_impl[0]) (LocalDecl { mutability: Mut, is_user_variable: None, internal: false, is_block_tail: None, ty: [type error], user_ty: UserTypeProjections { contents: [] }, name: None, source_info: SourceInfo { span: src/main.rs:29:5: 31:6, scope: scope[0] }, visibility_scope: scope[0] }): bad type [type error]
  --> src/main.rs:29:5
   |
29 | /     fn default_impl()->Self{
30 | |         [T::default(); N]
31 | |     }
   | |_____^

thread 'rustc' panicked at 'no errors encountered even though `delay_span_bug` issued', src/librustc_errors/lib.rs:356:17
note: Run with `RUST_BACKTRACE=1` environment variable to display a backtrace.

error: internal compiler error: unexpected panic

note: the compiler unexpectedly panicked. this is a bug.

note: we would appreciate a bug report: https://github.com/rust-lang/rust/blob/master/CONTRIBUTING.md#bug-reports

note: rustc 1.37.0-nightly (37d001e4d 2019-05-29) running on x86_64-unknown-linux-gnu

note: compiler flags: -C codegen-units=1 -C debuginfo=2 --crate-type bin

note: some of the compiler flags provided by cargo are hidden

error: Could not compile `playground`.

To learn more, run the command again with --verbose.

[varkor]

The discussion link is broken. Also, it'd be great if we could minimise this :)

[est31]

@varkor I've updated the discussion link. This is a minified version of the ICE:

trait FooImpl<const IS_ZERO: bool>{}

impl FooImpl<{0u8==0u8}> for () {}

[varkor]

So, I think #61409 mostly fixes this. However, we need #49147 to work for the entire helper impl to work.

[est31]

However, we need #49147 to work for the entire helper impl to work.

Why exactly? This would only affect us if Default it were const today, no? But it seems not to be const:

const fn foo() -> [u8; 32] {
    Default::default()
}

Gives:

error[E0723]: can only call other `const fn` within a `const fn`, but `const <[u8; 32] as std::default::Default>::default` is not stable as `const fn`
 --> src/main.rs:2:5
  |
2 |     Default::default()
  |     ^^^^^^^^^^^^^^^^^^
  |
  = note: for more information, see issue https://github.com/rust-lang/rust/issues/57563
  = help: add #![feature(const_fn)] to the crate attributes to enable

[HadrienG2]

@est31 The thing is, for [x; N] to be valid today, x needs to be Copy. But the Default::default() in [Default::default(); N] is not Copy (unless we constrain it to be, which we probably don't want).

#49147 originally proposed relaxing this Copy constraint to accept any const expression as well, but as you point out, that will not be enough to accept Default::default() yet because not every Default impl is const (AFAIK, const impls are not even a thing yet).

What we need is therefore a further extension to the concept, discussed in #49147 by @eddyb, to accept any expression that can be repeatedly evaluated at runtime.

[est31]

@HadrienG2 oh interesting, yeah we don't require it to be Copy.

However, this is not the same as the thing @eddyb talked about. Lowering [Ok::<i32, String>(rand()); n] to let x = rand(); [Ok::<i32, String>(x); n] kinda works. But we don't have such a transparent case here but instead an opaque [Default::default(); n].

Consider a type struct Hello(String); whose default impl invokes String::new("Hello, World!"). You can't just clone the string pointers, you actually need to invoke Default n times.

It turns out that even if the type itself implements Copy, we can't lower to let v = Default::default(); [v; n], as you could have a type like struct UniqueUUID(u128); with default impl fn default() -> Self { Self(rand())}. Then an array of those becomes [UniqueUUID(rand()), UniqueUUID(rand()), UniqueUUID(rand()), ...] and ultimately this is different from let v = UniqueUUID(rand()); [v; n]. So we can't do any specializations for Copy types, those would be breaking changes.

Your comment @HadrienG2 made me realize that the snippet in the issue description won't ever be correct. But fortunately there is this simple solution (not requiring #49147):

impl<T,const N:usize> FooImpl<{0u8!=0u8}> for [T;N] 
where
    T:Default,
{
    fn default_impl()->Self{
        let ret: Self = unsafe { core::mem::uninitialized() };
        let ret_slice: &mut [_] = ret;
        for e in ret_slice.iter_mut() {
            *e = Default::default();
        }
        ret
    }
}

It would probably be useful to have a function in libstd that wraps above code in a generic fashion, taking a closure impl Fn() -> T and calling the closure N times, returning [T;N]. And a try_ version that takes impl Fn() -> Result<T, E> and returns Result<[T;N], E>. This is just a side note however, the function is not required to implement this feature but it would allow you to avoid having to use unsafe yourself.

[HadrienG2]

I suspect that as written, your snippet has enough opportunities for UB to give @RalfJung a heart attack. But I like its overall logic, this is how I typically go about initializing arrays of primitive types myself. Given a bit of massaging with pointers instead of references, MaybeUninit, and some thoughts around panic safety, it should be good to go.

[HadrienG2]

Note that the generic utility that you seek could take the form of an array-friendly form of Iterator::collect(), which would address one of my longstanding gripes with arrays in Rust...

[est31]

Note that the generic utility that you seek could take the form of an array-friendly form of Iterator::collect(), which would address one of my longstanding gripes with arrays in Rust...

You mean implementing FromIterator for Option<[T;N]>? That would be awesome! You should file a PR :).