Check for region dependent goals on type_op itself as well

[ShoyuVanilla]

Fixes #151318

r? lcnr

[lcnr]

does just unwrapping here cause any ICE?

[ShoyuVanilla]

Nothing so far
Edit) Oh we have one 😅 I've run only next-solver test suite locally

[lcnr]

can you look into why that obligation is failing even though HIR typeck is erroring, can't see the obligation which causes this ICE in CI

[ShoyuVanilla]

Okay, I'll look into it

[ShoyuVanilla]

So, the obligation fails here is &T: Iterator here(L15):

rust/tests/ui/wf/hir-wf-check-erase-regions.rs

Lines 11 to 19 in 8d50bcc

	type IntoIter = std::iter::Flatten<std::slice::Iter<'a, T>>; //~ ERROR `&'a T` is not an iterator
	//~^ ERROR `&'a T` is not an iterator
	type Item = &'a T;
	fn into_iter(self) -> Self::IntoIter {
	//~^ ERROR `&'a T` is not an iterator
	//[nll]~| ERROR `&T` is not an iterator
	unimplemented!()
	}

which is caused in here

rust/compiler/rustc_trait_selection/src/traits/query/dropck_outlives.rs

Lines 190 to 222 in 8d50bcc

	for ty in constraints.dtorck_types.drain(..) {
	let ty = if let Ok(Normalized { value: ty, obligations }) =
	ocx.infcx.at(&cause, param_env).query_normalize(ty)
	{
	ocx.register_obligations(obligations);
	debug!("dropck_outlives: ty from dtorck_types = {:?}", ty);
	ty
	} else {
	// Flush errors b/c `deeply_normalize` doesn't expect pending
	// obligations, and we may have pending obligations from the
	// branch above (from other types).
	let errors = ocx.evaluate_obligations_error_on_ambiguity();
	if !errors.is_empty() {
	return Err(errors);
	}
	// When query normalization fails, we don't get back an interesting
	// reason that we could use to report an error in borrowck. In order to turn
	// this into a reportable error, we deeply normalize again. We don't expect
	// this to succeed, so delay a bug if it does.
	match ocx.deeply_normalize(&cause, param_env, ty) {
	Ok(_) => {
	tcx.dcx().span_delayed_bug(
	span,
	format!(
	"query normalize succeeded of {ty}, \
	but deep normalize failed",
	),
	);
	ty
	}
	Err(errors) => return Err(errors),

while trying to normalize <<Iter<'a, T> as Iterator>::Item as IntoIterator>::Iterator.

It's surprising that fn into_iter in L15 survives the typeck (or other earlier steps before MIR) without being tainted.
Maybe that's because of never type on unimplemented!() which bypasses actually touching the function's return type with NeverToAny coercion, otherwise the other concrete typed return would resulted in type mismatch error or fulfillment error while trying to normalize the function's return type?

I guess we ought to check the well-formedness of the type that never type is coerced into or the function's signature itself before MIR?

[lcnr]

I think the issue is that we check the return type is well-formed in wfcheck::check_well_formed and to avoid duplicate errors we don't check it in HIR typeck.

This means that non-wf return types go through HIR typeck without tainting it, only erroring in wfcheck.rs.

Hmm, I feel like ideally we do taint the MIR body here, but I think for now, just keep a span_delay_bug here and add a FIXME that we should try to make this an ICE (and why it doesn't work)

[lcnr]

@bors r+ rollup

thanks

[rust-bors]

📌 Commit 5f3bdde has been approved by lcnr

It is now in the queue for this repository.