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

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

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

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,
         );
 

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,

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>(

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,
         }
     }

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> {

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

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)
             }

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");
         }