fix ICE with references to infinite structs in consts

[lukas-code]

fixes #114484

Normalizing <Type as Pointee>::Metadata may emit a (non-fatal) error during trait selection if finding the struct tail of Type hits the recursion limit. When this happens, prior this PR, we would treat the projection as rigid, i.e. don't normalize it further. This PR changes it so that we normalize to ty::Error instead.

This is important, because to compute the layout of &Type we need to compute the layout of <Type as Pointee>::Metadata

rust/compiler/rustc_ty_utils/src/layout.rs

Lines 247 to 273 in 2ae9916

	let pointee_metadata = Ty::new_projection(tcx, metadata_def_id, [pointee]);
	let metadata_ty =
	match tcx.try_normalize_erasing_regions(cx.typing_env, pointee_metadata) {
	Ok(metadata_ty) => metadata_ty,
	Err(mut err) => {
	// Usually `<Ty as Pointee>::Metadata` can't be normalized because
	// its struct tail cannot be normalized either, so try to get a
	// more descriptive layout error here, which will lead to less confusing
	// diagnostics.
	//
	// We use the raw struct tail function here to get the first tail
	// that is an alias, which is likely the cause of the normalization
	// error.
	match tcx.try_normalize_erasing_regions(
	cx.typing_env,
	tcx.struct_tail_raw(pointee, |ty| ty, || {}),
	) {
	Ok(_) => {}
	Err(better_err) => {
	err = better_err;
	}
	}
	return Err(error(cx, LayoutError::NormalizationFailure(pointee, err)));
	}
	};
	let metadata_layout = cx.layout_of(metadata_ty)?;

and computing the layout of a rigid alias will (correctly) fail and needs to report an error to the user. For example:

trait Project {
    type Assoc;
}

fn foo<T: Project>() {
    [(); {
        let _: Option<T::Assoc> = None;
                   // ^^^^^^^^ this projection is rigid, so we can't know it's layout
        0
    }];
}

error: constant expression depends on a generic parameter
  --> src/lib.rs:6:10
   |
6  |       [(); {
   |  __________^
7  | |         let _: Option<T::Assoc> = None;
8  | |                    // ^^^^^^^^ this projection is rigid, so we can't know it's layout
9  | |         0
10 | |     }];
   | |_____^
   |
   = note: this may fail depending on what value the parameter takes

For non-generic rigid projections we will currently ICE, because we incorrectly assume that LayoutError::Unknown means that a const must be generic (#135138). This is being fixed and turned into a proper error in #135158.

#![feature(trivial_bounds)]

trait Project {
    type Assoc;
}

fn foo()
where
    u8: Project,
{
    [(); {
        let _: Option<<u8 as Project>::Assoc> = None; // ICEs currently, but will be an error
        0
    }];
}

However, if we hit the recursion limit when normalizing <Type as Pointee>::Metadata we don't want to report a layout error, because we already emitted the recursion error. So by normalizing to ty::Error here, we get a LayoutError::ReferencesError instead of a LayoutError::Unknown and don't report the layout error to the user.

[rustbot]

r? @oli-obk

rustbot has assigned @oli-obk.
They will have a look at your PR within the next two weeks and either review your PR or reassign to another reviewer.

Use r? to explicitly pick a reviewer

[lukas-code]

cc @FedericoBruzzone i suspect that this will make that post-mono error cap from #135158 redundant.

[FedericoBruzzone]

cc @FedericoBruzzone i suspect that this will make that post-mono error cap from #135158 redundant.

Yes, it would make post-mono error cap redundant. But are we sure that there could not be other cases where we do not want to have a limit on the number of post-mono errors?
We should probably talk about it in #135158.

[FedericoBruzzone]

As far as I know and having previously investigated this error, looks good to me.

[oli-obk]

Preexisting, so if you want a good follow-up to this PR, you could pass in the obligation cause to struct_tail_raw and use its span for the main message and report a note for the obligation

[oli-obk]

@bors r=FedericoBruzzone,oli-obk rollup

[bors]

📌 Commit 7a3c4f7 has been approved by FedericoBruzzone,oli-obk

It is now in the queue for this repository.