Rollup merge of #132168 - fee1-dead-contrib:fxclean, r=compiler-errors

Effects cleanup
- removed extra bits from predicates queries that are no longer needed in the new system
- removed the need for `non_erasable_generics` to take in tcx and DefId, removed unused arguments in callers
r? compiler-errors

Author: matthiaskrgr

compiler/rustc_codegen_cranelift/src/debuginfo/mod.rs

@@ -210,7 +210,6 @@ impl DebugContext {
  type_names::push_generic_params(
  tcx,
  tcx.normalize_erasing_regions(ty::ParamEnv::reveal_all(), args),
- enclosing_fn_def_id,
 &mut name,
 );
 

compiler/rustc_codegen_gcc/src/callee.rs

@@ -98,8 +98,7 @@ pub fn get_fn<'gcc, 'tcx>(cx: &CodegenCx<'gcc, 'tcx>, instance: Instance<'tcx>)
 // whether we are sharing generics or not. The important thing here is
 // that the visibility we apply to the declaration is the same one that
 // has been applied to the definition (wherever that definition may be).
-let is_generic =
- instance.args.non_erasable_generics(tcx, instance.def_id()).next().is_some();
+let is_generic = instance.args.non_erasable_generics().next().is_some();
 
 if is_generic {
 // This is a monomorphization. Its expected visibility depends

compiler/rustc_codegen_llvm/src/callee.rs

@@ -98,8 +98,7 @@ pub(crate) fn get_fn<'ll, 'tcx>(cx: &CodegenCx<'ll, 'tcx>, instance: Instance<'t
 unsafe{
  llvm::LLVMRustSetLinkage(llfn, llvm::Linkage::ExternalLinkage);
 
-let is_generic =
- instance.args.non_erasable_generics(tcx, instance.def_id()).next().is_some();
+let is_generic = instance.args.non_erasable_generics().next().is_some();
 
 let is_hidden = if is_generic {
 // This is a monomorphization of a generic function.

compiler/rustc_codegen_llvm/src/debuginfo/mod.rs

@@ -350,7 +350,6 @@ impl<'ll, 'tcx> DebugInfoCodegenMethods<'tcx> for CodegenCx<'ll, 'tcx> {
  type_names::push_generic_params(
  tcx,
  tcx.normalize_erasing_regions(ty::ParamEnv::reveal_all(), args),
- enclosing_fn_def_id,
 &mut name,
 );
 

compiler/rustc_codegen_ssa/src/back/symbol_export.rs

@@ -312,7 +312,7 @@ fn exported_symbols_provider_local(
 
 match*mono_item {
 MonoItem::Fn(Instance{def:InstanceKind::Item(def), args }) => {
-if args.non_erasable_generics(tcx, def).next().is_some(){
+if args.non_erasable_generics().next().is_some(){
 let symbol = ExportedSymbol::Generic(def, args);
  symbols.push((symbol,SymbolExportInfo{
 level:SymbolExportLevel::Rust,
@@ -321,27 +321,21 @@ fn exported_symbols_provider_local(
 }));
 }
 }
-MonoItem::Fn(Instance{def:InstanceKind::DropGlue(def_id,Some(ty)), args }) => {
+MonoItem::Fn(Instance{def:InstanceKind::DropGlue(_,Some(ty)), args }) => {
 // A little sanity-check
-assert_eq!(
- args.non_erasable_generics(tcx, def_id).next(),
-Some(GenericArgKind::Type(ty))
-);
+assert_eq!(args.non_erasable_generics().next(),Some(GenericArgKind::Type(ty)));
  symbols.push((ExportedSymbol::DropGlue(ty),SymbolExportInfo{
 level:SymbolExportLevel::Rust,
 kind:SymbolExportKind::Text,
 used:false,
 }));
 }
 MonoItem::Fn(Instance{
-def:InstanceKind::AsyncDropGlueCtorShim(def_id,Some(ty)),
+def:InstanceKind::AsyncDropGlueCtorShim(_,Some(ty)),
  args,
 }) => {
 // A little sanity-check
-assert_eq!(
- args.non_erasable_generics(tcx, def_id).next(),
-Some(GenericArgKind::Type(ty))
-);
+assert_eq!(args.non_erasable_generics().next(),Some(GenericArgKind::Type(ty)));
  symbols.push((ExportedSymbol::AsyncDropGlueCtorShim(ty),SymbolExportInfo{
 level:SymbolExportLevel::Rust,
 kind:SymbolExportKind::Text,

compiler/rustc_codegen_ssa/src/debuginfo/type_names.rs

@@ -110,14 +110,14 @@ fn push_debuginfo_type_name<'tcx>(
  ty_and_layout,
 &|output, visited| {
 push_item_name(tcx, def.did(),true, output);
-push_generic_params_internal(tcx, args,def.did(),output, visited);
+push_generic_params_internal(tcx, args, output, visited);
 },
  output,
  visited,
 );
 }else{
 push_item_name(tcx, def.did(), qualified, output);
-push_generic_params_internal(tcx, args,def.did(),output, visited);
+push_generic_params_internal(tcx, args, output, visited);
 }
 }
  ty::Tuple(component_types) => {
@@ -251,13 +251,8 @@ fn push_debuginfo_type_name<'tcx>(
 let principal =
  tcx.normalize_erasing_late_bound_regions(ty::ParamEnv::reveal_all(), principal);
 push_item_name(tcx, principal.def_id, qualified, output);
-let principal_has_generic_params = push_generic_params_internal(
- tcx,
- principal.args,
- principal.def_id,
- output,
- visited,
-);
+let principal_has_generic_params =
+push_generic_params_internal(tcx, principal.args, output, visited);
 
 let projection_bounds:SmallVec<[_;4]> = trait_data
 .projection_bounds()
@@ -538,13 +533,7 @@ pub fn compute_debuginfo_vtable_name<'tcx>(
  tcx.normalize_erasing_late_bound_regions(ty::ParamEnv::reveal_all(), trait_ref);
 push_item_name(tcx, trait_ref.def_id,true,&mut vtable_name);
  visited.clear();
-push_generic_params_internal(
- tcx,
- trait_ref.args,
- trait_ref.def_id,
-&mut vtable_name,
-&mut visited,
-);
+push_generic_params_internal(tcx, trait_ref.args,&mut vtable_name,&mut visited);
 }else{
  vtable_name.push('_');
 }
@@ -647,12 +636,11 @@ fn push_unqualified_item_name(
 fnpush_generic_params_internal<'tcx>(
 tcx:TyCtxt<'tcx>,
 args:GenericArgsRef<'tcx>,
-def_id:DefId,
 output:&mutString,
 visited:&mutFxHashSet<Ty<'tcx>>,
 ) -> bool{
 assert_eq!(args, tcx.normalize_erasing_regions(ty::ParamEnv::reveal_all(), args));
-letmut args = args.non_erasable_generics(tcx, def_id).peekable();
+letmut args = args.non_erasable_generics().peekable();
 if args.peek().is_none(){
 returnfalse;
 }
@@ -736,12 +724,11 @@ fn push_const_param<'tcx>(tcx: TyCtxt<'tcx>, ct: ty::Const<'tcx>, output: &mut S
 pubfnpush_generic_params<'tcx>(
 tcx:TyCtxt<'tcx>,
 args:GenericArgsRef<'tcx>,
-def_id:DefId,
 output:&mutString,
 ){
 let _prof = tcx.prof.generic_activity("compute_debuginfo_type_name");
 letmut visited = FxHashSet::default();
-push_generic_params_internal(tcx, args,def_id,output,&mut visited);
+push_generic_params_internal(tcx, args, output,&mut visited);
 }
 
 fnpush_closure_or_coroutine_name<'tcx>(
@@ -786,7 +773,7 @@ fn push_closure_or_coroutine_name<'tcx>(
 // FIXME(async_closures): This is probably not going to be correct w.r.t.
 // multiple coroutine flavors. Maybe truncate to (parent + 1)?
 let args = args.truncate_to(tcx, generics);
-push_generic_params_internal(tcx, args,enclosing_fn_def_id,output, visited);
+push_generic_params_internal(tcx, args, output, visited);
 }
 
 fnpush_close_angle_bracket(cpp_like_debuginfo:bool,output:&mutString){

compiler/rustc_hir_analysis/src/bounds.rs

@@ -1,7 +1,6 @@
 //! Bounds are restrictions applied to some types after they've been lowered from the HIR to the
 //! [`rustc_middle::ty`] form.
 
-use rustc_data_structures::fx::FxIndexMap;
 use rustc_hir::LangItem;
 use rustc_middle::ty::{self,Ty,TyCtxt,Upcast};
 use rustc_span::Span;
@@ -25,7 +24,6 @@ use rustc_span::Span;
 #[derive(Default,PartialEq,Eq,Clone,Debug)]
 pub(crate)structBounds<'tcx>{
 clauses:Vec<(ty::Clause<'tcx>,Span)>,
-effects_min_tys:FxIndexMap<Ty<'tcx>,Span>,
 }
 
 impl<'tcx>Bounds<'tcx>{
@@ -96,15 +94,7 @@ impl<'tcx> Bounds<'tcx> {
 }
 }
 
-pub(crate)fnclauses(
-&self,
-// FIXME(effects): remove tcx
-_tcx:TyCtxt<'tcx>,
-) -> implIterator<Item = (ty::Clause<'tcx>,Span)> + '_{
+pub(crate)fnclauses(&self) -> implIterator<Item = (ty::Clause<'tcx>,Span)> + '_{
 self.clauses.iter().cloned()
 }
-
-pub(crate)fneffects_min_tys(&self) -> implIterator<Item = Ty<'tcx>> + '_{
-self.effects_min_tys.keys().copied()
-}
 }

compiler/rustc_hir_analysis/src/collect/item_bounds.rs

@@ -67,7 +67,7 @@ fn associated_type_bounds<'tcx>(
 )
 });
 
-let all_bounds = tcx.arena.alloc_from_iter(bounds.clauses(tcx).chain(bounds_from_parent));
+let all_bounds = tcx.arena.alloc_from_iter(bounds.clauses().chain(bounds_from_parent));
 debug!(
 "associated_type_bounds({}) = {:?}",
  tcx.def_path_str(assoc_item_def_id.to_def_id()),
@@ -339,7 +339,7 @@ fn opaque_type_bounds<'tcx>(
 }
  debug!(?bounds);
 
- tcx.arena.alloc_from_iter(bounds.clauses(tcx))
+ tcx.arena.alloc_from_iter(bounds.clauses())
 })
 }
 

compiler/rustc_hir_analysis/src/collect/predicates_of.rs

@@ -106,7 +106,6 @@ fn gather_explicit_predicates_of(tcx: TyCtxt<'_>, def_id: LocalDefId) -> ty::Gen
 return ty::GenericPredicates{
 parent:Some(tcx.parent(def_id.to_def_id())),
 predicates: tcx.arena.alloc_from_iter(predicates),
-effects_min_tys: ty::List::empty(),
 };
 }
 
@@ -128,7 +127,6 @@ fn gather_explicit_predicates_of(tcx: TyCtxt<'_>, def_id: LocalDefId) -> ty::Gen
 return ty::GenericPredicates{
 parent:Some(impl_def_id),
 predicates: tcx.arena.alloc_from_iter(impl_predicates),
-effects_min_tys: ty::List::empty(),
 };
 }
 
@@ -154,7 +152,6 @@ fn gather_explicit_predicates_of(tcx: TyCtxt<'_>, def_id: LocalDefId) -> ty::Gen
 // We use an `IndexSet` to preserve order of insertion.
 // Preserving the order of insertion is important here so as not to break UI tests.
 letmut predicates:FxIndexSet<(ty::Clause<'_>,Span)> = FxIndexSet::default();
-letmut effects_min_tys = Vec::new();
 
 let hir_generics = node.generics().unwrap_or(NO_GENERICS);
 ifletNode::Item(item) = node {
@@ -189,8 +186,7 @@ fn gather_explicit_predicates_of(tcx: TyCtxt<'_>, def_id: LocalDefId) -> ty::Gen
  ty::List::empty(),
 PredicateFilter::All,
 );
- predicates.extend(bounds.clauses(tcx));
- effects_min_tys.extend(bounds.effects_min_tys());
+ predicates.extend(bounds.clauses());
 }
 
 // In default impls, we can assume that the self type implements
@@ -223,7 +219,7 @@ fn gather_explicit_predicates_of(tcx: TyCtxt<'_>, def_id: LocalDefId) -> ty::Gen
  param.span,
 );
 trace!(?bounds);
- predicates.extend(bounds.clauses(tcx));
+ predicates.extend(bounds.clauses());
 trace!(?predicates);
 }
  hir::GenericParamKind::Const{ .. } => {
@@ -275,8 +271,7 @@ fn gather_explicit_predicates_of(tcx: TyCtxt<'_>, def_id: LocalDefId) -> ty::Gen
  bound_vars,
 PredicateFilter::All,
 );
- predicates.extend(bounds.clauses(tcx));
- effects_min_tys.extend(bounds.effects_min_tys());
+ predicates.extend(bounds.clauses());
 }
 
  hir::WherePredicate::RegionPredicate(region_pred) => {
@@ -348,7 +343,6 @@ fn gather_explicit_predicates_of(tcx: TyCtxt<'_>, def_id: LocalDefId) -> ty::Gen
  ty::GenericPredicates{
 parent: generics.parent,
 predicates: tcx.arena.alloc_from_iter(predicates),
-effects_min_tys: tcx.mk_type_list(&effects_min_tys),
 }
 }
 
@@ -499,7 +493,6 @@ pub(super) fn explicit_predicates_of<'tcx>(
  ty::GenericPredicates{
 parent: predicates_and_bounds.parent,
 predicates: tcx.arena.alloc_slice(&predicates),
-effects_min_tys: predicates_and_bounds.effects_min_tys,
 }
 }
 }else{
@@ -551,7 +544,6 @@ pub(super) fn explicit_predicates_of<'tcx>(
 returnGenericPredicates{
 parent: parent_preds.parent,
 predicates:{ tcx.arena.alloc_from_iter(filtered_predicates)},
-effects_min_tys: parent_preds.effects_min_tys,
 };
 }
 gather_explicit_predicates_of(tcx, def_id)
@@ -630,7 +622,7 @@ pub(super) fn implied_predicates_with_filter<'tcx>(
 
 // Combine the two lists to form the complete set of superbounds:
 let implied_bounds =
-&*tcx.arena.alloc_from_iter(bounds.clauses(tcx).chain(where_bounds_that_match));
+&*tcx.arena.alloc_from_iter(bounds.clauses().chain(where_bounds_that_match));
 debug!(?implied_bounds);
 
 // Now require that immediate supertraits are lowered, which will, in
@@ -874,7 +866,7 @@ impl<'tcx> ItemCtxt<'tcx> {
 );
 }
 
- bounds.clauses(self.tcx).collect()
+ bounds.clauses().collect()
 }
 }
 
@@ -966,7 +958,7 @@ pub(super) fn const_conditions<'tcx>(
 
  ty::ConstConditions{
 parent: has_parent.then(|| tcx.local_parent(def_id).to_def_id()),
-predicates: tcx.arena.alloc_from_iter(bounds.clauses(tcx).map(|(clause, span)| {
+predicates: tcx.arena.alloc_from_iter(bounds.clauses().map(|(clause, span)| {
 (
  clause.kind().map_bound(|clause| match clause {
  ty::ClauseKind::HostEffect(ty::HostEffectPredicate{

compiler/rustc_hir_analysis/src/delegation.rs

@@ -278,8 +278,6 @@ impl<'tcx> PredicatesBuilder<'tcx> {
  ty::GenericPredicates{
 parent:self.parent,
 predicates:self.tcx.arena.alloc_from_iter(preds),
-// FIXME(fn_delegation): Support effects.
-effects_min_tys: ty::List::empty(),
 }
 }
 }