Perform unconstrained param detection in explicit_predicates_of and taint the query result

Author: oli-obk

compiler/rustc_hir_analysis/src/collect/predicates_of.rs

@@ -4,7 +4,9 @@ use rustc_hir as hir;
 use rustc_hir::def::DefKind;
 use rustc_hir::def_id::{DefId, LocalDefId};
 use rustc_hir::intravisit::{self, Visitor};
-use rustc_middle::ty::{self, GenericPredicates, ImplTraitInTraitData, Ty, TyCtxt, Upcast};
+use rustc_middle::ty::{
+    self, GenericPredicates, ImplTraitInTraitData, Ty, TyCtxt, TypeVisitableExt, Upcast,
+};
 use rustc_middle::{bug, span_bug};
 use rustc_span::symbol::Ident;
 use rustc_span::{Span, DUMMY_SP};
@@ -86,6 +88,7 @@ fn gather_explicit_predicates_of(tcx: TyCtxt<'_>, def_id: LocalDefId) -> ty::Gen
                 parent: Some(tcx.parent(def_id.to_def_id())),
                 predicates: tcx.arena.alloc_from_iter(predicates),
                 effects_min_tys: ty::List::empty(),
+                errored_due_to_unconstrained_params: Ok(()),
             };
         }
 
@@ -108,6 +111,8 @@ fn gather_explicit_predicates_of(tcx: TyCtxt<'_>, def_id: LocalDefId) -> ty::Gen
                 parent: Some(impl_def_id),
                 predicates: tcx.arena.alloc_from_iter(impl_predicates),
                 effects_min_tys: ty::List::empty(),
+                errored_due_to_unconstrained_params: trait_assoc_predicates
+                    .errored_due_to_unconstrained_params,
             };
         }
 
@@ -128,6 +133,7 @@ fn gather_explicit_predicates_of(tcx: TyCtxt<'_>, def_id: LocalDefId) -> ty::Gen
     // Preserving the order of insertion is important here so as not to break UI tests.
     let mut predicates: FxIndexSet<(ty::Clause<'_>, Span)> = FxIndexSet::default();
     let mut effects_min_tys = Vec::new();
+    let mut errored_due_to_unconstrained_params = Ok(());
 
     let hir_generics = node.generics().unwrap_or(NO_GENERICS);
     if let Node::Item(item) = node {
@@ -291,11 +297,16 @@ fn gather_explicit_predicates_of(tcx: TyCtxt<'_>, def_id: LocalDefId) -> ty::Gen
     if let Node::Item(&Item { kind: ItemKind::Impl { .. }, .. }) = node {
         let self_ty = tcx.type_of(def_id).instantiate_identity();
         let trait_ref = tcx.impl_trait_ref(def_id).map(ty::EarlyBinder::instantiate_identity);
-        cgp::setup_constraining_predicates(
-            tcx,
-            &mut predicates,
-            trait_ref,
-            &mut cgp::parameters_for_impl(tcx, self_ty, trait_ref),
+        let mut input_parameters = cgp::parameters_for_impl(tcx, self_ty, trait_ref);
+        cgp::setup_constraining_predicates(tcx, &mut predicates, trait_ref, &mut input_parameters);
+        errored_due_to_unconstrained_params = errored_due_to_unconstrained_params.and(
+            self_ty.error_reported().and(trait_ref.error_reported()).and_then(|()| {
+                crate::impl_wf_check::enforce_impl_params_are_constrained(
+                    tcx,
+                    def_id,
+                    input_parameters,
+                )
+            }),
         );
     }
 
@@ -338,6 +349,7 @@ fn gather_explicit_predicates_of(tcx: TyCtxt<'_>, def_id: LocalDefId) -> ty::Gen
         parent: generics.parent,
         predicates: tcx.arena.alloc_from_iter(predicates),
         effects_min_tys: tcx.mk_type_list(&effects_min_tys),
+        errored_due_to_unconstrained_params,
     }
 }
 
@@ -489,6 +501,8 @@ pub(super) fn explicit_predicates_of<'tcx>(
                 parent: predicates_and_bounds.parent,
                 predicates: tcx.arena.alloc_slice(&predicates),
                 effects_min_tys: predicates_and_bounds.effects_min_tys,
+                errored_due_to_unconstrained_params: predicates_and_bounds
+                    .errored_due_to_unconstrained_params,
             }
         }
     } else {
@@ -541,6 +555,8 @@ pub(super) fn explicit_predicates_of<'tcx>(
                 parent: parent_preds.parent,
                 predicates: { tcx.arena.alloc_from_iter(filtered_predicates) },
                 effects_min_tys: parent_preds.effects_min_tys,
+                errored_due_to_unconstrained_params: parent_preds
+                    .errored_due_to_unconstrained_params,
             };
         }
         gather_explicit_predicates_of(tcx, def_id)
@@ -653,6 +669,7 @@ pub(super) fn implied_predicates_with_filter(
         parent: None,
         predicates: implied_bounds,
         effects_min_tys: ty::List::empty(),
+        errored_due_to_unconstrained_params: Ok(()),
     }
 }
 
@@ -688,7 +705,12 @@ pub(super) fn type_param_predicates(
             let icx = ItemCtxt::new(tcx, parent);
             icx.probe_ty_param_bounds(DUMMY_SP, def_id, assoc_name)
         })
-        .unwrap_or_default();
+        .unwrap_or(GenericPredicates {
+            parent: None,
+            predicates: &[],
+            effects_min_tys: ty::List::empty(),
+            errored_due_to_unconstrained_params: Ok(()),
+        });
     let mut extend = None;
 
     let item_hir_id = tcx.local_def_id_to_hir_id(item_def_id);

compiler/rustc_hir_analysis/src/impl_wf_check.rs

@@ -9,10 +9,11 @@
 //! fixed, but for the moment it's easier to do these checks early.
 
 use min_specialization::check_min_specialization;
+use rustc_data_structures::fx::FxHashSet;
 use rustc_errors::codes::*;
 use rustc_hir::def::DefKind;
 use rustc_hir::def_id::LocalDefId;
-use rustc_middle::ty::{self, TyCtxt, TypeVisitableExt};
+use rustc_middle::ty::{self, TyCtxt};
 use rustc_span::ErrorGuaranteed;
 
 use crate::constrained_generic_params as cgp;
@@ -54,34 +55,21 @@ pub fn check_impl_wf(tcx: TyCtxt<'_>, impl_def_id: LocalDefId) -> Result<(), Err
     let min_specialization = tcx.features().min_specialization;
     let mut res = Ok(());
     debug_assert!(matches!(tcx.def_kind(impl_def_id), DefKind::Impl { .. }));
-    res = res.and(enforce_impl_params_are_constrained(tcx, impl_def_id));
+    res = res.and(tcx.explicit_predicates_of(impl_def_id).errored_due_to_unconstrained_params);
     if min_specialization {
         res = res.and(check_min_specialization(tcx, impl_def_id));
     }
 
     res
 }
 
-fn enforce_impl_params_are_constrained(
+pub(crate) fn enforce_impl_params_are_constrained(
     tcx: TyCtxt<'_>,
     impl_def_id: LocalDefId,
+    input_parameters: FxHashSet<cgp::Parameter>,
 ) -> Result<(), ErrorGuaranteed> {
     // Every lifetime used in an associated type must be constrained.
-    let impl_self_ty = tcx.type_of(impl_def_id).instantiate_identity();
-    impl_self_ty.error_reported()?;
     let impl_generics = tcx.generics_of(impl_def_id);
-    let impl_predicates = tcx.predicates_of(impl_def_id);
-    let impl_trait_ref = tcx.impl_trait_ref(impl_def_id).map(ty::EarlyBinder::instantiate_identity);
-
-    impl_trait_ref.error_reported()?;
-
-    let mut input_parameters = cgp::parameters_for_impl(tcx, impl_self_ty, impl_trait_ref);
-    cgp::identify_constrained_generic_params(
-        tcx,
-        impl_predicates,
-        impl_trait_ref,
-        &mut input_parameters,
-    );
 
     let mut res = Ok(());
     for param in &impl_generics.own_params {

compiler/rustc_hir_typeck/src/fn_ctxt/mod.rs

@@ -279,6 +279,7 @@ impl<'tcx> HirTyLowerer<'tcx> for FnCtxt<'_, 'tcx> {
                 }),
             ),
             effects_min_tys: ty::List::empty(),
+            errored_due_to_unconstrained_params: Ok(()),
         }
     }
 

compiler/rustc_middle/src/ty/generics.rs

@@ -3,7 +3,7 @@ use rustc_data_structures::fx::FxHashMap;
 use rustc_hir::def_id::DefId;
 use rustc_macros::{HashStable, TyDecodable, TyEncodable};
 use rustc_span::symbol::{kw, Symbol};
-use rustc_span::Span;
+use rustc_span::{ErrorGuaranteed, Span};
 use tracing::instrument;
 
 use super::{Clause, InstantiatedPredicates, ParamConst, ParamTy, Ty, TyCtxt};
@@ -367,11 +367,12 @@ impl<'tcx> Generics {
 }
 
 /// Bounds on generics.
-#[derive(Copy, Clone, Default, Debug, TyEncodable, TyDecodable, HashStable)]
+#[derive(Copy, Clone, Debug, TyEncodable, TyDecodable, HashStable)]
 pub struct GenericPredicates<'tcx> {
     pub parent: Option<DefId>,
     pub predicates: &'tcx [(Clause<'tcx>, Span)],
     pub effects_min_tys: &'tcx ty::List<Ty<'tcx>>,
+    pub errored_due_to_unconstrained_params: Result<(), ErrorGuaranteed>,
 }
 
 impl<'tcx> GenericPredicates<'tcx> {

compiler/rustc_smir/src/rustc_smir/context.rs

@@ -161,8 +161,12 @@ impl<'tcx> Context for TablesWrapper<'tcx> {
     fn predicates_of(&self, def_id: stable_mir::DefId) -> stable_mir::ty::GenericPredicates {
         let mut tables = self.0.borrow_mut();
         let def_id = tables[def_id];
-        let GenericPredicates { parent, predicates, effects_min_tys: _ } =
-            tables.tcx.predicates_of(def_id);
+        let GenericPredicates {
+            parent,
+            predicates,
+            effects_min_tys: _,
+            errored_due_to_unconstrained_params: _,
+        } = tables.tcx.predicates_of(def_id);
         stable_mir::ty::GenericPredicates {
             parent: parent.map(|did| tables.trait_def(did)),
             predicates: predicates
@@ -183,8 +187,12 @@ impl<'tcx> Context for TablesWrapper<'tcx> {
     ) -> stable_mir::ty::GenericPredicates {
         let mut tables = self.0.borrow_mut();
         let def_id = tables[def_id];
-        let GenericPredicates { parent, predicates, effects_min_tys: _ } =
-            tables.tcx.explicit_predicates_of(def_id);
+        let GenericPredicates {
+            parent,
+            predicates,
+            effects_min_tys: _,
+            errored_due_to_unconstrained_params: _,
+        } = tables.tcx.explicit_predicates_of(def_id);
         stable_mir::ty::GenericPredicates {
             parent: parent.map(|did| tables.trait_def(did)),
             predicates: predicates

inc-fat/debuginfo_lto_alloc-3sqmtdvybgxcy/s-gyc0fcg7uo-1vs3i8e-2ilcfwxf8c5240manakn6i3yu/dep-graph.bin

@@ -103,7 +103,12 @@ fn synthesize_auto_trait_impl<'tcx>(
             let mut generics = clean_ty_generics(
                 cx,
                 tcx.generics_of(item_def_id),
-                ty::GenericPredicates::default(),
+                ty::GenericPredicates {
+                    parent: None,
+                    predicates: &[],
+                    effects_min_tys: ty::List::empty(),
+                    errored_due_to_unconstrained_params: Ok(()),
+                },
             );
             generics.where_predicates.clear();