checking for structural recursion can cause a stack overflow

[lcnr]

struct Foo<T> {
    x: Foo<[T; 1]>,
    y: T,
}

struct Bar {
    x: Foo<Bar>,
}

has the following output:

error[E0072]: recursive type `Foo` has infinite size
 --> src/lib.rs:1:1
  |
1 | struct Foo<T> {
  | ^^^^^^^^^^^^^ recursive type has infinite size
2 |     x: Foo<[T; 1]>,
  |        ----------- recursive without indirection
  |
help: insert some indirection (e.g., a `Box`, `Rc`, or `&`) to make `Foo` representable
  |
2 |     x: Box<Foo<[T; 1]>>,
  |        ^^^^           ^


thread 'rustc' has overflowed its stack
fatal runtime error: stack overflow

the stack overflow should not happen ^^

[lcnr]

the recursion happens in

rust/compiler/rustc_middle/src/ty/util.rs

Lines 1001 to 1017 in e188693

	// We also need to know whether the first item contains other types
	// that are structurally recursive. If we don't catch this case, we
	// will recurse infinitely for some inputs.
	//
	// It is important that we DO take generic parameters into account
	// here, so that code like this is considered SelfRecursive, not
	// ContainsRecursive:
	//
	// struct Foo { Option<Option<Foo>> }
	for &seen_type in iter {
	if ty::TyS::same_type(ty, seen_type) {
	debug!("ContainsRecursive: {:?} contains {:?}", seen_type, ty);
	return Representability::ContainsRecursive;
	}
	}
	}

Because Foo is not trivially self recursive this check is never hit and we keep looking into Foo<[Bar; 1]>, Foo<[[Bar; 1]; 1]> and so on.

[lcnr]

cc #74224