Look at called functions for usedness of generic params

When a generic param is only used in a const fndef where it is in turn
unused, then it's unused in the caller as well.

This causes query cycles on recursive functions, we need to recover from
them and ignore them.

Author: Noratrieb

compiler/rustc_index/src/bit_set.rs

@@ -2089,10 +2089,38 @@ impl<T: FiniteBitSetTy> FiniteBitSet<T> {
         self.within_domain(index)
             .then(|| ((self.0.checked_shr(index).unwrap_or(T::ONE)) & T::ONE) == T::ONE)
     }
+
+    /// Returns an iterator over the bitset, yielding every bit.
+    pub fn iter(&self) -> FullFiniteBitSetIter<T> {
+        FullFiniteBitSetIter::new(*self)
+    }
 }
 
 impl<T: FiniteBitSetTy> Default for FiniteBitSet<T> {
     fn default() -> Self {
         Self::new_empty()
     }
 }
+
+/// An iterator that iterates over a finite bitset and yields every bit.
+pub struct FullFiniteBitSetIter<T: FiniteBitSetTy> {
+    bitset: FiniteBitSet<T>,
+    position: u32,
+}
+
+impl<T: FiniteBitSetTy> FullFiniteBitSetIter<T> {
+    fn new(bitset: FiniteBitSet<T>) -> Self {
+        Self { bitset, position: 0 }
+    }
+}
+
+impl<T: FiniteBitSetTy> Iterator for FullFiniteBitSetIter<T> {
+    type Item = bool;
+
+    fn next(&mut self) -> Option<Self::Item> {
+        self.bitset.contains(self.position).map(|bit| {
+            self.position += 1;
+            bit
+        })
+    }
+}

compiler/rustc_middle/src/ty/instance.rs

@@ -6,7 +6,7 @@ use rustc_errors::ErrorGuaranteed;
 use rustc_hir::def::Namespace;
 use rustc_hir::def_id::{CrateNum, DefId};
 use rustc_hir::lang_items::LangItem;
-use rustc_index::bit_set::FiniteBitSet;
+use rustc_index::bit_set::{FiniteBitSet, FullFiniteBitSetIter};
 use rustc_macros::HashStable;
 use rustc_middle::ty::normalize_erasing_regions::NormalizationError;
 use rustc_span::Symbol;
@@ -807,4 +807,11 @@ impl UnusedGenericParams {
     pub fn all_used(&self) -> bool {
         self.0.is_empty()
     }
+
+    /// Iterates over all the flags in the internal bitset. This will not only return the flags
+    /// for the generic paramters but also more than that, so the caller has to make sure to limit
+    /// iteration by the actual amount of flags.
+    pub fn iter_over_eager(&self) -> FullFiniteBitSetIter<u32> {
+        self.0.iter()
+    }
 }

compiler/rustc_monomorphize/src/lib.rs

@@ -1,5 +1,6 @@
 #![feature(array_windows)]
 #![feature(control_flow_enum)]
+#![feature(let_chains)]
 #![recursion_limit = "256"]
 #![allow(rustc::potential_query_instability)]
 #![deny(rustc::untranslatable_diagnostic)]

compiler/rustc_monomorphize/src/polymorphize.rs

@@ -6,20 +6,24 @@
 //! for their size, offset of a field, etc.).
 
 use rustc_hir::{def::DefKind, def_id::DefId, ConstContext};
-use rustc_middle::mir::{
-    self,
-    visit::{TyContext, Visitor},
-    Constant, ConstantKind, Local, LocalDecl, Location,
-};
 use rustc_middle::ty::{
     self,
     query::Providers,
     subst::SubstsRef,
     visit::{TypeSuperVisitable, TypeVisitable, TypeVisitor},
     Const, Ty, TyCtxt, UnusedGenericParams,
 };
+use rustc_middle::{
+    mir::{
+        self,
+        visit::{TyContext, Visitor},
+        Constant, ConstantKind, Local, LocalDecl, Location,
+    },
+    ty::Instance,
+};
 use rustc_span::symbol::sym;
 use std::ops::ControlFlow;
+use std::{convert::TryInto, iter};
 
 use crate::errors::UnusedGenericParamsHint;
 
@@ -32,6 +36,7 @@ pub fn provide(providers: &mut Providers) {
 ///
 /// Returns a bitset where bits representing unused parameters are set (`is_empty` indicates all
 /// parameters are used).
+#[instrument(skip(tcx), level = "debug")]
 fn unused_generic_params<'tcx>(
     tcx: TyCtxt<'tcx>,
     instance: ty::InstanceDef<'tcx>,
@@ -44,6 +49,7 @@ fn unused_generic_params<'tcx>(
     let def_id = instance.def_id();
     // Exit early if this instance should not be polymorphized.
     if !should_polymorphize(tcx, def_id, instance) {
+        debug!("Should not polymorphize instance");
         return UnusedGenericParams::new_all_used();
     }
 
@@ -52,6 +58,7 @@ fn unused_generic_params<'tcx>(
 
     // Exit early when there are no parameters to be unused.
     if generics.count() == 0 {
+        debug!("No generics");
         return UnusedGenericParams::new_all_used();
     }
 
@@ -248,6 +255,29 @@ impl<'a, 'tcx> MarkUsedGenericParams<'a, 'tcx> {
         }
         debug!(?self.unused_parameters);
     }
+
+    fn maybe_ignore_unused_fn_def_const(&mut self, ty: Ty<'tcx>) {
+        if let ty::FnDef(def_id, substs) = *ty.kind()
+            && let param_env = self.tcx.param_env(def_id)
+            && let Ok(substs) = self.tcx.try_normalize_erasing_regions(param_env, substs)
+            && let Ok(Some(instance)) = Instance::resolve(self.tcx, param_env, def_id, substs)
+            && let unused_params = self.tcx.unused_generic_params(instance.def)
+            && !unused_params.all_used()
+        {
+            debug!(?unused_params, "Referencing a function that has unused generic params, not marking them all as used");
+
+            for (subst, is_unused) in iter::zip(substs, unused_params.iter_over_eager()) {
+                if let ty::GenericArgKind::Type(subst_ty) = subst.unpack()
+                    && let ty::Param(param) = subst_ty.kind()
+                    && !is_unused
+                {
+                    self.unused_parameters.mark_used(param.index);
+                }
+            }
+        } else {
+            ty.visit_with(self);
+        }
+    }
 }
 
 impl<'a, 'tcx> Visitor<'tcx> for MarkUsedGenericParams<'a, 'tcx> {
@@ -268,7 +298,8 @@ impl<'a, 'tcx> Visitor<'tcx> for MarkUsedGenericParams<'a, 'tcx> {
         self.super_local_decl(local, local_decl);
     }
 
-    fn visit_constant(&mut self, ct: &Constant<'tcx>, location: Location) {
+    #[instrument(level = "debug", skip(self))]
+    fn visit_constant(&mut self, ct: &Constant<'tcx>, _: Location) {
         match ct.literal {
             ConstantKind::Ty(c) => {
                 c.visit_with(self);
@@ -285,9 +316,11 @@ impl<'a, 'tcx> Visitor<'tcx> for MarkUsedGenericParams<'a, 'tcx> {
                     }
                 }
 
-                Visitor::visit_ty(self, ty, TyContext::Location(location));
+                self.maybe_ignore_unused_fn_def_const(ty);
+            }
+            ConstantKind::Val(_, ty) => {
+                self.maybe_ignore_unused_fn_def_const(ty);
             }
-            ConstantKind::Val(_, ty) => Visitor::visit_ty(self, ty, TyContext::Location(location)),
         }
     }
 
@@ -315,7 +348,10 @@ impl<'a, 'tcx> TypeVisitor<'tcx> for MarkUsedGenericParams<'a, 'tcx> {
                 self.visit_child_body(def.did, substs);
                 ControlFlow::CONTINUE
             }
-            _ => c.super_visit_with(self),
+            _ => {
+                self.maybe_ignore_unused_fn_def_const(c.ty());
+                ControlFlow::CONTINUE
+            }
         }
     }