Recursive types in a `Vec<T>` with generic parameters gives ambiguous error

[Kjolnyr]

I tried this code:

struct Foo<T> { v: Vec<Bar<T>> }
struct Bar<T> { f: Foo<T> }

I expected to see this happen:

error[[E0072]](https://doc.rust-lang.org/stable/error_codes/E0072.html): recursive types `Foo` and `Bar` have infinite size
 --> src/lib.rs:1:1
  |
1 | struct Foo<T> { v: Bar<T> }
  | ^^^^^^^^^^^^^      ------ recursive without indirection
2 | struct Bar<T> { f: Foo<T> }
  | ^^^^^^^^^^^^^      ------ recursive without indirection
  |
help: insert some indirection (e.g., a `Box`, `Rc`, or `&`) to break the cycle

OR actually compiling.

Instead, this happened: not compiling

error[E0392]: parameter `T` is never used
 --> src/main.rs:2:12
  |
2 | struct Foo<T> { v: Vec<Bar<T>> }
  |            ^ unused parameter
  |
  = help: consider removing `T`, referring to it in a field, or using a marker such as `PhantomData`
  = help: if you intended `T` to be a const parameter, use `const T: usize` instead

error[E0392]: parameter `T` is never used
 --> src/main.rs:3:12
  |
3 | struct Bar<T> { f: Foo<T> }
  |            ^ unused parameter
  |
  = help: consider removing `T`, referring to it in a field, or using a marker such as `PhantomData`
  = help: if you intended `T` to be a const parameter, use `const T: usize` instead

For more information about this error, try `rustc --explain E0392`.

Meta

rustc --version --verbose:

rustc 1.70.0-nightly (db0cbc48d 2023-03-26)
binary: rustc
commit-hash: db0cbc48d4aaa300713a95d9b317a365a474490c
commit-date: 2023-03-26
host: x86_64-pc-windows-msvc
release: 1.70.0-nightly
LLVM version: 16.0.0

[Ezrashaw]

This should compile right? There is indirection because Vec<T> is heap-allocated.

@rustbot claim
(not sure I'll be able to fix it)

EDIT: rustbot doesn't like me lol

[rustbot]

Error: Parsing assign command in comment failed: ...' claim' | error: expected end of command at >| ' (not sure'...

Please file an issue on GitHub at triagebot if there's a problem with this bot, or reach out on #t-infra on Zulip.

[zirconium-n]

This is not a bug. T is unused, and it's impossible to derive variance for T.

Simpler example:

// I "inlined" `Foo` and replaced `Vec` with `Box`. 
struct Bar<T> {
    f: Box<Bar<T>>,
}

It's easy to replace inner Bar<T> with Self to see T is unused.

// I "inlined" `Foo` and replaced `Vec` with `Box`. 
struct Bar<T> {
    f: Box<Self>,
}

[Ezrashaw]

I think you are right. In that case, we need to emit an error when inferring variance and then not emit the "unused parameter" error in that case. EDIT: Should this be a compile error or should we mark the type parameter as invariant?

I'm not entirely sure about the correctness of your reduction.

[Ezrashaw]

@zirconium-n I think that'll delegate to someone more experienced than me for the final say on this:

https://rust-lang.zulipchat.com/#narrow/stream/182449-t-compiler.2Fhelp/topic/variance.20of.20mutually.20recursive.20ADTs