treat host effect params as erased generics in codegen

This fixes the changes brought to codegen tests when effect params are
added to libcore, by not attempting to monomorphize functions that get
the host param by being `const fn`.

Author: fee1-dead

Diff for: compiler/rustc_codegen_gcc/src/callee.rs

@@ -100,7 +100,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().next().is_some();
+            let is_generic = instance.non_erasable_generics(tcx).next().is_some();
 
             if is_generic {
                 // This is a monomorphization. Its expected visibility depends

Diff for: compiler/rustc_codegen_llvm/src/callee.rs

@@ -95,7 +95,7 @@ pub fn get_fn<'ll, 'tcx>(cx: &CodegenCx<'ll, 'tcx>, instance: Instance<'tcx>) ->
         unsafe {
             llvm::LLVMRustSetLinkage(llfn, llvm::Linkage::ExternalLinkage);
 
-            let is_generic = instance.args.non_erasable_generics().next().is_some();
+            let is_generic = instance.non_erasable_generics(tcx).next().is_some();
 
             if is_generic {
                 // This is a monomorphization. Its expected visibility depends

Diff for: compiler/rustc_codegen_llvm/src/debuginfo/mod.rs

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

Diff for: compiler/rustc_codegen_ssa/src/back/symbol_export.rs

@@ -333,8 +333,8 @@ fn exported_symbols_provider_local(
             }
 
             match *mono_item {
-                MonoItem::Fn(Instance { def: InstanceDef::Item(def), args }) => {
-                    if args.non_erasable_generics().next().is_some() {
+                MonoItem::Fn(instance @ Instance { def: InstanceDef::Item(def), args }) => {
+                    if instance.non_erasable_generics(tcx).next().is_some() {
                         let symbol = ExportedSymbol::Generic(def, args);
                         symbols.push((
                             symbol,

Diff for: compiler/rustc_codegen_ssa/src/debuginfo/type_names.rs

@@ -607,23 +607,21 @@ fn push_unqualified_item_name(
     };
 }
 
-fn push_generic_params_internal<'tcx>(
+fn push_generic_params_inner<'tcx>(
     tcx: TyCtxt<'tcx>,
-    args: GenericArgsRef<'tcx>,
+    args: impl Iterator<Item = GenericArgKind<'tcx>> + 'tcx,
     output: &mut String,
     visited: &mut FxHashSet<Ty<'tcx>>,
 ) -> bool {
-    if args.non_erasable_generics().next().is_none() {
+    let mut args = args.peekable();
+    if args.peek().is_none() {
         return false;
     }
-
-    debug_assert_eq!(args, tcx.normalize_erasing_regions(ty::ParamEnv::reveal_all(), args));
-
     let cpp_like_debuginfo = cpp_like_debuginfo(tcx);
 
     output.push('<');
 
-    for type_parameter in args.non_erasable_generics() {
+    for type_parameter in args {
         match type_parameter {
             GenericArgKind::Type(type_parameter) => {
                 push_debuginfo_type_name(tcx, type_parameter, true, output, visited);
@@ -642,6 +640,16 @@ fn push_generic_params_internal<'tcx>(
     true
 }
 
+fn push_generic_params_internal<'tcx>(
+    tcx: TyCtxt<'tcx>,
+    args: GenericArgsRef<'tcx>,
+    output: &mut String,
+    visited: &mut FxHashSet<Ty<'tcx>>,
+) -> bool {
+    debug_assert_eq!(args, tcx.normalize_erasing_regions(ty::ParamEnv::reveal_all(), args));
+    push_generic_params_inner(tcx, args.non_erasable_generics(), output, visited)
+}
+
 fn push_const_param<'tcx>(tcx: TyCtxt<'tcx>, ct: ty::Const<'tcx>, output: &mut String) {
     match ct.kind() {
         ty::ConstKind::Param(param) => {
@@ -691,11 +699,12 @@ fn push_const_param<'tcx>(tcx: TyCtxt<'tcx>, ct: ty::Const<'tcx>, output: &mut S
 pub fn push_generic_params<'tcx>(
     tcx: TyCtxt<'tcx>,
     args: GenericArgsRef<'tcx>,
+    generics: &'tcx ty::Generics,
     output: &mut String,
 ) {
     let _prof = tcx.prof.generic_activity("compute_debuginfo_type_name");
     let mut visited = FxHashSet::default();
-    push_generic_params_internal(tcx, args, output, &mut visited);
+    push_generic_params_inner(tcx, args.non_erasable_generics_real(generics), output, &mut visited);
 }
 
 fn push_closure_or_generator_name<'tcx>(

Diff for: compiler/rustc_middle/src/mir/mono.rs

@@ -78,9 +78,9 @@ impl<'tcx> MonoItem<'tcx> {
         }
     }
 
-    pub fn is_generic_fn(&self) -> bool {
+    pub fn is_generic_fn(&self, tcx: TyCtxt<'tcx>) -> bool {
         match *self {
-            MonoItem::Fn(ref instance) => instance.args.non_erasable_generics().next().is_some(),
+            MonoItem::Fn(ref instance) => instance.non_erasable_generics(tcx).next().is_some(),
             MonoItem::Static(..) | MonoItem::GlobalAsm(..) => false,
         }
     }

Diff for: compiler/rustc_middle/src/ty/generic_args.rs

@@ -379,6 +379,8 @@ impl<'tcx> GenericArgs<'tcx> {
         self.iter().filter_map(|k| k.as_const())
     }
 
+    /// Returns generic arguments that are not lifetimes. Consider using `non_erasable_generics_real`
+    /// if you have access to the generics declaration that this instance is for.
     #[inline]
     pub fn non_erasable_generics(
         &'tcx self,
@@ -389,6 +391,20 @@ impl<'tcx> GenericArgs<'tcx> {
         })
     }
 
+    /// Returns the "real" set of generic arguments that are not erasable. This considers
+    /// the host effect param information given by `generics`, which are erased to `true`
+    /// in runtime.
+    pub fn non_erasable_generics_real(
+        &'tcx self,
+        generics: &'tcx ty::Generics,
+    ) -> impl DoubleEndedIterator<Item = GenericArgKind<'tcx>> + 'tcx {
+        self.iter().enumerate().filter_map(|(i, k)| match k.unpack() {
+            _ if Some(i) == generics.host_effect_index => None,
+            ty::GenericArgKind::Lifetime(_) => None,
+            generic => Some(generic),
+        })
+    }
+
     #[inline]
     #[track_caller]
     pub fn type_at(&self, i: usize) -> Ty<'tcx> {

Diff for: compiler/rustc_middle/src/ty/generics.rs

@@ -212,10 +212,12 @@ impl<'tcx> Generics {
     pub fn own_requires_monomorphization(&self) -> bool {
         for param in &self.params {
             match param.kind {
-                GenericParamDefKind::Type { .. } | GenericParamDefKind::Const { .. } => {
+                GenericParamDefKind::Type { .. }
+                | GenericParamDefKind::Const { is_host_effect: false, .. } => {
                     return true;
                 }
-                GenericParamDefKind::Lifetime => {}
+                GenericParamDefKind::Lifetime
+                | GenericParamDefKind::Const { is_host_effect: true, .. } => {}
             }
         }
         false

Diff for: compiler/rustc_middle/src/ty/instance.rs

@@ -118,6 +118,13 @@ impl<'tcx> Instance<'tcx> {
         tcx.subst_and_normalize_erasing_regions(self.args, param_env, ty)
     }
 
+    pub fn non_erasable_generics(
+        &self,
+        tcx: TyCtxt<'tcx>,
+    ) -> impl DoubleEndedIterator<Item = ty::GenericArgKind<'tcx>> + 'tcx {
+        self.args.non_erasable_generics_real(tcx.generics_of(self.def_id()))
+    }
+
     /// Finds a crate that contains a monomorphization of this instance that
     /// can be linked to from the local crate. A return value of `None` means
     /// no upstream crate provides such an exported monomorphization.
@@ -139,7 +146,7 @@ impl<'tcx> Instance<'tcx> {
         }
 
         // If this a non-generic instance, it cannot be a shared monomorphization.
-        self.args.non_erasable_generics().next()?;
+        self.non_erasable_generics(tcx).next()?;
 
         match self.def {
             InstanceDef::Item(def) => tcx
@@ -344,6 +351,7 @@ impl<'tcx> Instance<'tcx> {
     pub fn mono(tcx: TyCtxt<'tcx>, def_id: DefId) -> Instance<'tcx> {
         let args = GenericArgs::for_item(tcx, def_id, |param, _| match param.kind {
             ty::GenericParamDefKind::Lifetime => tcx.lifetimes.re_erased.into(),
+            ty::GenericParamDefKind::Const { is_host_effect: true, .. } => tcx.consts.true_.into(),
             ty::GenericParamDefKind::Type { .. } => {
                 bug!("Instance::mono: {:?} has type parameters", def_id)
             }

Diff for: compiler/rustc_mir_transform/src/inline.rs

@@ -390,7 +390,7 @@ impl<'tcx> Inliner<'tcx> {
 
         // Reachability pass defines which functions are eligible for inlining. Generally inlining
         // other functions is incorrect because they could reference symbols that aren't exported.
-        let is_generic = callsite.callee.args.non_erasable_generics().next().is_some();
+        let is_generic = callsite.callee.non_erasable_generics(self.tcx).next().is_some();
         if !is_generic && !callee_attrs.requests_inline() {
             return Err("not exported");
         }

Diff for: compiler/rustc_monomorphize/src/collector.rs

@@ -459,7 +459,7 @@ fn collect_items_rec<'tcx>(
     // Check for PMEs and emit a diagnostic if one happened. To try to show relevant edges of the
     // mono item graph.
     if tcx.sess.diagnostic().err_count() > error_count
-        && starting_item.node.is_generic_fn()
+        && starting_item.node.is_generic_fn(tcx)
         && starting_item.node.is_user_defined()
     {
         let formatted_item = with_no_trimmed_paths!(starting_item.node.to_string());
@@ -1315,6 +1315,7 @@ fn create_mono_items_for_default_impls<'tcx>(
     // it, to validate whether or not the impl is legal to instantiate at all.
     let only_region_params = |param: &ty::GenericParamDef, _: &_| match param.kind {
         GenericParamDefKind::Lifetime => tcx.lifetimes.re_erased.into(),
+        GenericParamDefKind::Const { is_host_effect: true, .. } => tcx.consts.true_.into(),
         GenericParamDefKind::Type { .. } | GenericParamDefKind::Const { .. } => {
             unreachable!(
                 "`own_requires_monomorphization` check means that \

Diff for: compiler/rustc_monomorphize/src/partitioning.rs

@@ -221,7 +221,7 @@ where
         }
 
         let characteristic_def_id = characteristic_def_id_of_mono_item(cx.tcx, mono_item);
-        let is_volatile = is_incremental_build && mono_item.is_generic_fn();
+        let is_volatile = is_incremental_build && mono_item.is_generic_fn(cx.tcx);
 
         let cgu_name = match characteristic_def_id {
             Some(def_id) => compute_codegen_unit_name(
@@ -801,7 +801,7 @@ fn mono_item_visibility<'tcx>(
         return Visibility::Hidden;
     }
 
-    let is_generic = instance.args.non_erasable_generics().next().is_some();
+    let is_generic = instance.non_erasable_generics(tcx).next().is_some();
 
     // Upstream `DefId` instances get different handling than local ones.
     let Some(def_id) = def_id.as_local() else {

Diff for: compiler/rustc_symbol_mangling/src/lib.rs

@@ -108,7 +108,6 @@ use rustc_middle::middle::codegen_fn_attrs::CodegenFnAttrFlags;
 use rustc_middle::middle::codegen_fn_attrs::CodegenFnAttrs;
 use rustc_middle::mir::mono::{InstantiationMode, MonoItem};
 use rustc_middle::query::Providers;
-use rustc_middle::ty::GenericArgsRef;
 use rustc_middle::ty::{self, Instance, TyCtxt};
 use rustc_session::config::SymbolManglingVersion;
 
@@ -144,7 +143,7 @@ fn symbol_name_provider<'tcx>(tcx: TyCtxt<'tcx>, instance: Instance<'tcx>) -> ty
         // This closure determines the instantiating crate for instances that
         // need an instantiating-crate-suffix for their symbol name, in order
         // to differentiate between local copies.
-        if is_generic(instance.args) {
+        if is_generic(instance, tcx) {
             // For generics we might find re-usable upstream instances. If there
             // is one, we rely on the symbol being instantiated locally.
             instance.upstream_monomorphization(tcx).unwrap_or(LOCAL_CRATE)
@@ -246,7 +245,7 @@ fn compute_symbol_name<'tcx>(
     // the ID of the instantiating crate. This avoids symbol conflicts
     // in case the same instances is emitted in two crates of the same
     // project.
-    let avoid_cross_crate_conflicts = is_generic(args) || is_globally_shared_function;
+    let avoid_cross_crate_conflicts = is_generic(instance, tcx) || is_globally_shared_function;
 
     let instantiating_crate = avoid_cross_crate_conflicts.then(compute_instantiating_crate);
 
@@ -278,6 +277,6 @@ fn compute_symbol_name<'tcx>(
     symbol
 }
 
-fn is_generic(args: GenericArgsRef<'_>) -> bool {
-    args.non_erasable_generics().next().is_some()
+fn is_generic<'tcx>(instance: Instance<'tcx>, tcx: TyCtxt<'tcx>) -> bool {
+    instance.non_erasable_generics(tcx).next().is_some()
 }

Diff for: compiler/rustc_ty_utils/src/instance.rs

@@ -55,6 +55,7 @@ fn resolve_instance<'tcx>(
             }
         } else {
             debug!(" => free item");
+            // FIXME(effects): we may want to erase the effect param if that is present on this item.
             ty::InstanceDef::Item(def_id)
         };