diff --git a/compiler/rustc_hir_analysis/src/check/compare_impl_item.rs b/compiler/rustc_hir_analysis/src/check/compare_impl_item.rs
index 7332888c5f913..8262a79d2e55e 100644
--- a/compiler/rustc_hir_analysis/src/check/compare_impl_item.rs
+++ b/compiler/rustc_hir_analysis/src/check/compare_impl_item.rs
@@ -424,12 +424,12 @@ fn compare_method_predicate_entailment<'tcx>(
Ok(())
}
-struct RemapLateParam<'a, 'tcx> {
+struct RemapLateParam<'tcx> {
tcx: TyCtxt<'tcx>,
- mapping: &'a FxIndexMap<ty::LateParamRegionKind, ty::LateParamRegionKind>,
+ mapping: FxIndexMap<ty::LateParamRegionKind, ty::LateParamRegionKind>,
}
-impl<'tcx> TypeFolder<TyCtxt<'tcx>> for RemapLateParam<'_, 'tcx> {
+impl<'tcx> TypeFolder<TyCtxt<'tcx>> for RemapLateParam<'tcx> {
fn cx(&self) -> TyCtxt<'tcx> {
self.tcx
}
diff --git a/compiler/rustc_hir_analysis/src/check/compare_impl_item/refine.rs b/compiler/rustc_hir_analysis/src/check/compare_impl_item/refine.rs
index 494e9560c8154..0e9e9b48ab309 100644
--- a/compiler/rustc_hir_analysis/src/check/compare_impl_item/refine.rs
+++ b/compiler/rustc_hir_analysis/src/check/compare_impl_item/refine.rs
@@ -299,8 +299,7 @@ fn report_mismatched_rpitit_signature<'tcx>(
})
.collect();
- let mut return_ty =
- trait_m_sig.output().fold_with(&mut super::RemapLateParam { tcx, mapping: &mapping });
+ let mut return_ty = trait_m_sig.output().fold_with(&mut super::RemapLateParam { tcx, mapping });
if tcx.asyncness(impl_m_def_id).is_async() && tcx.asyncness(trait_m_def_id).is_async() {
let ty::Alias(ty::Projection, future_ty) = return_ty.kind() else {
diff --git a/compiler/rustc_hir_analysis/src/check/dropck.rs b/compiler/rustc_hir_analysis/src/check/dropck.rs
index 0876bb828485d..d7dfe482da449 100644
--- a/compiler/rustc_hir_analysis/src/check/dropck.rs
+++ b/compiler/rustc_hir_analysis/src/check/dropck.rs
@@ -1,7 +1,3 @@
-// FIXME(@lcnr): Move this module out of `rustc_hir_analysis`.
-//
-// We don't do any drop checking during hir typeck.
-
use rustc_data_structures::fx::FxHashSet;
use rustc_errors::codes::*;
use rustc_errors::{ErrorGuaranteed, struct_span_code_err};
@@ -32,7 +28,10 @@ use crate::hir::def_id::{DefId, LocalDefId};
/// struct/enum definition for the nominal type itself (i.e.
/// cannot do `struct S<T>; impl<T:Clone> Drop for S<T> { ... }`).
///
-pub fn check_drop_impl(tcx: TyCtxt<'_>, drop_impl_did: DefId) -> Result<(), ErrorGuaranteed> {
+pub(crate) fn check_drop_impl(
+ tcx: TyCtxt<'_>,
+ drop_impl_did: DefId,
+) -> Result<(), ErrorGuaranteed> {
match tcx.impl_polarity(drop_impl_did) {
ty::ImplPolarity::Positive => {}
ty::ImplPolarity::Negative => {
diff --git a/compiler/rustc_hir_analysis/src/check/intrinsic.rs b/compiler/rustc_hir_analysis/src/check/intrinsic.rs
index 8aa95d1c1d516..cf3d489730425 100644
--- a/compiler/rustc_hir_analysis/src/check/intrinsic.rs
+++ b/compiler/rustc_hir_analysis/src/check/intrinsic.rs
@@ -199,7 +199,8 @@ pub fn check_intrinsic_type(
let split: Vec<&str> = name_str.split('_').collect();
assert!(split.len() >= 2, "Atomic intrinsic in an incorrect format");
- //We only care about the operation here
+ // Each atomic op has variants with different suffixes (`_seq_cst`, `_acquire`, etc.). Use
+ // string ops to strip the suffixes, because the variants all get the same treatment here.
let (n_tps, inputs, output) = match split[1] {
"cxchg" | "cxchgweak" => (
1,
diff --git a/compiler/rustc_hir_analysis/src/check/mod.rs b/compiler/rustc_hir_analysis/src/check/mod.rs
index 814c784710a1f..5723e89236b3a 100644
--- a/compiler/rustc_hir_analysis/src/check/mod.rs
+++ b/compiler/rustc_hir_analysis/src/check/mod.rs
@@ -455,18 +455,14 @@ fn fn_sig_suggestion<'tcx>(
let mut output = sig.output();
let asyncness = if tcx.asyncness(assoc.def_id).is_async() {
- output = if let ty::Alias(_, alias_ty) = *output.kind() {
- tcx.explicit_item_self_bounds(alias_ty.def_id)
+ output = if let ty::Alias(_, alias_ty) = *output.kind()
+ && let Some(output) = tcx
+ .explicit_item_self_bounds(alias_ty.def_id)
.iter_instantiated_copied(tcx, alias_ty.args)
.find_map(|(bound, _)| {
bound.as_projection_clause()?.no_bound_vars()?.term.as_type()
- })
- .unwrap_or_else(|| {
- span_bug!(
- ident.span,
- "expected async fn to have `impl Future` output, but it returns {output}"
- )
- })
+ }) {
+ output
} else {
span_bug!(
ident.span,
diff --git a/compiler/rustc_hir_analysis/src/check/wfcheck.rs b/compiler/rustc_hir_analysis/src/check/wfcheck.rs
index 83bb8c0dfaf1b..c9837ca3716c6 100644
--- a/compiler/rustc_hir_analysis/src/check/wfcheck.rs
+++ b/compiler/rustc_hir_analysis/src/check/wfcheck.rs
@@ -2267,14 +2267,12 @@ impl<'tcx> WfCheckingCtxt<'_, 'tcx> {
fn check_mod_type_wf(tcx: TyCtxt<'_>, module: LocalModDefId) -> Result<(), ErrorGuaranteed> {
let items = tcx.hir_module_items(module);
- let mut res = items.par_items(|item| tcx.ensure().check_well_formed(item.owner_id.def_id));
- res =
- res.and(items.par_impl_items(|item| tcx.ensure().check_well_formed(item.owner_id.def_id)));
- res =
- res.and(items.par_trait_items(|item| tcx.ensure().check_well_formed(item.owner_id.def_id)));
- res = res
- .and(items.par_foreign_items(|item| tcx.ensure().check_well_formed(item.owner_id.def_id)));
- res = res.and(items.par_opaques(|item| tcx.ensure().check_well_formed(item)));
+ let res = items
+ .par_items(|item| tcx.ensure().check_well_formed(item.owner_id.def_id))
+ .and(items.par_impl_items(|item| tcx.ensure().check_well_formed(item.owner_id.def_id)))
+ .and(items.par_trait_items(|item| tcx.ensure().check_well_formed(item.owner_id.def_id)))
+ .and(items.par_foreign_items(|item| tcx.ensure().check_well_formed(item.owner_id.def_id)))
+ .and(items.par_opaques(|item| tcx.ensure().check_well_formed(item)));
if module == LocalModDefId::CRATE_DEF_ID {
super::entry::check_for_entry_fn(tcx);
}
diff --git a/compiler/rustc_hir_analysis/src/coherence/builtin.rs b/compiler/rustc_hir_analysis/src/coherence/builtin.rs
index 6bbd76633da8f..30f51fe17246f 100644
--- a/compiler/rustc_hir_analysis/src/coherence/builtin.rs
+++ b/compiler/rustc_hir_analysis/src/coherence/builtin.rs
@@ -404,17 +404,12 @@ pub(crate) fn coerce_unsized_info<'tcx>(
check_mutbl(mt_a, mt_b, &|ty| Ty::new_imm_ref(tcx, r_b, ty))
}
- (&ty::Ref(_, ty_a, mutbl_a), &ty::RawPtr(ty_b, mutbl_b)) => check_mutbl(
- ty::TypeAndMut { ty: ty_a, mutbl: mutbl_a },
- ty::TypeAndMut { ty: ty_b, mutbl: mutbl_b },
- &|ty| Ty::new_imm_ptr(tcx, ty),
- ),
-
- (&ty::RawPtr(ty_a, mutbl_a), &ty::RawPtr(ty_b, mutbl_b)) => check_mutbl(
- ty::TypeAndMut { ty: ty_a, mutbl: mutbl_a },
- ty::TypeAndMut { ty: ty_b, mutbl: mutbl_b },
- &|ty| Ty::new_imm_ptr(tcx, ty),
- ),
+ (&ty::Ref(_, ty_a, mutbl_a), &ty::RawPtr(ty_b, mutbl_b))
+ | (&ty::RawPtr(ty_a, mutbl_a), &ty::RawPtr(ty_b, mutbl_b)) => {
+ let mt_a = ty::TypeAndMut { ty: ty_a, mutbl: mutbl_a };
+ let mt_b = ty::TypeAndMut { ty: ty_b, mutbl: mutbl_b };
+ check_mutbl(mt_a, mt_b, &|ty| Ty::new_imm_ptr(tcx, ty))
+ }
(&ty::Adt(def_a, args_a), &ty::Adt(def_b, args_b))
if def_a.is_struct() && def_b.is_struct() =>
diff --git a/compiler/rustc_hir_analysis/src/coherence/mod.rs b/compiler/rustc_hir_analysis/src/coherence/mod.rs
index 4e5f0a3186a9a..b1f73a903d81f 100644
--- a/compiler/rustc_hir_analysis/src/coherence/mod.rs
+++ b/compiler/rustc_hir_analysis/src/coherence/mod.rs
@@ -158,12 +158,12 @@ fn coherent_trait(tcx: TyCtxt<'_>, def_id: DefId) -> Result<(), ErrorGuaranteed>
let trait_ref = trait_header.trait_ref.instantiate_identity();
let trait_def = tcx.trait_def(trait_ref.def_id);
- res = res.and(check_impl(tcx, impl_def_id, trait_ref, trait_def));
- res = res.and(check_object_overlap(tcx, impl_def_id, trait_ref));
-
- res = res.and(unsafety::check_item(tcx, impl_def_id, trait_header, trait_def));
- res = res.and(tcx.ensure().orphan_check_impl(impl_def_id));
- res = res.and(builtin::check_trait(tcx, def_id, impl_def_id, trait_header));
+ res = res
+ .and(check_impl(tcx, impl_def_id, trait_ref, trait_def))
+ .and(check_object_overlap(tcx, impl_def_id, trait_ref))
+ .and(unsafety::check_item(tcx, impl_def_id, trait_header, trait_def))
+ .and(tcx.ensure().orphan_check_impl(impl_def_id))
+ .and(builtin::check_trait(tcx, def_id, impl_def_id, trait_header));
}
res
diff --git a/compiler/rustc_hir_analysis/src/collect.rs b/compiler/rustc_hir_analysis/src/collect.rs
index cad7b2a1e57b9..226370fccadde 100644
--- a/compiler/rustc_hir_analysis/src/collect.rs
+++ b/compiler/rustc_hir_analysis/src/collect.rs
@@ -57,7 +57,7 @@ mod type_of;
///////////////////////////////////////////////////////////////////////////
-pub fn provide(providers: &mut Providers) {
+pub(crate) fn provide(providers: &mut Providers) {
resolve_bound_vars::provide(providers);
*providers = Providers {
type_of: type_of::type_of,
@@ -122,7 +122,7 @@ pub fn provide(providers: &mut Providers) {
/// `ItemCtxt` is parameterized by a `DefId` that it uses to satisfy
/// `probe_ty_param_bounds` requests, drawing the information from
/// the HIR (`hir::Generics`), recursively.
-pub struct ItemCtxt<'tcx> {
+pub(crate) struct ItemCtxt<'tcx> {
tcx: TyCtxt<'tcx>,
item_def_id: LocalDefId,
tainted_by_errors: Cell<Option<ErrorGuaranteed>>,
@@ -148,7 +148,7 @@ impl<'v> Visitor<'v> for HirPlaceholderCollector {
}
}
-pub struct CollectItemTypesVisitor<'tcx> {
+pub(crate) struct CollectItemTypesVisitor<'tcx> {
pub tcx: TyCtxt<'tcx>,
}
@@ -364,19 +364,19 @@ fn bad_placeholder<'cx, 'tcx>(
}
impl<'tcx> ItemCtxt<'tcx> {
- pub fn new(tcx: TyCtxt<'tcx>, item_def_id: LocalDefId) -> ItemCtxt<'tcx> {
+ pub(crate) fn new(tcx: TyCtxt<'tcx>, item_def_id: LocalDefId) -> ItemCtxt<'tcx> {
ItemCtxt { tcx, item_def_id, tainted_by_errors: Cell::new(None) }
}
- pub fn lower_ty(&self, hir_ty: &hir::Ty<'tcx>) -> Ty<'tcx> {
+ pub(crate) fn lower_ty(&self, hir_ty: &hir::Ty<'tcx>) -> Ty<'tcx> {
self.lowerer().lower_ty(hir_ty)
}
- pub fn hir_id(&self) -> hir::HirId {
+ pub(crate) fn hir_id(&self) -> hir::HirId {
self.tcx.local_def_id_to_hir_id(self.item_def_id)
}
- pub fn node(&self) -> hir::Node<'tcx> {
+ pub(crate) fn node(&self) -> hir::Node<'tcx> {
self.tcx.hir_node(self.hir_id())
}
diff --git a/compiler/rustc_hir_analysis/src/delegation.rs b/compiler/rustc_hir_analysis/src/delegation.rs
index e65420ea8bf44..ed45833b614fb 100644
--- a/compiler/rustc_hir_analysis/src/delegation.rs
+++ b/compiler/rustc_hir_analysis/src/delegation.rs
@@ -100,213 +100,156 @@ enum InheritanceKind {
Own,
}
-struct GenericsBuilder<'tcx> {
+fn build_generics<'tcx>(
tcx: TyCtxt<'tcx>,
sig_id: DefId,
parent: Option<DefId>,
inh_kind: InheritanceKind,
-}
-
-impl<'tcx> GenericsBuilder<'tcx> {
- fn new(tcx: TyCtxt<'tcx>, sig_id: DefId) -> GenericsBuilder<'tcx> {
- GenericsBuilder { tcx, sig_id, parent: None, inh_kind: InheritanceKind::WithParent(false) }
- }
-
- fn with_parent(mut self, parent: DefId) -> Self {
- self.parent = Some(parent);
- self
- }
-
- fn with_inheritance_kind(mut self, inh_kind: InheritanceKind) -> Self {
- self.inh_kind = inh_kind;
- self
- }
-
- fn build(self) -> ty::Generics {
- let mut own_params = vec![];
+) -> ty::Generics {
+ let mut own_params = vec![];
- let sig_generics = self.tcx.generics_of(self.sig_id);
- if let InheritanceKind::WithParent(has_self) = self.inh_kind
- && let Some(parent_def_id) = sig_generics.parent
- {
- let sig_parent_generics = self.tcx.generics_of(parent_def_id);
- own_params.append(&mut sig_parent_generics.own_params.clone());
- if !has_self {
- own_params.remove(0);
- }
+ let sig_generics = tcx.generics_of(sig_id);
+ if let InheritanceKind::WithParent(has_self) = inh_kind
+ && let Some(parent_def_id) = sig_generics.parent
+ {
+ let sig_parent_generics = tcx.generics_of(parent_def_id);
+ own_params.append(&mut sig_parent_generics.own_params.clone());
+ if !has_self {
+ own_params.remove(0);
}
- own_params.append(&mut sig_generics.own_params.clone());
+ }
+ own_params.append(&mut sig_generics.own_params.clone());
+
+ // Lifetime parameters must be declared before type and const parameters.
+ // Therefore, When delegating from a free function to a associated function,
+ // generic parameters need to be reordered:
+ //
+ // trait Trait<'a, A> {
+ // fn foo<'b, B>(...) {...}
+ // }
+ //
+ // reuse Trait::foo;
+ // desugaring:
+ // fn foo<'a, 'b, This: Trait<'a, A>, A, B>(...) {
+ // Trait::foo(...)
+ // }
+ own_params.sort_by_key(|key| key.kind.is_ty_or_const());
+
+ let param_def_id_to_index =
+ own_params.iter().map(|param| (param.def_id, param.index)).collect();
+
+ let (parent_count, has_self) = if let Some(def_id) = parent {
+ let parent_generics = tcx.generics_of(def_id);
+ let parent_kind = tcx.def_kind(def_id);
+ (parent_generics.count(), parent_kind == DefKind::Trait)
+ } else {
+ (0, false)
+ };
- // Lifetime parameters must be declared before type and const parameters.
- // Therefore, When delegating from a free function to a associated function,
- // generic parameters need to be reordered:
+ for (idx, param) in own_params.iter_mut().enumerate() {
+ param.index = (idx + parent_count) as u32;
+ // FIXME(fn_delegation): Default parameters are not inherited, because they are
+ // not permitted in functions. Therefore, there are 2 options here:
//
- // trait Trait<'a, A> {
- // fn foo<'b, B>(...) {...}
- // }
+ // - We can create non-default generic parameters.
+ // - We can substitute default parameters into the signature.
//
- // reuse Trait::foo;
- // desugaring:
- // fn foo<'a, 'b, This: Trait<'a, A>, A, B>(...) {
- // Trait::foo(...)
- // }
- own_params.sort_by_key(|key| key.kind.is_ty_or_const());
-
- let param_def_id_to_index =
- own_params.iter().map(|param| (param.def_id, param.index)).collect();
-
- let (parent_count, has_self) = if let Some(def_id) = self.parent {
- let parent_generics = self.tcx.generics_of(def_id);
- let parent_kind = self.tcx.def_kind(def_id);
- (parent_generics.count(), parent_kind == DefKind::Trait)
- } else {
- (0, false)
- };
-
- for (idx, param) in own_params.iter_mut().enumerate() {
- param.index = (idx + parent_count) as u32;
- // FIXME(fn_delegation): Default parameters are not inherited, because they are
- // not permitted in functions. Therefore, there are 2 options here:
- //
- // - We can create non-default generic parameters.
- // - We can substitute default parameters into the signature.
- //
- // At the moment, first option has been selected as the most general.
- if let ty::GenericParamDefKind::Type { has_default, .. }
- | ty::GenericParamDefKind::Const { has_default, .. } = &mut param.kind
- {
- *has_default = false;
- }
+ // At the moment, first option has been selected as the most general.
+ if let ty::GenericParamDefKind::Type { has_default, .. }
+ | ty::GenericParamDefKind::Const { has_default, .. } = &mut param.kind
+ {
+ *has_default = false;
}
+ }
- ty::Generics {
- parent: self.parent,
- parent_count,
- own_params,
- param_def_id_to_index,
- has_self,
- has_late_bound_regions: sig_generics.has_late_bound_regions,
- }
+ ty::Generics {
+ parent,
+ parent_count,
+ own_params,
+ param_def_id_to_index,
+ has_self,
+ has_late_bound_regions: sig_generics.has_late_bound_regions,
}
}
-struct PredicatesBuilder<'tcx> {
+fn build_predicates<'tcx>(
tcx: TyCtxt<'tcx>,
sig_id: DefId,
parent: Option<DefId>,
inh_kind: InheritanceKind,
args: ty::GenericArgsRef<'tcx>,
-}
-
-impl<'tcx> PredicatesBuilder<'tcx> {
- fn new(
+) -> ty::GenericPredicates<'tcx> {
+ struct PredicatesCollector<'tcx> {
tcx: TyCtxt<'tcx>,
+ preds: Vec<(ty::Clause<'tcx>, Span)>,
args: ty::GenericArgsRef<'tcx>,
- sig_id: DefId,
- ) -> PredicatesBuilder<'tcx> {
- PredicatesBuilder {
- tcx,
- sig_id,
- parent: None,
- inh_kind: InheritanceKind::WithParent(false),
- args,
- }
- }
-
- fn with_parent(mut self, parent: DefId) -> Self {
- self.parent = Some(parent);
- self
}
- fn with_inheritance_kind(mut self, inh_kind: InheritanceKind) -> Self {
- self.inh_kind = inh_kind;
- self
- }
-
- fn build(self) -> ty::GenericPredicates<'tcx> {
- struct PredicatesCollector<'tcx> {
- tcx: TyCtxt<'tcx>,
- preds: Vec<(ty::Clause<'tcx>, Span)>,
- args: ty::GenericArgsRef<'tcx>,
+ impl<'tcx> PredicatesCollector<'tcx> {
+ fn new(tcx: TyCtxt<'tcx>, args: ty::GenericArgsRef<'tcx>) -> PredicatesCollector<'tcx> {
+ PredicatesCollector { tcx, preds: vec![], args }
}
- impl<'tcx> PredicatesCollector<'tcx> {
- fn new(tcx: TyCtxt<'tcx>, args: ty::GenericArgsRef<'tcx>) -> PredicatesCollector<'tcx> {
- PredicatesCollector { tcx, preds: vec![], args }
- }
-
- fn with_own_preds(
- mut self,
- f: impl Fn(DefId) -> ty::GenericPredicates<'tcx>,
- def_id: DefId,
- ) -> Self {
- let preds = f(def_id).instantiate_own(self.tcx, self.args);
- self.preds.extend(preds);
- self
- }
+ fn with_own_preds(
+ mut self,
+ f: impl Fn(DefId) -> ty::GenericPredicates<'tcx>,
+ def_id: DefId,
+ ) -> Self {
+ let preds = f(def_id).instantiate_own(self.tcx, self.args);
+ self.preds.extend(preds);
+ self
+ }
- fn with_preds(
- mut self,
- f: impl Fn(DefId) -> ty::GenericPredicates<'tcx> + Copy,
- def_id: DefId,
- ) -> Self {
- let preds = f(def_id);
- if let Some(parent_def_id) = preds.parent {
- self = self.with_own_preds(f, parent_def_id);
- }
- self.with_own_preds(f, def_id)
+ fn with_preds(
+ mut self,
+ f: impl Fn(DefId) -> ty::GenericPredicates<'tcx> + Copy,
+ def_id: DefId,
+ ) -> Self {
+ let preds = f(def_id);
+ if let Some(parent_def_id) = preds.parent {
+ self = self.with_own_preds(f, parent_def_id);
}
+ self.with_own_preds(f, def_id)
}
- let collector = PredicatesCollector::new(self.tcx, self.args);
-
- // `explicit_predicates_of` is used here to avoid copying `Self: Trait` predicate.
- // Note: `predicates_of` query can also add inferred outlives predicates, but that
- // is not the case here as `sig_id` is either a trait or a function.
- let preds = match self.inh_kind {
- InheritanceKind::WithParent(false) => {
- collector.with_preds(|def_id| self.tcx.explicit_predicates_of(def_id), self.sig_id)
- }
- InheritanceKind::WithParent(true) => {
- collector.with_preds(|def_id| self.tcx.predicates_of(def_id), self.sig_id)
- }
- InheritanceKind::Own => {
- collector.with_own_preds(|def_id| self.tcx.predicates_of(def_id), self.sig_id)
- }
+ }
+ let collector = PredicatesCollector::new(tcx, args);
+
+ // `explicit_predicates_of` is used here to avoid copying `Self: Trait` predicate.
+ // Note: `predicates_of` query can also add inferred outlives predicates, but that
+ // is not the case here as `sig_id` is either a trait or a function.
+ let preds = match inh_kind {
+ InheritanceKind::WithParent(false) => {
+ collector.with_preds(|def_id| tcx.explicit_predicates_of(def_id), sig_id)
}
- .preds;
-
- ty::GenericPredicates {
- parent: self.parent,
- predicates: self.tcx.arena.alloc_from_iter(preds),
+ InheritanceKind::WithParent(true) => {
+ collector.with_preds(|def_id| tcx.predicates_of(def_id), sig_id)
+ }
+ InheritanceKind::Own => {
+ collector.with_own_preds(|def_id| tcx.predicates_of(def_id), sig_id)
}
}
+ .preds;
+
+ ty::GenericPredicates { parent, predicates: tcx.arena.alloc_from_iter(preds) }
}
-struct GenericArgsBuilder<'tcx> {
+fn build_generic_args<'tcx>(
tcx: TyCtxt<'tcx>,
- remap_table: RemapTable,
sig_id: DefId,
def_id: LocalDefId,
-}
+ args: ty::GenericArgsRef<'tcx>,
+) -> ty::GenericArgsRef<'tcx> {
+ let caller_generics = tcx.generics_of(def_id);
+ let callee_generics = tcx.generics_of(sig_id);
-impl<'tcx> GenericArgsBuilder<'tcx> {
- fn new(tcx: TyCtxt<'tcx>, sig_id: DefId, def_id: LocalDefId) -> GenericArgsBuilder<'tcx> {
- GenericArgsBuilder { tcx, remap_table: FxHashMap::default(), sig_id, def_id }
+ let mut remap_table = FxHashMap::default();
+ for caller_param in &caller_generics.own_params {
+ let callee_index = callee_generics.param_def_id_to_index(tcx, caller_param.def_id).unwrap();
+ remap_table.insert(callee_index, caller_param.index);
}
- fn build_from_args(mut self, args: ty::GenericArgsRef<'tcx>) -> ty::GenericArgsRef<'tcx> {
- let caller_generics = self.tcx.generics_of(self.def_id);
- let callee_generics = self.tcx.generics_of(self.sig_id);
-
- for caller_param in &caller_generics.own_params {
- let callee_index =
- callee_generics.param_def_id_to_index(self.tcx, caller_param.def_id).unwrap();
- self.remap_table.insert(callee_index, caller_param.index);
- }
-
- let mut folder = ParamIndexRemapper { tcx: self.tcx, remap_table: self.remap_table };
- args.fold_with(&mut folder)
- }
+ let mut folder = ParamIndexRemapper { tcx, remap_table };
+ args.fold_with(&mut folder)
}
fn create_generic_args<'tcx>(
@@ -314,8 +257,6 @@ fn create_generic_args<'tcx>(
def_id: LocalDefId,
sig_id: DefId,
) -> ty::GenericArgsRef<'tcx> {
- let builder = GenericArgsBuilder::new(tcx, sig_id, def_id);
-
let caller_kind = fn_kind(tcx, def_id.into());
let callee_kind = fn_kind(tcx, sig_id);
match (caller_kind, callee_kind) {
@@ -325,7 +266,7 @@ fn create_generic_args<'tcx>(
| (FnKind::AssocTrait, FnKind::Free)
| (FnKind::AssocTrait, FnKind::AssocTrait) => {
let args = ty::GenericArgs::identity_for_item(tcx, sig_id);
- builder.build_from_args(args)
+ build_generic_args(tcx, sig_id, def_id, args)
}
(FnKind::AssocTraitImpl, FnKind::AssocTrait) => {
@@ -335,8 +276,9 @@ fn create_generic_args<'tcx>(
tcx.impl_trait_header(parent).unwrap().trait_ref.instantiate_identity().args;
let trait_args = ty::GenericArgs::identity_for_item(tcx, sig_id);
- let method_args = tcx.mk_args_from_iter(trait_args.iter().skip(callee_generics.parent_count));
- let method_args = builder.build_from_args(method_args);
+ let method_args =
+ tcx.mk_args_from_iter(trait_args.iter().skip(callee_generics.parent_count));
+ let method_args = build_generic_args(tcx, sig_id, def_id, method_args);
tcx.mk_args_from_iter(parent_args.iter().chain(method_args))
}
@@ -347,16 +289,16 @@ fn create_generic_args<'tcx>(
let generic_self_ty = ty::GenericArg::from(self_ty);
let trait_args = ty::GenericArgs::identity_for_item(tcx, sig_id);
- let trait_args = builder.build_from_args(trait_args);
+ let trait_args = build_generic_args(tcx, sig_id, def_id, trait_args);
let args = std::iter::once(generic_self_ty).chain(trait_args.iter().skip(1));
tcx.mk_args_from_iter(args)
}
// For trait impl's `sig_id` is always equal to the corresponding trait method.
+ // For inherent methods delegation is not yet supported.
(FnKind::AssocTraitImpl, _)
| (_, FnKind::AssocTraitImpl)
- // Delegation to inherent methods is not yet supported.
| (_, FnKind::AssocInherentImpl) => unreachable!(),
}
}
@@ -377,39 +319,31 @@ pub(crate) fn inherit_generics_for_delegation_item<'tcx>(
def_id: LocalDefId,
sig_id: DefId,
) -> ty::Generics {
- let builder = GenericsBuilder::new(tcx, sig_id);
-
let caller_kind = fn_kind(tcx, def_id.into());
let callee_kind = fn_kind(tcx, sig_id);
match (caller_kind, callee_kind) {
- (FnKind::Free, FnKind::Free)
- | (FnKind::Free, FnKind::AssocTrait) => builder.with_inheritance_kind(InheritanceKind::WithParent(true)).build(),
+ (FnKind::Free, FnKind::Free) | (FnKind::Free, FnKind::AssocTrait) => {
+ build_generics(tcx, sig_id, None, InheritanceKind::WithParent(true))
+ }
(FnKind::AssocTraitImpl, FnKind::AssocTrait) => {
- builder
- .with_parent(tcx.parent(def_id.into()))
- .with_inheritance_kind(InheritanceKind::Own)
- .build()
+ build_generics(tcx, sig_id, Some(tcx.parent(def_id.into())), InheritanceKind::Own)
}
(FnKind::AssocInherentImpl, FnKind::AssocTrait)
- | (FnKind::AssocTrait, FnKind::AssocTrait) => {
- builder
- .with_parent(tcx.parent(def_id.into()))
- .build()
- }
-
- (FnKind::AssocInherentImpl, FnKind::Free)
- | (FnKind::AssocTrait, FnKind::Free) => {
- builder
- .with_parent(tcx.parent(def_id.into()))
- .build()
- }
+ | (FnKind::AssocTrait, FnKind::AssocTrait)
+ | (FnKind::AssocInherentImpl, FnKind::Free)
+ | (FnKind::AssocTrait, FnKind::Free) => build_generics(
+ tcx,
+ sig_id,
+ Some(tcx.parent(def_id.into())),
+ InheritanceKind::WithParent(false),
+ ),
// For trait impl's `sig_id` is always equal to the corresponding trait method.
+ // For inherent methods delegation is not yet supported.
(FnKind::AssocTraitImpl, _)
| (_, FnKind::AssocTraitImpl)
- // Delegation to inherent methods is not yet supported.
| (_, FnKind::AssocInherentImpl) => unreachable!(),
}
}
@@ -420,36 +354,36 @@ pub(crate) fn inherit_predicates_for_delegation_item<'tcx>(
sig_id: DefId,
) -> ty::GenericPredicates<'tcx> {
let args = create_generic_args(tcx, def_id, sig_id);
- let builder = PredicatesBuilder::new(tcx, args, sig_id);
-
let caller_kind = fn_kind(tcx, def_id.into());
let callee_kind = fn_kind(tcx, sig_id);
match (caller_kind, callee_kind) {
- (FnKind::Free, FnKind::Free)
- | (FnKind::Free, FnKind::AssocTrait) => {
- builder.with_inheritance_kind(InheritanceKind::WithParent(true)).build()
+ (FnKind::Free, FnKind::Free) | (FnKind::Free, FnKind::AssocTrait) => {
+ build_predicates(tcx, sig_id, None, InheritanceKind::WithParent(true), args)
}
- (FnKind::AssocTraitImpl, FnKind::AssocTrait) => {
- builder
- .with_parent(tcx.parent(def_id.into()))
- .with_inheritance_kind(InheritanceKind::Own)
- .build()
- }
+ (FnKind::AssocTraitImpl, FnKind::AssocTrait) => build_predicates(
+ tcx,
+ sig_id,
+ Some(tcx.parent(def_id.into())),
+ InheritanceKind::Own,
+ args,
+ ),
(FnKind::AssocInherentImpl, FnKind::AssocTrait)
| (FnKind::AssocTrait, FnKind::AssocTrait)
| (FnKind::AssocInherentImpl, FnKind::Free)
- | (FnKind::AssocTrait, FnKind::Free) => {
- builder
- .with_parent(tcx.parent(def_id.into()))
- .build()
- }
+ | (FnKind::AssocTrait, FnKind::Free) => build_predicates(
+ tcx,
+ sig_id,
+ Some(tcx.parent(def_id.into())),
+ InheritanceKind::WithParent(false),
+ args,
+ ),
// For trait impl's `sig_id` is always equal to the corresponding trait method.
+ // For inherent methods delegation is not yet supported.
(FnKind::AssocTraitImpl, _)
| (_, FnKind::AssocTraitImpl)
- // Delegation to inherent methods is not yet supported.
| (_, FnKind::AssocInherentImpl) => unreachable!(),
}
}
diff --git a/compiler/rustc_hir_analysis/src/hir_ty_lowering/generics.rs b/compiler/rustc_hir_analysis/src/hir_ty_lowering/generics.rs
index fe3dcb35639fe..4313739787011 100644
--- a/compiler/rustc_hir_analysis/src/hir_ty_lowering/generics.rs
+++ b/compiler/rustc_hir_analysis/src/hir_ty_lowering/generics.rs
@@ -273,7 +273,7 @@ pub fn lower_generic_args<'tcx: 'a, 'a>(
// We lower to an infer even when the feature gate is not enabled
// as it is useful for diagnostics to be able to see a `ConstKind::Infer`
- args.push(ctx.provided_kind(&args, param, arg));
+ args.push(ctx.provided_kind(param, arg));
args_iter.next();
params.next();
}
diff --git a/compiler/rustc_hir_analysis/src/hir_ty_lowering/mod.rs b/compiler/rustc_hir_analysis/src/hir_ty_lowering/mod.rs
index 61d5869c19f15..b4cab3330afaf 100644
--- a/compiler/rustc_hir_analysis/src/hir_ty_lowering/mod.rs
+++ b/compiler/rustc_hir_analysis/src/hir_ty_lowering/mod.rs
@@ -296,7 +296,6 @@ pub trait GenericArgsLowerer<'a, 'tcx> {
fn provided_kind(
&mut self,
- preceding_args: &[ty::GenericArg<'tcx>],
param: &ty::GenericParamDef,
arg: &GenericArg<'tcx>,
) -> ty::GenericArg<'tcx>;
@@ -480,7 +479,6 @@ impl<'tcx> dyn HirTyLowerer<'tcx> + '_ {
fn provided_kind(
&mut self,
- _preceding_args: &[ty::GenericArg<'tcx>],
param: &ty::GenericParamDef,
arg: &GenericArg<'tcx>,
) -> ty::GenericArg<'tcx> {
diff --git a/compiler/rustc_hir_analysis/src/impl_wf_check/min_specialization.rs b/compiler/rustc_hir_analysis/src/impl_wf_check/min_specialization.rs
index 32694d5f4bc18..af1107b499f4e 100644
--- a/compiler/rustc_hir_analysis/src/impl_wf_check/min_specialization.rs
+++ b/compiler/rustc_hir_analysis/src/impl_wf_check/min_specialization.rs
@@ -34,7 +34,7 @@
//! impl<T, I: Iterator<Item=T>> SpecExtend<T> for I { /* default impl */ }
//! ```
//!
-//! We get that the generic pamameters for `impl2` are `[T, std::vec::IntoIter<T>]`.
+//! We get that the generic parameters for `impl2` are `[T, std::vec::IntoIter<T>]`.
//! `T` is constrained to be `<I as Iterator>::Item`, so we check only
//! `std::vec::IntoIter<T>` for repeated parameters, which it doesn't have. The
//! predicates of `impl1` are only `T: Sized`, which is also a predicate of
@@ -119,7 +119,6 @@ fn check_always_applicable(
impl2_node: Node,
) -> Result<(), ErrorGuaranteed> {
let span = tcx.def_span(impl1_def_id);
- let mut res = check_has_items(tcx, impl1_def_id, impl2_node, span);
let (impl1_args, impl2_args) = get_impl_args(tcx, impl1_def_id, impl2_node)?;
let impl2_def_id = impl2_node.def_id();
@@ -131,11 +130,10 @@ fn check_always_applicable(
unconstrained_parent_impl_args(tcx, impl2_def_id, impl2_args)
};
- res = res.and(check_static_lifetimes(tcx, &parent_args, span));
- res = res.and(check_duplicate_params(tcx, impl1_args, parent_args, span));
- res = res.and(check_predicates(tcx, impl1_def_id, impl1_args, impl2_node, impl2_args, span));
-
- res
+ check_has_items(tcx, impl1_def_id, impl2_node, span)
+ .and(check_static_lifetimes(tcx, &parent_args, span))
+ .and(check_duplicate_params(tcx, impl1_args, parent_args, span))
+ .and(check_predicates(tcx, impl1_def_id, impl1_args, impl2_node, impl2_args, span))
}
fn check_has_items(
diff --git a/compiler/rustc_hir_analysis/src/lib.rs b/compiler/rustc_hir_analysis/src/lib.rs
index bc7d4365eeef4..f77bba89d8cfe 100644
--- a/compiler/rustc_hir_analysis/src/lib.rs
+++ b/compiler/rustc_hir_analysis/src/lib.rs
@@ -83,12 +83,11 @@ pub mod autoderef;
mod bounds;
mod check_unused;
mod coherence;
-mod delegation;
-pub mod hir_ty_lowering;
-// FIXME: This module shouldn't be public.
-pub mod collect;
+mod collect;
mod constrained_generic_params;
+mod delegation;
mod errors;
+pub mod hir_ty_lowering;
pub mod hir_wf_check;
mod impl_wf_check;
mod outlives;
@@ -104,7 +103,8 @@ use rustc_middle::ty::{self, Const, Ty, TyCtxt};
use rustc_span::Span;
use rustc_trait_selection::traits;
-use self::hir_ty_lowering::{FeedConstTy, HirTyLowerer};
+pub use crate::collect::suggest_impl_trait;
+use crate::hir_ty_lowering::{FeedConstTy, HirTyLowerer};
rustc_fluent_macro::fluent_messages! { "../messages.ftl" }
diff --git a/compiler/rustc_hir_analysis/src/outlives/implicit_infer.rs b/compiler/rustc_hir_analysis/src/outlives/implicit_infer.rs
index c2377b4781c28..036163b9f1409 100644
--- a/compiler/rustc_hir_analysis/src/outlives/implicit_infer.rs
+++ b/compiler/rustc_hir_analysis/src/outlives/implicit_infer.rs
@@ -24,7 +24,7 @@ pub(super) fn infer_predicates(
// If new predicates were added then we need to re-calculate
// all crates since there could be new implied predicates.
- 'outer: loop {
+ loop {
let mut predicates_added = false;
// Visit all the crates and infer predicates
@@ -90,7 +90,7 @@ pub(super) fn infer_predicates(
}
if !predicates_added {
- break 'outer;
+ break;
}
}
diff --git a/compiler/rustc_hir_analysis/src/variance/mod.rs b/compiler/rustc_hir_analysis/src/variance/mod.rs
index 02cfb57b836f6..a7760326bb4c3 100644
--- a/compiler/rustc_hir_analysis/src/variance/mod.rs
+++ b/compiler/rustc_hir_analysis/src/variance/mod.rs
@@ -27,9 +27,6 @@ mod solve;
pub(crate) mod dump;
-/// Code for transforming variances.
-mod xform;
-
pub(crate) fn provide(providers: &mut Providers) {
*providers = Providers { variances_of, crate_variances, ..*providers };
}
diff --git a/compiler/rustc_hir_analysis/src/variance/solve.rs b/compiler/rustc_hir_analysis/src/variance/solve.rs
index d0bdca8677922..4106c1a5b6355 100644
--- a/compiler/rustc_hir_analysis/src/variance/solve.rs
+++ b/compiler/rustc_hir_analysis/src/variance/solve.rs
@@ -12,8 +12,26 @@ use tracing::debug;
use super::constraints::*;
use super::terms::VarianceTerm::*;
use super::terms::*;
-use super::xform::*;
+fn glb(v1: ty::Variance, v2: ty::Variance) -> ty::Variance {
+ // Greatest lower bound of the variance lattice as defined in The Paper:
+ //
+ // *
+ // - +
+ // o
+ match (v1, v2) {
+ (ty::Invariant, _) | (_, ty::Invariant) => ty::Invariant,
+
+ (ty::Covariant, ty::Contravariant) => ty::Invariant,
+ (ty::Contravariant, ty::Covariant) => ty::Invariant,
+
+ (ty::Covariant, ty::Covariant) => ty::Covariant,
+
+ (ty::Contravariant, ty::Contravariant) => ty::Contravariant,
+
+ (x, ty::Bivariant) | (ty::Bivariant, x) => x,
+ }
+}
struct SolveContext<'a, 'tcx> {
terms_cx: TermsContext<'a, 'tcx>,
constraints: Vec<Constraint<'a>>,
diff --git a/compiler/rustc_hir_analysis/src/variance/xform.rs b/compiler/rustc_hir_analysis/src/variance/xform.rs
deleted file mode 100644
index 2e9964788e6e5..0000000000000
--- a/compiler/rustc_hir_analysis/src/variance/xform.rs
+++ /dev/null
@@ -1,22 +0,0 @@
-use rustc_middle::ty;
-
-pub(crate) fn glb(v1: ty::Variance, v2: ty::Variance) -> ty::Variance {
- // Greatest lower bound of the variance lattice as
- // defined in The Paper:
- //
- // *
- // - +
- // o
- match (v1, v2) {
- (ty::Invariant, _) | (_, ty::Invariant) => ty::Invariant,
-
- (ty::Covariant, ty::Contravariant) => ty::Invariant,
- (ty::Contravariant, ty::Covariant) => ty::Invariant,
-
- (ty::Covariant, ty::Covariant) => ty::Covariant,
-
- (ty::Contravariant, ty::Contravariant) => ty::Contravariant,
-
- (x, ty::Bivariant) | (ty::Bivariant, x) => x,
- }
-}
diff --git a/compiler/rustc_hir_typeck/src/fn_ctxt/_impl.rs b/compiler/rustc_hir_typeck/src/fn_ctxt/_impl.rs
index 8e647ad3c6a4d..e84ae65f90322 100644
--- a/compiler/rustc_hir_typeck/src/fn_ctxt/_impl.rs
+++ b/compiler/rustc_hir_typeck/src/fn_ctxt/_impl.rs
@@ -1261,7 +1261,6 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
fn provided_kind(
&mut self,
- _preceding_args: &[ty::GenericArg<'tcx>],
param: &ty::GenericParamDef,
arg: &GenericArg<'tcx>,
) -> ty::GenericArg<'tcx> {
diff --git a/compiler/rustc_hir_typeck/src/fn_ctxt/mod.rs b/compiler/rustc_hir_typeck/src/fn_ctxt/mod.rs
index d432199f03735..b77e6de52ff1c 100644
--- a/compiler/rustc_hir_typeck/src/fn_ctxt/mod.rs
+++ b/compiler/rustc_hir_typeck/src/fn_ctxt/mod.rs
@@ -31,12 +31,12 @@ use crate::{CoroutineTypes, Diverges, EnclosingBreakables, TypeckRootCtxt};
/// functions, closures, and `const`s, including performing type inference
/// with [`InferCtxt`].
///
-/// This is in contrast to [`ItemCtxt`], which is used to type-check item *signatures*
-/// and thus does not perform type inference.
+/// This is in contrast to `rustc_hir_analysis::collect::ItemCtxt`, which is
+/// used to type-check item *signatures* and thus does not perform type
+/// inference.
///
-/// See [`ItemCtxt`]'s docs for more.
+/// See `ItemCtxt`'s docs for more.
///
-/// [`ItemCtxt`]: rustc_hir_analysis::collect::ItemCtxt
/// [`InferCtxt`]: infer::InferCtxt
pub(crate) struct FnCtxt<'a, 'tcx> {
pub(super) body_id: LocalDefId,
diff --git a/compiler/rustc_hir_typeck/src/fn_ctxt/suggestions.rs b/compiler/rustc_hir_typeck/src/fn_ctxt/suggestions.rs
index aea2e0fd3a300..60f9265bfcc0d 100644
--- a/compiler/rustc_hir_typeck/src/fn_ctxt/suggestions.rs
+++ b/compiler/rustc_hir_typeck/src/fn_ctxt/suggestions.rs
@@ -12,8 +12,8 @@ use rustc_hir::{
GenericBound, HirId, Node, PatExpr, PatExprKind, Path, QPath, Stmt, StmtKind, TyKind,
WherePredicateKind, expr_needs_parens,
};
-use rustc_hir_analysis::collect::suggest_impl_trait;
use rustc_hir_analysis::hir_ty_lowering::HirTyLowerer;
+use rustc_hir_analysis::suggest_impl_trait;
use rustc_middle::lint::in_external_macro;
use rustc_middle::middle::stability::EvalResult;
use rustc_middle::span_bug;
diff --git a/compiler/rustc_hir_typeck/src/method/confirm.rs b/compiler/rustc_hir_typeck/src/method/confirm.rs
index 880ee83c80a06..5c1c38aeb9534 100644
--- a/compiler/rustc_hir_typeck/src/method/confirm.rs
+++ b/compiler/rustc_hir_typeck/src/method/confirm.rs
@@ -413,7 +413,6 @@ impl<'a, 'tcx> ConfirmContext<'a, 'tcx> {
fn provided_kind(
&mut self,
- _preceding_args: &[ty::GenericArg<'tcx>],
param: &ty::GenericParamDef,
arg: &GenericArg<'tcx>,
) -> ty::GenericArg<'tcx> {