Resolve type aliases to the type they point to in intra-doc links

[LeSeulArtichaut]

This feels a bit sketchy, but I think it's better than just rejecting the link.
Helps with #86120, r? @jyn514

[rust-highfive]

Some changes occurred in intra-doc-links.

cc @jyn514

[jyn514]

Can you help me understand why this wasn't working before? Does inherent_impls not work at all for type aliases?

[LeSeulArtichaut]

(I'm not especially familiar with this part of the compiler, these are the results of skimming the source code, so take it with a grain of salt)

inherent_impls uses the impls_map that is collected by InherentCollect in this somewhat lengthy function:

rust/compiler/rustc_typeck/src/coherence/inherent_impls.rs

Lines 43 to 354 in 4d3ce2e

	fn visit_item(&mut self, item: &hir::Item<'_>) {
	let (ty, assoc_items) = match item.kind {
	hir::ItemKind::Impl(hir::Impl { of_trait: None, ref self_ty, items, .. }) => {
	(self_ty, items)
	}
	_ => return,
	};
	let self_ty = self.tcx.type_of(item.def_id);
	let lang_items = self.tcx.lang_items();
	match *self_ty.kind() {
	ty::Adt(def, _) => {
	self.check_def_id(item, def.did);
	}
	ty::Foreign(did) => {
	self.check_def_id(item, did);
	}
	ty::Dynamic(ref data, ..) if data.principal_def_id().is_some() => {
	self.check_def_id(item, data.principal_def_id().unwrap());
	}
	ty::Bool => {
	self.check_primitive_impl(
	item.def_id,
	lang_items.bool_impl(),
	None,
	"bool",
	"bool",
	item.span,
	assoc_items,
	);
	}
	ty::Char => {
	self.check_primitive_impl(
	item.def_id,
	lang_items.char_impl(),
	None,
	"char",
	"char",
	item.span,
	assoc_items,
	);
	}
	ty::Str => {
	self.check_primitive_impl(
	item.def_id,
	lang_items.str_impl(),
	lang_items.str_alloc_impl(),
	"str",
	"str",
	item.span,
	assoc_items,
	);
	}
	ty::Slice(slice_item) if slice_item == self.tcx.types.u8 => {
	self.check_primitive_impl(
	item.def_id,
	lang_items.slice_u8_impl(),
	lang_items.slice_u8_alloc_impl(),
	"slice_u8",
	"[u8]",
	item.span,
	assoc_items,
	);
	}
	ty::Slice(_) => {
	self.check_primitive_impl(
	item.def_id,
	lang_items.slice_impl(),
	lang_items.slice_alloc_impl(),
	"slice",
	"[T]",
	item.span,
	assoc_items,
	);
	}
	ty::Array(_, _) => {
	self.check_primitive_impl(
	item.def_id,
	lang_items.array_impl(),
	None,
	"array",
	"[T; N]",
	item.span,
	assoc_items,
	);
	}
	ty::RawPtr(ty::TypeAndMut { ty: inner, mutbl: hir::Mutability::Not })
	if matches!(inner.kind(), ty::Slice(_)) =>
	{
	self.check_primitive_impl(
	item.def_id,
	lang_items.const_slice_ptr_impl(),
	None,
	"const_slice_ptr",
	"*const [T]",
	item.span,
	assoc_items,
	);
	}
	ty::RawPtr(ty::TypeAndMut { ty: inner, mutbl: hir::Mutability::Mut })
	if matches!(inner.kind(), ty::Slice(_)) =>
	{
	self.check_primitive_impl(
	item.def_id,
	lang_items.mut_slice_ptr_impl(),
	None,
	"mut_slice_ptr",
	"*mut [T]",
	item.span,
	assoc_items,
	);
	}
	ty::RawPtr(ty::TypeAndMut { ty: _, mutbl: hir::Mutability::Not }) => {
	self.check_primitive_impl(
	item.def_id,
	lang_items.const_ptr_impl(),
	None,
	"const_ptr",
	"*const T",
	item.span,
	assoc_items,
	);
	}
	ty::RawPtr(ty::TypeAndMut { ty: _, mutbl: hir::Mutability::Mut }) => {
	self.check_primitive_impl(
	item.def_id,
	lang_items.mut_ptr_impl(),
	None,
	"mut_ptr",
	"*mut T",
	item.span,
	assoc_items,
	);
	}
	ty::Int(ty::IntTy::I8) => {
	self.check_primitive_impl(
	item.def_id,
	lang_items.i8_impl(),
	None,
	"i8",
	"i8",
	item.span,
	assoc_items,
	);
	}
	ty::Int(ty::IntTy::I16) => {
	self.check_primitive_impl(
	item.def_id,
	lang_items.i16_impl(),
	None,
	"i16",
	"i16",
	item.span,
	assoc_items,
	);
	}
	ty::Int(ty::IntTy::I32) => {
	self.check_primitive_impl(
	item.def_id,
	lang_items.i32_impl(),
	None,
	"i32",
	"i32",
	item.span,
	assoc_items,
	);
	}
	ty::Int(ty::IntTy::I64) => {
	self.check_primitive_impl(
	item.def_id,
	lang_items.i64_impl(),
	None,
	"i64",
	"i64",
	item.span,
	assoc_items,
	);
	}
	ty::Int(ty::IntTy::I128) => {
	self.check_primitive_impl(
	item.def_id,
	lang_items.i128_impl(),
	None,
	"i128",
	"i128",
	item.span,
	assoc_items,
	);
	}
	ty::Int(ty::IntTy::Isize) => {
	self.check_primitive_impl(
	item.def_id,
	lang_items.isize_impl(),
	None,
	"isize",
	"isize",
	item.span,
	assoc_items,
	);
	}
	ty::Uint(ty::UintTy::U8) => {
	self.check_primitive_impl(
	item.def_id,
	lang_items.u8_impl(),
	None,
	"u8",
	"u8",
	item.span,
	assoc_items,
	);
	}
	ty::Uint(ty::UintTy::U16) => {
	self.check_primitive_impl(
	item.def_id,
	lang_items.u16_impl(),
	None,
	"u16",
	"u16",
	item.span,
	assoc_items,
	);
	}
	ty::Uint(ty::UintTy::U32) => {
	self.check_primitive_impl(
	item.def_id,
	lang_items.u32_impl(),
	None,
	"u32",
	"u32",
	item.span,
	assoc_items,
	);
	}
	ty::Uint(ty::UintTy::U64) => {
	self.check_primitive_impl(
	item.def_id,
	lang_items.u64_impl(),
	None,
	"u64",
	"u64",
	item.span,
	assoc_items,
	);
	}
	ty::Uint(ty::UintTy::U128) => {
	self.check_primitive_impl(
	item.def_id,
	lang_items.u128_impl(),
	None,
	"u128",
	"u128",
	item.span,
	assoc_items,
	);
	}
	ty::Uint(ty::UintTy::Usize) => {
	self.check_primitive_impl(
	item.def_id,
	lang_items.usize_impl(),
	None,
	"usize",
	"usize",
	item.span,
	assoc_items,
	);
	}
	ty::Float(ty::FloatTy::F32) => {
	self.check_primitive_impl(
	item.def_id,
	lang_items.f32_impl(),
	lang_items.f32_runtime_impl(),
	"f32",
	"f32",
	item.span,
	assoc_items,
	);
	}
	ty::Float(ty::FloatTy::F64) => {
	self.check_primitive_impl(
	item.def_id,
	lang_items.f64_impl(),
	lang_items.f64_runtime_impl(),
	"f64",
	"f64",
	item.span,
	assoc_items,
	);
	}
	ty::Error(_) => {}
	_ => {
	let mut err = struct_span_err!(
	self.tcx.sess,
	ty.span,
	E0118,
	"no nominal type found for inherent implementation"
	);
	err.span_label(ty.span, "impl requires a nominal type")
	.note("either implement a trait on it or create a newtype to wrap it instead");
	if let ty::Ref(_, subty, _) = self_ty.kind() {
	err.note(&format!(
	"you could also try moving the reference to \
	uses of `{}` (such as `self`) within the implementation",
	subty
	));
	}
	err.emit();
	}
	}
	}

Notice this line:

rust/compiler/rustc_typeck/src/coherence/inherent_impls.rs

Line 51 in 4d3ce2e

let self_ty = self.tcx.type_of(item.def_id);

This has the effect of converting the Self type to a semantic ty::Ty, resolving any type alias, so no type alias's DefId ever gets registered in there, hence inherent_impls returns nothing.

[jyn514]

Could we do that by checking inherent_impls(did) before calling resolve_associated_item?

[LeSeulArtichaut]

If I'm right in #86334 (comment), inherent_impls won't return anything for a type alias. I think rustdoc is able to display the implementations for type aliases because it does its own visit of the HIR to collect them. Maybe there's a way to use that here, but when I tried the cache was still empty, I'm assuming it gets populated later in the process.

[jyn514]

Got it. As long as the link works I'm not super concerned about whether it goes to the type alias or not.

[LeSeulArtichaut]

@jyn514 Pushed the code cleanups you requested. Is there anything else you'd want to see in this PR regarding the two remaining review comments?

[jyn514]

I was surprised too, but I couldn't find anything. Maybe I should ask on Zulip.

Opened https://rust-lang.zulipchat.com/#narrow/stream/182449-t-compiler.2Fhelp/topic/DefId.20to.20Res.3F. r=me with the nit fixed if no one responds in the next couple days.

[LeSeulArtichaut]

According to @petrochenkov the current code cannot be improved, so:
@bors r=jyn514

[bors]

📌 Commit dd90900 has been approved by jyn514