bjoernager/rust
bjoernager/rust
1
Fork 0
Code Issues Pull requests Activity

Auto merge of #120919 - oli-obk:impl_polarity, r=compiler-errors

Browse source 
Merge `impl_polarity` and `impl_trait_ref` queries

Hopefully this is perf neutral. I want to finish https://github.com/rust-lang/rust/pull/120835 and stop using the HIR in `coherent_trait`, which should then give us a perf improvement.
This commit is contained in:
bors 2024-02-13 02:48:49 +00:00
commit d26b417112
22 changed files with 156 additions and 131 deletions
Download patch file Download diff file Expand all files Collapse all files

19
compiler/rustc_hir_analysis/src/astconv/mod.rs
View file

@ -1673,9 +1673,9 @@ impl<'o, 'tcx> dyn AstConv<'tcx> + 'o {
.is_accessible_from(self.item_def_id(), tcx) .is_accessible_from(self.item_def_id(), tcx)
&& tcx.all_impls(*trait_def_id) && tcx.all_impls(*trait_def_id)
.any(|impl_def_id| { .any(|impl_def_id| {
let trait_ref = tcx.impl_trait_ref(impl_def_id); let impl_header = tcx.impl_trait_header(impl_def_id);
trait_ref.is_some_and(|trait_ref| { impl_header.is_some_and(|header| {
let impl_ = trait_ref.instantiate( let header = header.instantiate(
tcx, tcx,
infcx.fresh_args_for_item(DUMMY_SP, impl_def_id), infcx.fresh_args_for_item(DUMMY_SP, impl_def_id),
); );
@ -1687,11 +1687,10 @@ impl<'o, 'tcx> dyn AstConv<'tcx> + 'o {
infcx infcx
.can_eq( .can_eq(
ty::ParamEnv::empty(), ty::ParamEnv::empty(),
impl_.self_ty(), header.trait_ref.self_ty(),
value, value,
) ) && header.polarity != ty::ImplPolarity::Negative
}) })
&& tcx.impl_polarity(impl_def_id) != ty::ImplPolarity::Negative
}) })
}) })
.map(|trait_def_id| tcx.def_path_str(trait_def_id)) .map(|trait_def_id| tcx.def_path_str(trait_def_id))
@ -1737,13 +1736,13 @@ impl<'o, 'tcx> dyn AstConv<'tcx> + 'o {
} else { } else {
// Find all the types that have an `impl` for the trait. // Find all the types that have an `impl` for the trait.
tcx.all_impls(trait_def_id) tcx.all_impls(trait_def_id)
.filter(|impl_def_id| { .filter_map(|impl_def_id| tcx.impl_trait_header(impl_def_id))
.filter(|header| {
// Consider only accessible traits // Consider only accessible traits
tcx.visibility(trait_def_id).is_accessible_from(self.item_def_id(), tcx) tcx.visibility(trait_def_id).is_accessible_from(self.item_def_id(), tcx)
&& tcx.impl_polarity(impl_def_id) != ty::ImplPolarity::Negative && header.skip_binder().polarity != ty::ImplPolarity::Negative
}) })
.filter_map(|impl_def_id| tcx.impl_trait_ref(impl_def_id)) .map(|header| header.instantiate_identity().trait_ref.self_ty())
.map(|impl_| impl_.instantiate_identity().self_ty())
// We don't care about blanket impls. // We don't care about blanket impls.
.filter(|self_ty| !self_ty.has_non_region_param()) .filter(|self_ty| !self_ty.has_non_region_param())
.map(|self_ty| tcx.erase_regions(self_ty).to_string()) .map(|self_ty| tcx.erase_regions(self_ty).to_string())

24
compiler/rustc_hir_analysis/src/check/check.rs
View file

@ -527,8 +527,12 @@ pub(crate) fn check_item_type(tcx: TyCtxt<'_>, def_id: LocalDefId) {
} }
DefKind::Fn => {} // entirely within check_item_body DefKind::Fn => {} // entirely within check_item_body
DefKind::Impl { of_trait } => { DefKind::Impl { of_trait } => {
if of_trait && let Some(impl_trait_ref) = tcx.impl_trait_ref(def_id) { if of_trait && let Some(impl_trait_header) = tcx.impl_trait_header(def_id) {
check_impl_items_against_trait(tcx, def_id, impl_trait_ref.instantiate_identity()); check_impl_items_against_trait(
tcx,
def_id,
impl_trait_header.instantiate_identity(),
);
check_on_unimplemented(tcx, def_id); check_on_unimplemented(tcx, def_id);
} }
} }
@ -719,19 +723,19 @@ pub(super) fn check_specialization_validity<'tcx>(
fn check_impl_items_against_trait<'tcx>( fn check_impl_items_against_trait<'tcx>(
tcx: TyCtxt<'tcx>, tcx: TyCtxt<'tcx>,
impl_id: LocalDefId, impl_id: LocalDefId,
impl_trait_ref: ty::TraitRef<'tcx>, impl_trait_header: ty::ImplTraitHeader<'tcx>,
) { ) {
// If the trait reference itself is erroneous (so the compilation is going // If the trait reference itself is erroneous (so the compilation is going
// to fail), skip checking the items here -- the `impl_item` table in `tcx` // to fail), skip checking the items here -- the `impl_item` table in `tcx`
// isn't populated for such impls. // isn't populated for such impls.
if impl_trait_ref.references_error() { if impl_trait_header.references_error() {
return; return;
} }
let impl_item_refs = tcx.associated_item_def_ids(impl_id); let impl_item_refs = tcx.associated_item_def_ids(impl_id);
// Negative impls are not expected to have any items // Negative impls are not expected to have any items
match tcx.impl_polarity(impl_id) { match impl_trait_header.polarity {
ty::ImplPolarity::Reservation | ty::ImplPolarity::Positive => {} ty::ImplPolarity::Reservation | ty::ImplPolarity::Positive => {}
ty::ImplPolarity::Negative => { ty::ImplPolarity::Negative => {
if let [first_item_ref, ..] = impl_item_refs { if let [first_item_ref, ..] = impl_item_refs {
@ -748,7 +752,7 @@ fn check_impl_items_against_trait<'tcx>(
} }
} }
let trait_def = tcx.trait_def(impl_trait_ref.def_id); let trait_def = tcx.trait_def(impl_trait_header.trait_ref.def_id);
for &impl_item in impl_item_refs { for &impl_item in impl_item_refs {
let ty_impl_item = tcx.associated_item(impl_item); let ty_impl_item = tcx.associated_item(impl_item);
@ -767,10 +771,10 @@ fn check_impl_items_against_trait<'tcx>(
)); ));
} }
ty::AssocKind::Fn => { ty::AssocKind::Fn => {
compare_impl_method(tcx, ty_impl_item, ty_trait_item, impl_trait_ref); compare_impl_method(tcx, ty_impl_item, ty_trait_item, impl_trait_header.trait_ref);
} }
ty::AssocKind::Type => { ty::AssocKind::Type => {
compare_impl_ty(tcx, ty_impl_item, ty_trait_item, impl_trait_ref); compare_impl_ty(tcx, ty_impl_item, ty_trait_item, impl_trait_header.trait_ref);
} }
} }
@ -790,7 +794,7 @@ fn check_impl_items_against_trait<'tcx>(
let mut must_implement_one_of: Option<&[Ident]> = let mut must_implement_one_of: Option<&[Ident]> =
trait_def.must_implement_one_of.as_deref(); trait_def.must_implement_one_of.as_deref();
for &trait_item_id in tcx.associated_item_def_ids(impl_trait_ref.def_id) { for &trait_item_id in tcx.associated_item_def_ids(impl_trait_header.trait_ref.def_id) {
let leaf_def = ancestors.leaf_def(tcx, trait_item_id); let leaf_def = ancestors.leaf_def(tcx, trait_item_id);
let is_implemented = leaf_def let is_implemented = leaf_def
@ -868,7 +872,7 @@ fn check_impl_items_against_trait<'tcx>(
if let Some(missing_items) = must_implement_one_of { if let Some(missing_items) = must_implement_one_of {
let attr_span = tcx let attr_span = tcx
.get_attr(impl_trait_ref.def_id, sym::rustc_must_implement_one_of) .get_attr(impl_trait_header.trait_ref.def_id, sym::rustc_must_implement_one_of)
.map(|attr| attr.span); .map(|attr| attr.span);
missing_items_must_implement_one_of_err( missing_items_must_implement_one_of_err(

15
compiler/rustc_hir_analysis/src/check/wfcheck.rs
View file

@ -245,9 +245,9 @@ fn check_item<'tcx>(tcx: TyCtxt<'tcx>, item: &'tcx hir::Item<'tcx>) -> Result<()
// won't be allowed unless there's an *explicit* implementation of `Send` // won't be allowed unless there's an *explicit* implementation of `Send`
// for `T` // for `T`
hir::ItemKind::Impl(impl_) => { hir::ItemKind::Impl(impl_) => {
let is_auto = tcx let header = tcx.impl_trait_header(def_id);
.impl_trait_ref(def_id) let is_auto = header
.is_some_and(|trait_ref| tcx.trait_is_auto(trait_ref.skip_binder().def_id)); .is_some_and(|header| tcx.trait_is_auto(header.skip_binder().trait_ref.def_id));
let mut res = Ok(()); let mut res = Ok(());
if let (hir::Defaultness::Default { .. }, true) = (impl_.defaultness, is_auto) { if let (hir::Defaultness::Default { .. }, true) = (impl_.defaultness, is_auto) {
let sp = impl_.of_trait.as_ref().map_or(item.span, |t| t.path.span); let sp = impl_.of_trait.as_ref().map_or(item.span, |t| t.path.span);
@ -259,11 +259,12 @@ fn check_item<'tcx>(tcx: TyCtxt<'tcx>, item: &'tcx hir::Item<'tcx>) -> Result<()
.emit()); .emit());
} }
// We match on both `ty::ImplPolarity` and `ast::ImplPolarity` just to get the `!` span. // We match on both `ty::ImplPolarity` and `ast::ImplPolarity` just to get the `!` span.
match tcx.impl_polarity(def_id) { match header.map(|h| h.skip_binder().polarity) {
ty::ImplPolarity::Positive => { // `None` means this is an inherent impl
Some(ty::ImplPolarity::Positive) | None => {
res = res.and(check_impl(tcx, item, impl_.self_ty, &impl_.of_trait)); res = res.and(check_impl(tcx, item, impl_.self_ty, &impl_.of_trait));
} }
ty::ImplPolarity::Negative => { Some(ty::ImplPolarity::Negative) => {
let ast::ImplPolarity::Negative(span) = impl_.polarity else { let ast::ImplPolarity::Negative(span) = impl_.polarity else {
bug!("impl_polarity query disagrees with impl's polarity in AST"); bug!("impl_polarity query disagrees with impl's polarity in AST");
}; };
@ -280,7 +281,7 @@ fn check_item<'tcx>(tcx: TyCtxt<'tcx>, item: &'tcx hir::Item<'tcx>) -> Result<()
.emit()); .emit());
} }
} }
ty::ImplPolarity::Reservation => { Some(ty::ImplPolarity::Reservation) => {
// FIXME: what amount of WF checking do we need for reservation impls? // FIXME: what amount of WF checking do we need for reservation impls?
} }
} }

52
compiler/rustc_hir_analysis/src/collect.rs
View file

@ -79,8 +79,7 @@ pub fn provide(providers: &mut Providers) {
trait_def, trait_def,
adt_def, adt_def,
fn_sig, fn_sig,
impl_trait_ref, impl_trait_header,
impl_polarity,
coroutine_kind, coroutine_kind,
coroutine_for_closure, coroutine_for_closure,
collect_mod_item_types, collect_mod_item_types,
@ -600,7 +599,7 @@ fn convert_item(tcx: TyCtxt<'_>, item_id: hir::ItemId) {
hir::ItemKind::Impl { .. } => { hir::ItemKind::Impl { .. } => {
tcx.ensure().generics_of(def_id); tcx.ensure().generics_of(def_id);
tcx.ensure().type_of(def_id); tcx.ensure().type_of(def_id);
tcx.ensure().impl_trait_ref(def_id); tcx.ensure().impl_trait_header(def_id);
tcx.ensure().predicates_of(def_id); tcx.ensure().predicates_of(def_id);
} }
hir::ItemKind::Trait(..) => { hir::ItemKind::Trait(..) => {
@ -1499,19 +1498,20 @@ fn suggest_impl_trait<'tcx>(
None None
} }
fn impl_trait_ref( fn impl_trait_header(
tcx: TyCtxt<'_>, tcx: TyCtxt<'_>,
def_id: LocalDefId, def_id: LocalDefId,
) -> Option<ty::EarlyBinder<ty::TraitRef<'_>>> { ) -> Option<ty::EarlyBinder<ty::ImplTraitHeader<'_>>> {
let icx = ItemCtxt::new(tcx, def_id); let icx = ItemCtxt::new(tcx, def_id);
let impl_ = tcx.hir().expect_item(def_id).expect_impl(); let item = tcx.hir().expect_item(def_id);
let impl_ = item.expect_impl();
impl_ impl_
.of_trait .of_trait
.as_ref() .as_ref()
.map(|ast_trait_ref| { .map(|ast_trait_ref| {
let selfty = tcx.type_of(def_id).instantiate_identity(); let selfty = tcx.type_of(def_id).instantiate_identity();
if let Some(ErrorGuaranteed { .. }) = check_impl_constness( let trait_ref = if let Some(ErrorGuaranteed { .. }) = check_impl_constness(
tcx, tcx,
tcx.is_const_trait_impl_raw(def_id.to_def_id()), tcx.is_const_trait_impl_raw(def_id.to_def_id()),
ast_trait_ref, ast_trait_ref,
@ -1536,9 +1536,12 @@ fn impl_trait_ref(
icx.astconv().instantiate_mono_trait_ref(trait_ref, selfty) icx.astconv().instantiate_mono_trait_ref(trait_ref, selfty)
} else { } else {
icx.astconv().instantiate_mono_trait_ref(ast_trait_ref, selfty) icx.astconv().instantiate_mono_trait_ref(ast_trait_ref, selfty)
} };
ty::EarlyBinder::bind(ty::ImplTraitHeader {
trait_ref,
polarity: polarity_of_impl(tcx, def_id, impl_, item.span)
})
}) })
.map(ty::EarlyBinder::bind)
} }
fn check_impl_constness( fn check_impl_constness(
@ -1566,43 +1569,34 @@ fn check_impl_constness(
})) }))
} }
fn impl_polarity(tcx: TyCtxt<'_>, def_id: LocalDefId) -> ty::ImplPolarity { fn polarity_of_impl(
tcx: TyCtxt<'_>,
def_id: LocalDefId,
impl_: &hir::Impl<'_>,
span: Span,
) -> ty::ImplPolarity {
let is_rustc_reservation = tcx.has_attr(def_id, sym::rustc_reservation_impl); let is_rustc_reservation = tcx.has_attr(def_id, sym::rustc_reservation_impl);
let item = tcx.hir().expect_item(def_id); match &impl_ {
match &item.kind { hir::Impl { polarity: hir::ImplPolarity::Negative(span), of_trait, .. } => {
hir::ItemKind::Impl(hir::Impl {
polarity: hir::ImplPolarity::Negative(span),
of_trait,
..
}) => {
if is_rustc_reservation { if is_rustc_reservation {
let span = span.to(of_trait.as_ref().map_or(*span, |t| t.path.span)); let span = span.to(of_trait.as_ref().map_or(*span, |t| t.path.span));
tcx.dcx().span_err(span, "reservation impls can't be negative"); tcx.dcx().span_err(span, "reservation impls can't be negative");
} }
ty::ImplPolarity::Negative ty::ImplPolarity::Negative
} }
hir::ItemKind::Impl(hir::Impl { hir::Impl { polarity: hir::ImplPolarity::Positive, of_trait: None, .. } => {
polarity: hir::ImplPolarity::Positive,
of_trait: None,
..
}) => {
if is_rustc_reservation { if is_rustc_reservation {
tcx.dcx().span_err(item.span, "reservation impls can't be inherent"); tcx.dcx().span_err(span, "reservation impls can't be inherent");
} }
ty::ImplPolarity::Positive ty::ImplPolarity::Positive
} }
hir::ItemKind::Impl(hir::Impl { hir::Impl { polarity: hir::ImplPolarity::Positive, of_trait: Some(_), .. } => {
polarity: hir::ImplPolarity::Positive,
of_trait: Some(_),
..
}) => {
if is_rustc_reservation { if is_rustc_reservation {
ty::ImplPolarity::Reservation ty::ImplPolarity::Reservation
} else { } else {
ty::ImplPolarity::Positive ty::ImplPolarity::Positive
} }
} }
item => bug!("impl_polarity: {:?} not an impl", item),
} }
} }

14
compiler/rustc_hir_typeck/src/method/suggest.rs
View file

@ -3134,12 +3134,16 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
if self if self
.tcx .tcx
.all_impls(candidate.def_id) .all_impls(candidate.def_id)
.filter(|imp_did| { .map(|imp_did| {
self.tcx.impl_polarity(*imp_did) == ty::ImplPolarity::Negative self.tcx.impl_trait_header(imp_did).expect(
"inherent impls can't be candidates, only trait impls can be",
)
}) })
.any(|imp_did| { .filter(|header| {
let imp = header.skip_binder().polarity == ty::ImplPolarity::Negative
self.tcx.impl_trait_ref(imp_did).unwrap().instantiate_identity(); })
.any(|header| {
let imp = header.instantiate_identity().trait_ref;
let imp_simp = let imp_simp =
simplify_type(self.tcx, imp.self_ty(), TreatParams::ForLookup); simplify_type(self.tcx, imp.self_ty(), TreatParams::ForLookup);
imp_simp.is_some_and(|s| s == simp_rcvr_ty) imp_simp.is_some_and(|s| s == simp_rcvr_ty)

2
compiler/rustc_incremental/src/persist/dirty_clean.rs
View file

@ -63,7 +63,7 @@ const BASE_HIR: &[&str] = &[
/// `impl` implementation of struct/trait /// `impl` implementation of struct/trait
const BASE_IMPL: &[&str] = const BASE_IMPL: &[&str] =
&[label_strs::associated_item_def_ids, label_strs::generics_of, label_strs::impl_trait_ref]; &[label_strs::associated_item_def_ids, label_strs::generics_of, label_strs::impl_trait_header];
/// DepNodes for mir_built/Optimized, which is relevant in "executable" /// DepNodes for mir_built/Optimized, which is relevant in "executable"
/// code, i.e., functions+methods /// code, i.e., functions+methods

3
compiler/rustc_metadata/src/rmeta/decoder/cstore_impl.rs
View file

@ -215,7 +215,7 @@ provide! { tcx, def_id, other, cdata,
variances_of => { table } variances_of => { table }
fn_sig => { table } fn_sig => { table }
codegen_fn_attrs => { table } codegen_fn_attrs => { table }
impl_trait_ref => { table } impl_trait_header => { table }
const_param_default => { table } const_param_default => { table }
object_lifetime_default => { table } object_lifetime_default => { table }
thir_abstract_const => { table } thir_abstract_const => { table }
@ -234,7 +234,6 @@ provide! { tcx, def_id, other, cdata,
unused_generic_params => { cdata.root.tables.unused_generic_params.get(cdata, def_id.index) } unused_generic_params => { cdata.root.tables.unused_generic_params.get(cdata, def_id.index) }
def_kind => { cdata.def_kind(def_id.index) } def_kind => { cdata.def_kind(def_id.index) }
impl_parent => { table } impl_parent => { table }
impl_polarity => { table_direct }
defaultness => { table_direct } defaultness => { table_direct }
constness => { table_direct } constness => { table_direct }
coerce_unsized_info => { coerce_unsized_info => {

6
compiler/rustc_metadata/src/rmeta/encoder.rs
View file

@ -1969,10 +1969,10 @@ impl<'a, 'tcx> EncodeContext<'a, 'tcx> {
let def_id = id.owner_id.to_def_id(); let def_id = id.owner_id.to_def_id();
self.tables.defaultness.set_some(def_id.index, tcx.defaultness(def_id)); self.tables.defaultness.set_some(def_id.index, tcx.defaultness(def_id));
self.tables.impl_polarity.set_some(def_id.index, tcx.impl_polarity(def_id));
if of_trait && let Some(trait_ref) = tcx.impl_trait_ref(def_id) { if of_trait && let Some(header) = tcx.impl_trait_header(def_id) {
record!(self.tables.impl_trait_ref[def_id] <- trait_ref); record!(self.tables.impl_trait_header[def_id] <- header);
let trait_ref = header.map_bound(|h| h.trait_ref);
let trait_ref = trait_ref.instantiate_identity(); let trait_ref = trait_ref.instantiate_identity();
let simplified_self_ty = fast_reject::simplify_type( let simplified_self_ty = fast_reject::simplify_type(

3
compiler/rustc_metadata/src/rmeta/mod.rs
View file

@ -423,7 +423,7 @@ define_tables! {
variances_of: Table<DefIndex, LazyArray<ty::Variance>>, variances_of: Table<DefIndex, LazyArray<ty::Variance>>,
fn_sig: Table<DefIndex, LazyValue<ty::EarlyBinder<ty::PolyFnSig<'static>>>>, fn_sig: Table<DefIndex, LazyValue<ty::EarlyBinder<ty::PolyFnSig<'static>>>>,
codegen_fn_attrs: Table<DefIndex, LazyValue<CodegenFnAttrs>>, codegen_fn_attrs: Table<DefIndex, LazyValue<CodegenFnAttrs>>,
impl_trait_ref: Table<DefIndex, LazyValue<ty::EarlyBinder<ty::TraitRef<'static>>>>, impl_trait_header: Table<DefIndex, LazyValue<ty::EarlyBinder<ty::ImplTraitHeader<'static>>>>,
const_param_default: Table<DefIndex, LazyValue<ty::EarlyBinder<rustc_middle::ty::Const<'static>>>>, const_param_default: Table<DefIndex, LazyValue<ty::EarlyBinder<rustc_middle::ty::Const<'static>>>>,
object_lifetime_default: Table<DefIndex, LazyValue<ObjectLifetimeDefault>>, object_lifetime_default: Table<DefIndex, LazyValue<ObjectLifetimeDefault>>,
optimized_mir: Table<DefIndex, LazyValue<mir::Body<'static>>>, optimized_mir: Table<DefIndex, LazyValue<mir::Body<'static>>>,
@ -433,7 +433,6 @@ define_tables! {
promoted_mir: Table<DefIndex, LazyValue<IndexVec<mir::Promoted, mir::Body<'static>>>>, promoted_mir: Table<DefIndex, LazyValue<IndexVec<mir::Promoted, mir::Body<'static>>>>,
thir_abstract_const: Table<DefIndex, LazyValue<ty::EarlyBinder<ty::Const<'static>>>>, thir_abstract_const: Table<DefIndex, LazyValue<ty::EarlyBinder<ty::Const<'static>>>>,
impl_parent: Table<DefIndex, RawDefId>, impl_parent: Table<DefIndex, RawDefId>,
impl_polarity: Table<DefIndex, ty::ImplPolarity>,
constness: Table<DefIndex, hir::Constness>, constness: Table<DefIndex, hir::Constness>,
defaultness: Table<DefIndex, hir::Defaultness>, defaultness: Table<DefIndex, hir::Defaultness>,
// FIXME(eddyb) perhaps compute this on the fly if cheap enough? // FIXME(eddyb) perhaps compute this on the fly if cheap enough?

4
compiler/rustc_middle/src/query/erase.rs
View file

@ -177,8 +177,8 @@ impl EraseType for Option<mir::DestructuredConstant<'_>> {
type Result = [u8; size_of::<Option<mir::DestructuredConstant<'static>>>()]; type Result = [u8; size_of::<Option<mir::DestructuredConstant<'static>>>()];
} }
impl EraseType for Option<ty::EarlyBinder<ty::TraitRef<'_>>> { impl EraseType for Option<ty::EarlyBinder<ty::ImplTraitHeader<'_>>> {
type Result = [u8; size_of::<Option<ty::EarlyBinder<ty::TraitRef<'static>>>>()]; type Result = [u8; size_of::<Option<ty::EarlyBinder<ty::ImplTraitHeader<'static>>>>()];
} }
impl EraseType for Option<ty::EarlyBinder<Ty<'_>>> { impl EraseType for Option<ty::EarlyBinder<Ty<'_>>> {

8
compiler/rustc_middle/src/query/mod.rs
View file

@ -846,17 +846,13 @@ rustc_queries! {
cache_on_disk_if { true } cache_on_disk_if { true }
} }
/// Given an `impl_id`, return the trait it implements. /// Given an `impl_id`, return the trait it implements along with some header information.
/// Return `None` if this is an inherent impl. /// Return `None` if this is an inherent impl.
query impl_trait_ref(impl_id: DefId) -> Option<ty::EarlyBinder<ty::TraitRef<'tcx>>> { query impl_trait_header(impl_id: DefId) -> Option<ty::EarlyBinder<ty::ImplTraitHeader<'tcx>>> {
desc { |tcx| "computing trait implemented by `{}`", tcx.def_path_str(impl_id) } desc { |tcx| "computing trait implemented by `{}`", tcx.def_path_str(impl_id) }
cache_on_disk_if { impl_id.is_local() } cache_on_disk_if { impl_id.is_local() }
separate_provide_extern separate_provide_extern
} }
query impl_polarity(impl_id: DefId) -> ty::ImplPolarity {
desc { |tcx| "computing implementation polarity of `{}`", tcx.def_path_str(impl_id) }
separate_provide_extern
}
query issue33140_self_ty(key: DefId) -> Option<ty::EarlyBinder<ty::Ty<'tcx>>> { query issue33140_self_ty(key: DefId) -> Option<ty::EarlyBinder<ty::Ty<'tcx>>> {
desc { |tcx| "computing Self type wrt issue #33140 `{}`", tcx.def_path_str(key) } desc { |tcx| "computing Self type wrt issue #33140 `{}`", tcx.def_path_str(key) }

14
compiler/rustc_middle/src/ty/context.rs
View file

@ -2316,6 +2316,20 @@ impl<'tcx> TyCtxt<'tcx> {
pub fn module_children_local(self, def_id: LocalDefId) -> &'tcx [ModChild] { pub fn module_children_local(self, def_id: LocalDefId) -> &'tcx [ModChild] {
self.resolutions(()).module_children.get(&def_id).map_or(&[], |v| &v[..]) self.resolutions(()).module_children.get(&def_id).map_or(&[], |v| &v[..])
} }
/// Given an `impl_id`, return the trait it implements.
/// Return `None` if this is an inherent impl.
pub fn impl_trait_ref(
self,
def_id: impl IntoQueryParam<DefId>,
) -> Option<ty::EarlyBinder<ty::TraitRef<'tcx>>> {
Some(self.impl_trait_header(def_id)?.map_bound(|h| h.trait_ref))
}
pub fn impl_polarity(self, def_id: impl IntoQueryParam<DefId>) -> ty::ImplPolarity {
self.impl_trait_header(def_id)
.map_or(ty::ImplPolarity::Positive, |h| h.skip_binder().polarity)
}
} }
/// Parameter attributes that can only be determined by examining the body of a function instead /// Parameter attributes that can only be determined by examining the body of a function instead

24
compiler/rustc_middle/src/ty/mod.rs
View file

@ -248,6 +248,12 @@ pub struct ImplHeader<'tcx> {
pub predicates: Vec<Predicate<'tcx>>, pub predicates: Vec<Predicate<'tcx>>,
} }
#[derive(Copy, Clone, Debug, TypeFoldable, TypeVisitable, TyEncodable, TyDecodable, HashStable)]
pub struct ImplTraitHeader<'tcx> {
pub trait_ref: ty::TraitRef<'tcx>,
pub polarity: ImplPolarity,
}
#[derive(Copy, Clone, PartialEq, Eq, Debug, TypeFoldable, TypeVisitable)] #[derive(Copy, Clone, PartialEq, Eq, Debug, TypeFoldable, TypeVisitable)]
pub enum ImplSubject<'tcx> { pub enum ImplSubject<'tcx> {
Trait(TraitRef<'tcx>), Trait(TraitRef<'tcx>),
@ -1602,17 +1608,16 @@ impl<'tcx> TyCtxt<'tcx> {
def_id1: DefId, def_id1: DefId,
def_id2: DefId, def_id2: DefId,
) -> Option<ImplOverlapKind> { ) -> Option<ImplOverlapKind> {
let impl_trait_ref1 = self.impl_trait_ref(def_id1); let impl1 = self.impl_trait_header(def_id1).unwrap().instantiate_identity();
let impl_trait_ref2 = self.impl_trait_ref(def_id2); let impl2 = self.impl_trait_header(def_id2).unwrap().instantiate_identity();
// If either trait impl references an error, they're allowed to overlap, // If either trait impl references an error, they're allowed to overlap,
// as one of them essentially doesn't exist. // as one of them essentially doesn't exist.
if impl_trait_ref1.is_some_and(|tr| tr.instantiate_identity().references_error()) if impl1.references_error() || impl2.references_error() {
|| impl_trait_ref2.is_some_and(|tr| tr.instantiate_identity().references_error())
{
return Some(ImplOverlapKind::Permitted { marker: false }); return Some(ImplOverlapKind::Permitted { marker: false });
} }
match (self.impl_polarity(def_id1), self.impl_polarity(def_id2)) { match (impl1.polarity, impl2.polarity) {
(ImplPolarity::Reservation, _) | (_, ImplPolarity::Reservation) => { (ImplPolarity::Reservation, _) | (_, ImplPolarity::Reservation) => {
// `#[rustc_reservation_impl]` impls don't overlap with anything // `#[rustc_reservation_impl]` impls don't overlap with anything
return Some(ImplOverlapKind::Permitted { marker: false }); return Some(ImplOverlapKind::Permitted { marker: false });
@ -1627,10 +1632,9 @@ impl<'tcx> TyCtxt<'tcx> {
}; };
let is_marker_overlap = { let is_marker_overlap = {
let is_marker_impl = |trait_ref: Option<EarlyBinder<TraitRef<'_>>>| -> bool { let is_marker_impl =
trait_ref.is_some_and(|tr| self.trait_def(tr.skip_binder().def_id).is_marker) |trait_ref: TraitRef<'_>| -> bool { self.trait_def(trait_ref.def_id).is_marker };
}; is_marker_impl(impl1.trait_ref) && is_marker_impl(impl2.trait_ref)
is_marker_impl(impl_trait_ref1) && is_marker_impl(impl_trait_ref2)
}; };
if is_marker_overlap { if is_marker_overlap {

1
compiler/rustc_middle/src/ty/parameterized.rs
View file

@ -134,4 +134,5 @@ parameterized_over_tcx! {
ty::Predicate, ty::Predicate,
ty::Clause, ty::Clause,
ty::ClauseKind, ty::ClauseKind,
ty::ImplTraitHeader
} }

13
compiler/rustc_monomorphize/src/collector.rs
View file

@ -1347,8 +1347,11 @@ fn create_mono_items_for_default_impls<'tcx>(
item: hir::ItemId, item: hir::ItemId,
output: &mut MonoItems<'tcx>, output: &mut MonoItems<'tcx>,
) { ) {
let polarity = tcx.impl_polarity(item.owner_id); let Some(impl_) = tcx.impl_trait_header(item.owner_id) else {
if matches!(polarity, ty::ImplPolarity::Negative) { return;
};
if matches!(impl_.skip_binder().polarity, ty::ImplPolarity::Negative) {
return; return;
} }
@ -1356,10 +1359,6 @@ fn create_mono_items_for_default_impls<'tcx>(
return; return;
} }
let Some(trait_ref) = tcx.impl_trait_ref(item.owner_id) else {
return;
};
// Lifetimes never affect trait selection, so we are allowed to eagerly // Lifetimes never affect trait selection, so we are allowed to eagerly
// instantiate an instance of an impl method if the impl (and method, // instantiate an instance of an impl method if the impl (and method,
// which we check below) is only parameterized over lifetime. In that case, // which we check below) is only parameterized over lifetime. In that case,
@ -1376,7 +1375,7 @@ fn create_mono_items_for_default_impls<'tcx>(
} }
}; };
let impl_args = GenericArgs::for_item(tcx, item.owner_id.to_def_id(), only_region_params); let impl_args = GenericArgs::for_item(tcx, item.owner_id.to_def_id(), only_region_params);
let trait_ref = trait_ref.instantiate(tcx, impl_args); let trait_ref = impl_.instantiate(tcx, impl_args).trait_ref;
// Unlike 'lazy' monomorphization that begins by collecting items transitively // Unlike 'lazy' monomorphization that begins by collecting items transitively
// called by `main` or other global items, when eagerly monomorphizing impl // called by `main` or other global items, when eagerly monomorphizing impl

11
compiler/rustc_trait_selection/src/solve/trait_goals.rs
View file

@ -39,15 +39,18 @@ impl<'tcx> assembly::GoalKind<'tcx> for TraitPredicate<'tcx> {
) -> Result<Candidate<'tcx>, NoSolution> { ) -> Result<Candidate<'tcx>, NoSolution> {
let tcx = ecx.tcx(); let tcx = ecx.tcx();
let impl_trait_ref = tcx.impl_trait_ref(impl_def_id).unwrap(); let impl_trait_header = tcx.impl_trait_header(impl_def_id).unwrap();
let drcx = DeepRejectCtxt { treat_obligation_params: TreatParams::ForLookup }; let drcx = DeepRejectCtxt { treat_obligation_params: TreatParams::ForLookup };
if !drcx.args_may_unify(goal.predicate.trait_ref.args, impl_trait_ref.skip_binder().args) { if !drcx.args_may_unify(
goal.predicate.trait_ref.args,
impl_trait_header.skip_binder().trait_ref.args,
) {
return Err(NoSolution); return Err(NoSolution);
} }
let impl_polarity = tcx.impl_polarity(impl_def_id);
// An upper bound of the certainty of this goal, used to lower the certainty // An upper bound of the certainty of this goal, used to lower the certainty
// of reservation impl to ambiguous during coherence. // of reservation impl to ambiguous during coherence.
let impl_polarity = impl_trait_header.skip_binder().polarity;
let maximal_certainty = match impl_polarity { let maximal_certainty = match impl_polarity {
ty::ImplPolarity::Positive | ty::ImplPolarity::Negative => { ty::ImplPolarity::Positive | ty::ImplPolarity::Negative => {
match impl_polarity == goal.predicate.polarity { match impl_polarity == goal.predicate.polarity {
@ -63,7 +66,7 @@ impl<'tcx> assembly::GoalKind<'tcx> for TraitPredicate<'tcx> {
ecx.probe_trait_candidate(CandidateSource::Impl(impl_def_id)).enter(|ecx| { ecx.probe_trait_candidate(CandidateSource::Impl(impl_def_id)).enter(|ecx| {
let impl_args = ecx.fresh_args_for_item(impl_def_id); let impl_args = ecx.fresh_args_for_item(impl_def_id);
let impl_trait_ref = impl_trait_ref.instantiate(tcx, impl_args); let impl_trait_ref = impl_trait_header.instantiate(tcx, impl_args).trait_ref;
ecx.eq(goal.param_env, goal.predicate.trait_ref, impl_trait_ref)?; ecx.eq(goal.param_env, goal.predicate.trait_ref, impl_trait_ref)?;
let where_clause_bounds = tcx let where_clause_bounds = tcx

15
compiler/rustc_trait_selection/src/traits/error_reporting/type_err_ctxt_ext.rs
View file

@ -1976,13 +1976,13 @@ impl<'tcx> InferCtxtPrivExt<'tcx> for TypeErrCtxt<'_, 'tcx> {
.tcx .tcx
.all_impls(trait_pred.def_id()) .all_impls(trait_pred.def_id())
.filter_map(|def_id| { .filter_map(|def_id| {
if self.tcx.impl_polarity(def_id) == ty::ImplPolarity::Negative let imp = self.tcx.impl_trait_header(def_id).unwrap().skip_binder();
if imp.polarity == ty::ImplPolarity::Negative
|| !self.tcx.is_user_visible_dep(def_id.krate) || !self.tcx.is_user_visible_dep(def_id.krate)
{ {
return None; return None;
} }
let imp = imp.trait_ref;
let imp = self.tcx.impl_trait_ref(def_id).unwrap().skip_binder();
self.fuzzy_match_tys(trait_pred.skip_binder().self_ty(), imp.self_ty(), false).map( self.fuzzy_match_tys(trait_pred.skip_binder().self_ty(), imp.self_ty(), false).map(
|similarity| ImplCandidate { trait_ref: imp, similarity, impl_def_id: def_id }, |similarity| ImplCandidate { trait_ref: imp, similarity, impl_def_id: def_id },
@ -2161,12 +2161,13 @@ impl<'tcx> InferCtxtPrivExt<'tcx> for TypeErrCtxt<'_, 'tcx> {
.tcx .tcx
.all_impls(def_id) .all_impls(def_id)
// Ignore automatically derived impls and `!Trait` impls. // Ignore automatically derived impls and `!Trait` impls.
.filter(|&def_id| { .filter_map(|def_id| self.tcx.impl_trait_header(def_id))
self.tcx.impl_polarity(def_id) != ty::ImplPolarity::Negative .map(ty::EarlyBinder::instantiate_identity)
.filter(|header| {
header.polarity != ty::ImplPolarity::Negative
|| self.tcx.is_automatically_derived(def_id) || self.tcx.is_automatically_derived(def_id)
}) })
.filter_map(|def_id| self.tcx.impl_trait_ref(def_id)) .map(|header| header.trait_ref)
.map(ty::EarlyBinder::instantiate_identity)
.filter(|trait_ref| { .filter(|trait_ref| {
let self_ty = trait_ref.self_ty(); let self_ty = trait_ref.self_ty();
// Avoid mentioning type parameters. // Avoid mentioning type parameters.

10
compiler/rustc_trait_selection/src/traits/select/candidate_assembly.rs
View file

@ -560,20 +560,22 @@ impl<'cx, 'tcx> SelectionContext<'cx, 'tcx> {
// Before we create the generic parameters and everything, first // Before we create the generic parameters and everything, first
// consider a "quick reject". This avoids creating more types // consider a "quick reject". This avoids creating more types
// and so forth that we need to. // and so forth that we need to.
let impl_trait_ref = self.tcx().impl_trait_ref(impl_def_id).unwrap(); let impl_trait_header = self.tcx().impl_trait_header(impl_def_id).unwrap();
if !drcx.args_may_unify(obligation_args, impl_trait_ref.skip_binder().args) { if !drcx
.args_may_unify(obligation_args, impl_trait_header.skip_binder().trait_ref.args)
{
return; return;
} }
if self.reject_fn_ptr_impls( if self.reject_fn_ptr_impls(
impl_def_id, impl_def_id,
obligation, obligation,
impl_trait_ref.skip_binder().self_ty(), impl_trait_header.skip_binder().trait_ref.self_ty(),
) { ) {
return; return;
} }
self.infcx.probe(|_| { self.infcx.probe(|_| {
if let Ok(_args) = self.match_impl(impl_def_id, impl_trait_ref, obligation) { if let Ok(_args) = self.match_impl(impl_def_id, impl_trait_header, obligation) {
candidates.vec.push(ImplCandidate(impl_def_id)); candidates.vec.push(ImplCandidate(impl_def_id));
} }
}); });

18
compiler/rustc_trait_selection/src/traits/select/mod.rs
View file

@ -2412,8 +2412,8 @@ impl<'tcx> SelectionContext<'_, 'tcx> {
impl_def_id: DefId, impl_def_id: DefId,
obligation: &PolyTraitObligation<'tcx>, obligation: &PolyTraitObligation<'tcx>,
) -> Normalized<'tcx, GenericArgsRef<'tcx>> { ) -> Normalized<'tcx, GenericArgsRef<'tcx>> {
let impl_trait_ref = self.tcx().impl_trait_ref(impl_def_id).unwrap(); let impl_trait_header = self.tcx().impl_trait_header(impl_def_id).unwrap();
match self.match_impl(impl_def_id, impl_trait_ref, obligation) { match self.match_impl(impl_def_id, impl_trait_header, obligation) {
Ok(args) => args, Ok(args) => args,
Err(()) => { Err(()) => {
// FIXME: A rematch may fail when a candidate cache hit occurs // FIXME: A rematch may fail when a candidate cache hit occurs
@ -2446,7 +2446,7 @@ impl<'tcx> SelectionContext<'_, 'tcx> {
fn match_impl( fn match_impl(
&mut self, &mut self,
impl_def_id: DefId, impl_def_id: DefId,
impl_trait_ref: EarlyBinder<ty::TraitRef<'tcx>>, impl_trait_header: EarlyBinder<ty::ImplTraitHeader<'tcx>>,
obligation: &PolyTraitObligation<'tcx>, obligation: &PolyTraitObligation<'tcx>,
) -> Result<Normalized<'tcx, GenericArgsRef<'tcx>>, ()> { ) -> Result<Normalized<'tcx, GenericArgsRef<'tcx>>, ()> {
let placeholder_obligation = let placeholder_obligation =
@ -2455,12 +2455,12 @@ impl<'tcx> SelectionContext<'_, 'tcx> {
let impl_args = self.infcx.fresh_args_for_item(obligation.cause.span, impl_def_id); let impl_args = self.infcx.fresh_args_for_item(obligation.cause.span, impl_def_id);
let impl_trait_ref = impl_trait_ref.instantiate(self.tcx(), impl_args); let impl_trait_header = impl_trait_header.instantiate(self.tcx(), impl_args);
if impl_trait_ref.references_error() { if impl_trait_header.references_error() {
return Err(()); return Err(());
} }
debug!(?impl_trait_ref); debug!(?impl_trait_header);
let Normalized { value: impl_trait_ref, obligations: mut nested_obligations } = let Normalized { value: impl_trait_ref, obligations: mut nested_obligations } =
ensure_sufficient_stack(|| { ensure_sufficient_stack(|| {
@ -2469,7 +2469,7 @@ impl<'tcx> SelectionContext<'_, 'tcx> {
obligation.param_env, obligation.param_env,
obligation.cause.clone(), obligation.cause.clone(),
obligation.recursion_depth + 1, obligation.recursion_depth + 1,
impl_trait_ref, impl_trait_header.trait_ref,
) )
}); });
@ -2490,9 +2490,7 @@ impl<'tcx> SelectionContext<'_, 'tcx> {
})?; })?;
nested_obligations.extend(obligations); nested_obligations.extend(obligations);
if !self.is_intercrate() if !self.is_intercrate() && impl_trait_header.polarity == ty::ImplPolarity::Reservation {
&& self.tcx().impl_polarity(impl_def_id) == ty::ImplPolarity::Reservation
{
debug!("reservation impls only apply in intercrate mode"); debug!("reservation impls only apply in intercrate mode");
return Err(()); return Err(());
} }

16
compiler/rustc_trait_selection/src/traits/specialize/mod.rs
View file

@ -168,6 +168,8 @@ pub(super) fn specializes(tcx: TyCtxt<'_>, (impl1_def_id, impl2_def_id): (DefId,
} }
} }
let impl1_trait_header = tcx.impl_trait_header(impl1_def_id).unwrap().instantiate_identity();
// We determine whether there's a subset relationship by: // We determine whether there's a subset relationship by:
// //
// - replacing bound vars with placeholders in impl1, // - replacing bound vars with placeholders in impl1,
@ -181,21 +183,25 @@ pub(super) fn specializes(tcx: TyCtxt<'_>, (impl1_def_id, impl2_def_id): (DefId,
// See RFC 1210 for more details and justification. // See RFC 1210 for more details and justification.
// Currently we do not allow e.g., a negative impl to specialize a positive one // Currently we do not allow e.g., a negative impl to specialize a positive one
if tcx.impl_polarity(impl1_def_id) != tcx.impl_polarity(impl2_def_id) { if impl1_trait_header.polarity != tcx.impl_polarity(impl2_def_id) {
return false; return false;
} }
// create a parameter environment corresponding to a (placeholder) instantiation of impl1 // create a parameter environment corresponding to a (placeholder) instantiation of impl1
let penv = tcx.param_env(impl1_def_id); let penv = tcx.param_env(impl1_def_id);
let impl1_trait_ref = tcx.impl_trait_ref(impl1_def_id).unwrap().instantiate_identity();
// Create an infcx, taking the predicates of impl1 as assumptions: // Create an infcx, taking the predicates of impl1 as assumptions:
let infcx = tcx.infer_ctxt().build(); let infcx = tcx.infer_ctxt().build();
// Attempt to prove that impl2 applies, given all of the above. // Attempt to prove that impl2 applies, given all of the above.
fulfill_implication(&infcx, penv, impl1_trait_ref, impl1_def_id, impl2_def_id, |_, _| { fulfill_implication(
ObligationCause::dummy() &infcx,
}) penv,
impl1_trait_header.trait_ref,
impl1_def_id,
impl2_def_id,
|_, _| ObligationCause::dummy(),
)
.is_ok() .is_ok()
} }

7
compiler/rustc_ty_utils/src/ty.rs
View file

@ -257,14 +257,15 @@ fn param_env_reveal_all_normalized(tcx: TyCtxt<'_>, def_id: DefId) -> ty::ParamE
fn issue33140_self_ty(tcx: TyCtxt<'_>, def_id: DefId) -> Option<EarlyBinder<Ty<'_>>> { fn issue33140_self_ty(tcx: TyCtxt<'_>, def_id: DefId) -> Option<EarlyBinder<Ty<'_>>> {
debug!("issue33140_self_ty({:?})", def_id); debug!("issue33140_self_ty({:?})", def_id);
let trait_ref = tcx let impl_ = tcx
.impl_trait_ref(def_id) .impl_trait_header(def_id)
.unwrap_or_else(|| bug!("issue33140_self_ty called on inherent impl {:?}", def_id)) .unwrap_or_else(|| bug!("issue33140_self_ty called on inherent impl {:?}", def_id))
.skip_binder(); .skip_binder();
let trait_ref = impl_.trait_ref;
debug!("issue33140_self_ty({:?}), trait-ref={:?}", def_id, trait_ref); debug!("issue33140_self_ty({:?}), trait-ref={:?}", def_id, trait_ref);
let is_marker_like = tcx.impl_polarity(def_id) == ty::ImplPolarity::Positive let is_marker_like = impl_.polarity == ty::ImplPolarity::Positive
&& tcx.associated_item_def_ids(trait_ref.def_id).is_empty(); && tcx.associated_item_def_ids(trait_ref.def_id).is_empty();
// Check whether these impls would be ok for a marker trait. // Check whether these impls would be ok for a marker trait.

8
tests/incremental/hashes/trait_impls.rs
View file

@ -462,9 +462,9 @@ impl AddTypeParameterToImpl<u32> for Bar<u32> {
} }
#[cfg(not(any(cfail1,cfail4)))] #[cfg(not(any(cfail1,cfail4)))]
#[rustc_clean(except="opt_hir_owner_nodes,generics_of,impl_trait_ref", cfg="cfail2")] #[rustc_clean(except="opt_hir_owner_nodes,generics_of,impl_trait_header", cfg="cfail2")]
#[rustc_clean(cfg="cfail3")] #[rustc_clean(cfg="cfail3")]
#[rustc_clean(except="opt_hir_owner_nodes,generics_of,impl_trait_ref", cfg="cfail5")] #[rustc_clean(except="opt_hir_owner_nodes,generics_of,impl_trait_header", cfg="cfail5")]
#[rustc_clean(cfg="cfail6")] #[rustc_clean(cfg="cfail6")]
impl<TTT> AddTypeParameterToImpl<TTT> for Bar<TTT> { impl<TTT> AddTypeParameterToImpl<TTT> for Bar<TTT> {
#[rustc_clean( #[rustc_clean(
@ -493,9 +493,9 @@ impl ChangeSelfTypeOfImpl for u32 {
} }
#[cfg(not(any(cfail1,cfail4)))] #[cfg(not(any(cfail1,cfail4)))]
#[rustc_clean(except="opt_hir_owner_nodes,impl_trait_ref", cfg="cfail2")] #[rustc_clean(except="opt_hir_owner_nodes,impl_trait_header", cfg="cfail2")]
#[rustc_clean(cfg="cfail3")] #[rustc_clean(cfg="cfail3")]
#[rustc_clean(except="opt_hir_owner_nodes,impl_trait_ref", cfg="cfail5")] #[rustc_clean(except="opt_hir_owner_nodes,impl_trait_header", cfg="cfail5")]
#[rustc_clean(cfg="cfail6")] #[rustc_clean(cfg="cfail6")]
impl ChangeSelfTypeOfImpl for u64 { impl ChangeSelfTypeOfImpl for u64 {
#[rustc_clean(except="fn_sig,typeck,optimized_mir", cfg="cfail2")] #[rustc_clean(except="fn_sig,typeck,optimized_mir", cfg="cfail2")]