Collect lang items from AST, get rid of GenericBound::LangItemTrait

[compiler-errors]

r? @cjgillot
cc #115178

Looking forward, the work to remove QPath::LangItem will also be significantly more difficult, but I plan on doing it as well. Specifically, we have to change:

1. A lot of rustc_ast_lowering for things like expr ..
2. A lot of astconv, since we actually instantiate lang and non-lang paths quite differently.
3. A ton of diagnostics and clippy lints that are special-cased via QPath::LangItem

Meanwhile, it was pretty easy to remove GenericBound::LangItemTrait, so I just did that here.

[compiler-errors]

tools! i never check tools!

@rustbot author

[rustbot]

Some changes occurred in src/tools/clippy

cc @rust-lang/clippy

[compiler-errors]

Actually, I have no idea what is going on here, and I have no idea where to begin debugging this. Help would be appreciated.

[petrochenkov]

Previous attempt - #103662.
I left some comments on that PR, not sure how much they are relevant to this one.
(But I'd like to look at this PR too, maybe this or next week.)

[compiler-errors]

Oh, thanks for that link, @petrochenkov. I see that the same CI failure here was happening on that PR -- ec485f3. I will just cherry-pick that commit.

[cjgillot]

I wonder if we should #118552 to avoid having to maintain such map. Could you add a FIXME with the issue so we can retrieve the question?

[compiler-errors]

@rustbot ready

[cjgillot]

r=me after rebase

[compiler-errors]

I had to modify the check for the number of generic params to handle associated items correctly. This should be ready to go, but I guess I will wait for @cjgillot to look at the last commit in particular.

[petrochenkov]

(I'll also look today or tomorrow.)

[petrochenkov]

The old def_span logic is supposedly reproduced in this PR, so why do some spans change?

[compiler-errors]

I don't reproduce it fully -- I'm just caching the item span here.

In HIR, we do some special span creation to essentially compute the "head span" of each item:

rust/compiler/rustc_middle/src/hir/map/mod.rs

Lines 839 to 948 in ff2c563

	pub fn opt_span(self, hir_id: HirId) -> Option<Span> {
	fn until_within(outer: Span, end: Span) -> Span {
	if let Some(end) = end.find_ancestor_inside(outer) {
	outer.with_hi(end.hi())
	} else {
	outer
	}
	}
	fn named_span(item_span: Span, ident: Ident, generics: Option<&Generics<'_>>) -> Span {
	if ident.name != kw::Empty {
	let mut span = until_within(item_span, ident.span);
	if let Some(g) = generics
	&& !g.span.is_dummy()
	&& let Some(g_span) = g.span.find_ancestor_inside(item_span)
	{
	span = span.to(g_span);
	}
	span
	} else {
	item_span
	}
	}
	let span = match self.find(hir_id)? {
	// Function-like.
	Node::Item(Item { kind: ItemKind::Fn(sig, ..), span: outer_span, .. })
	| Node::TraitItem(TraitItem {
	kind: TraitItemKind::Fn(sig, ..),
	span: outer_span,
	..
	})
	| Node::ImplItem(ImplItem {
	kind: ImplItemKind::Fn(sig, ..), span: outer_span, ..
	}) => {
	// Ensure that the returned span has the item's SyntaxContext, and not the
	// SyntaxContext of the visibility.
	sig.span.find_ancestor_in_same_ctxt(*outer_span).unwrap_or(*outer_span)
	}
	// Impls, including their where clauses.
	Node::Item(Item {
	kind: ItemKind::Impl(Impl { generics, .. }),
	span: outer_span,
	..
	}) => until_within(*outer_span, generics.where_clause_span),
	// Constants and Statics.
	Node::Item(Item {
	kind: ItemKind::Const(ty, ..) | ItemKind::Static(ty, ..),
	span: outer_span,
	..
	})
	| Node::TraitItem(TraitItem {
	kind: TraitItemKind::Const(ty, ..),
	span: outer_span,
	..
	})
	| Node::ImplItem(ImplItem {
	kind: ImplItemKind::Const(ty, ..),
	span: outer_span,
	..
	})
	| Node::ForeignItem(ForeignItem {
	kind: ForeignItemKind::Static(ty, ..),
	span: outer_span,
	..
	}) => until_within(*outer_span, ty.span),
	// With generics and bounds.
	Node::Item(Item {
	kind: ItemKind::Trait(_, _, generics, bounds, _),
	span: outer_span,
	..
	})
	| Node::TraitItem(TraitItem {
	kind: TraitItemKind::Type(bounds, _),
	generics,
	span: outer_span,
	..
	}) => {
	let end = if let Some(b) = bounds.last() { b.span() } else { generics.span };
	until_within(*outer_span, end)
	}
	// Other cases.
	Node::Item(item) => match &item.kind {
	ItemKind::Use(path, _) => {
	// Ensure that the returned span has the item's SyntaxContext, and not the
	// SyntaxContext of the path.
	path.span.find_ancestor_in_same_ctxt(item.span).unwrap_or(item.span)
	}
	_ => named_span(item.span, item.ident, item.kind.generics()),
	},
	Node::Variant(variant) => named_span(variant.span, variant.ident, None),
	Node::ImplItem(item) => named_span(item.span, item.ident, Some(item.generics)),
	Node::ForeignItem(item) => match item.kind {
	ForeignItemKind::Fn(decl, _, _) => until_within(item.span, decl.output.span()),
	_ => named_span(item.span, item.ident, None),
	},
	Node::Ctor(_) => return self.opt_span(self.parent_id(hir_id)),
	Node::Expr(Expr {
	kind: ExprKind::Closure(Closure { fn_decl_span, .. }),
	span,
	..
	}) => {
	// Ensure that the returned span has the item's SyntaxContext.
	fn_decl_span.find_ancestor_inside(*span).unwrap_or(*span)
	}
	_ => self.span_with_body(hir_id),
	};
	debug_assert_eq!(span.ctxt(), self.span_with_body(hir_id).ctxt());
	Some(span)
	}

[bors]

☔ The latest upstream changes (presumably #118500) made this pull request unmergeable. Please resolve the merge conflicts.

[cjgillot]

@bors r+

[bors]

📌 Commit bc1ca6b has been approved by cjgillot

It is now in the queue for this repository.

[pnkfelix]

If I'm interpreting the data on PR #119002 correctly, it seems like this PR was the primary cause of some ~38 smallish (<0.5%) regressions, mostly to check builds, that were flagged in that rollup.