Wrong diagnostic: Type must be annotated #[derive(PartialEq, Eq)] to be used as the type of a const parameter

[vmarkushin]

I tried this code:

#![feature(const_generics)]

#[derive(PartialEq, Eq)]
enum Nat {
    Z,
    S(Box<Nat>)
}

fn foo<const N: Nat>() {}

And got this error:

error[E0741]: `Nat` must be annotated with `#[derive(PartialEq, Eq)]` to be used as the type of a const parameter
 --> src/lib.rs:9:17
  |
9 | fn foo<const N: Nat>() {}
  |                 ^^^ `Nat` doesn't derive both `PartialEq` and `Eq`

The code without the const parameter compiles, though:

#![feature(const_generics)]

#[derive(PartialEq, Eq)]
enum Nat {
    Z,
    S(Box<Nat>)
}

// fn foo<const N: Nat>() {}

Meta

rustc +nightly --version --verbose:

rustc 1.50.0-nightly (0edce6f4b 2020-12-24)
binary: rustc
commit-hash: 0edce6f4bbb4514482537f569f0b8ef48e71e0a0
commit-date: 2020-12-24
host: x86_64-apple-darwin
release: 1.50.0-nightly

[SNCPlay42]

The real problem is that Box does not #[derive(PartialEq, Eq)], but the diagnostic assumes the annotation is missing from the outermost type.

@rustbot label D-incorrect T-compiler requires-nightly

[vmarkushin]

@SNCPlay42 but why it compiles without the const parameter? playground

[SNCPlay42]

Box implements PartialEq and Eq, so you can derive them in structs containing a Box, but it doesn't do so by deriving them itself.

Const generic parameters require that PartialEq and Eq are derived on both the type and its fields (and its fields' fields etc.) so that how equality works for the parameter is predictable.

[vmarkushin]

@SNCPlay42 interesting, that makes sense. Thank you.

[lcnr]

the error now mentions that Box is the issue, not Nat itself, marking as needs-test

#![feature(adt_const_params)]

#[derive(PartialEq, Eq)]
enum Nat {
    Z,
    S(Box<Nat>)
}

fn foo<const N: Nat>() {}

[Mark-Simulacrum]

I don't think this is fixed yet. We mention the Box, but where the Box comes from is still pretty opaque -- we should likely point at or say something about the enum variant.

Saying that Box<Nat> must be derive(PartialEq, Eq) is also pretty nonsensical, as that's not something you can do -- Box<T> could be, though.

[estebank]

Current output:

error: `Nat` is forbidden as the type of a const generic parameter
 --> src/lib.rs:7:17
  |
7 | fn foo<const N: Nat>() {}
  |                 ^^^
  |
  = note: the only supported types are integers, `bool` and `char`
  = help: more complex types are supported with `#![feature(adt_const_params)]`

With adt_const_params

error[E0741]: `Box<Nat>` must be annotated with `#[derive(PartialEq, Eq)]` to be used as the type of a const parameter
 --> src/lib.rs:8:17
  |
8 | fn foo<const N: Nat>() {}
  |                 ^^^

[estebank]

Current output with the feature enabled:

error[E0741]: `Nat` must implement `ConstParamTy` to be used as the type of a const generic parameter
 --> src/lib.rs:8:17
  |
8 | fn foo<const N: Nat>() {}
  |                 ^^^
  |
help: add `#[derive(ConstParamTy)]` to the struct
  |
3 + #[derive(ConstParamTy)]
4 | enum Nat {
  |