Const-generic type mismatch: #[repr(usize)] enum as const parameter in arrays

[qwerty19106]

The code:

#![feature(const_generics)]

use core::ptr::null_mut;

#[derive(Clone, Copy, Debug)]
#[repr(usize)]
pub enum ArrayCount {
    Values3 = 3,
    Values4 = 4,
    Values6 = 6
}

/// Non-Copy type!
#[repr(transparent)]
struct ArrayItem<T>(*mut T);

impl<T> ArrayItem<T> {
    pub fn new() -> Self {
        Self(null_mut())
    }
}

#[repr(transparent)]
pub struct MyArray<T, const COUNT: ArrayCount>([ArrayItem<T>; COUNT as usize]);

impl<T> MyArray<T, {ArrayCount::Values3}> {
    pub(crate) const fn new() -> Self {
        Self([
            ArrayItem::new(),
            ArrayItem::new(),
            ArrayItem::new(),
        ])
    }
}

fn main() {
}

It produced error:

error[E0308]: mismatched types
  --> src/main.rs:28:14
   |
28 |           Self([
   |  ______________^
29 | |             ArrayItem::new(),
30 | |             ArrayItem::new(),
31 | |             ArrayItem::new(),
32 | |         ])
   | |_________^ expected `COUNT as usize`, found `3usize`
   |
   = note: expected type `[ArrayItem<T>; _]`
              found type `[ArrayItem<T>; 3]`

Playground

Although Constants in array repeat expressions RFC not yet implemented, this code must work already.

Or I'm wrong and this syntax does not supported by const-generics?

[jonas-schievink]

Not sure where you see the ICE, removing that.

[qwerty19106]

This is glitch after the previous 2 issues.. It is not ICE.

[qwerty19106]

To @varkor

Minimal code:

#![feature(const_generics)]

pub struct MyArray<const COUNT: usize>([u8; COUNT + 1]);

impl<const COUNT: usize> MyArray<{COUNT}> {
    fn inner(&self) -> &[u8; COUNT + 1] {
        &self.0
    }
}

fn main() {
}

produce error:

error[E0308]: mismatched types
 --> src/main.rs:8:9
  |
8 |         &self.0
  |         ^^^^^^^ expected `COUNT + 1`, found `COUNT + 1`
  |
  = note: expected type `&[u8; _]`
             found type `&[u8; _]`

The {COUNT} + 1 variant also give this error.

playground

[qwerty19106]

Now it is ICE:

error: internal compiler error: src/librustc/ty/subst.rs:651: const parameter `COUNT/#0` (Const { ty: usize, val: Param(COUNT/#0) }/0) out of range when substituting substs=[]

[varkor]

It's back to the original error.

[qwerty19106]

Now it produce this errors:

error: constant expression depends on a generic parameter
 --> src/main.rs:3:40
  |
3 | pub struct MyArray<const COUNT: usize>([u8; COUNT + 1]);
  |                                        ^^^^^^^^^^^^^^^
  |
  = note: this may fail depending on what value the parameter takes

error: constant expression depends on a generic parameter
 --> src/main.rs:6:5
  |
6 | /     fn inner(&self) -> &[u8; COUNT + 1] {
7 | |         &self.0
8 | |     }
  | |_____^
  |
  = note: this may fail depending on what value the parameter takes

[varkor]

The behaviour is now as expected. We just need a test now.

[qwerty19106]

The behaviour is now as expected. We just need a test now.

Const Generic RFC leads the code as possible:

fn foo<const N: usize>() -> [i32; N + 1] {
    let x: [i32; N + 1] = [0; N + 1];
    x
}

Is there another issue that is tracking it?

[varkor]

Yes, there are some subtle issues about making sure that constants in types are well-formed. The tracking issue for this is #68436.