False positive 'type parameter is never used' with struct

[Aaron1011]

Consider the following code snippet playground

trait MyTrait<I> {}
trait SecondTrait {}

fn bar<A: MyTrait<B>, B: SecondTrait>() {}

struct MyStruct<A: MyTrait<B>, B: SecondTrait> {
    field: A
}

This procudes the error:

error[E0392]: parameter `B` is never used
 --> src/lib.rs:6:32
  |
6 | struct MyStruct<A: MyTrait<B>, B: SecondTrait> {
  |                                ^ unused type parameter
  |
  = help: consider removing `B` or using a marker such as `std::marker::PhantomData`

However, the parameter B is used - it's part of how we bound A.

The function and struct are equivalent in terms of generic parameters - since the equalivalent function compiles, the struct should as well.

Though this can be worked around via PhantomData, there's no reason to require using it. The struct definition is perfectly valid and useful, and should be useable without any workarounds.

[jonas-schievink]

This is probably intentional - the problem with type parameters that aren't used in field types is that it's not possible to infer their variance, so PhantomData can be used to act "as if" there's a field of a specific type incorporating the unused type parameter

[scottmcm]

Note also that, in cases like this, it means that MyStruct { field } can't figure out which of possibly-many Bs you meant, so it's probably not what you want even if it were to work.

Usually this is handled by not bounding the struct, and just bounding methods on the struct.

[frewsxcv]

the problem with type parameters that aren't used in field types is that it's not possible to infer their variance

I'm not familiar enough with compilers or programming languages to understand what it means to "infer variance", but I'm wondering if there's a more descriptive error message we can add here explaining why it's not possible. Here's an example where I hit this:

pub trait Coord {
    fn x(&self) -> f32;
    fn y(&self) -> f32;
}

pub trait Rect<C: Coord> {
    fn min(&self) -> C;
    fn max(&self) -> C;
}

pub trait Line<C: Coord> {
    fn start(&self) -> C;
    fn end(&self) -> C;
}

pub enum Geometry<C, R, L>
where C: Coord,
      R: Rect<C>,
      L: Line<C>
{
    Rect(R),
    Line(L),
}