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

src/librustdoc/clean/auto_trait.rs

@@ -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();
 

src/librustdoc/clean/mod.rs

@@ -1411,6 +1411,7 @@ pub(crate) fn clean_middle_assoc_item<'tcx>(
                     parent: None,
                     predicates,
                     effects_min_tys: ty::List::empty(),
+                    errored_due_to_unconstrained_params: Ok(()),
                 },
             );
             simplify::move_bounds_to_generic_parameters(&mut generics);

tests/crashes/126646.rs renamed to tests/ui/associated-item/missing_method_in_impl_with_unconstrained_type_param.rs

@@ -1,11 +1,13 @@
-//@ known-bug: rust-lang/rust#126646
+//! This test used to ICE when trying to resolve the method call in the `test` function.
+
 mod foo {
     pub trait Callable {
         type Output;
         fn call() -> Self::Output;
     }
 
     impl<'a, V: ?Sized> Callable for &'a () {
+        //~^ ERROR: `V` is not constrained
         type Output = ();
     }
 }

tests/ui/associated-item/missing_method_in_impl_with_unconstrained_type_param.stderr

@@ -0,0 +1,9 @@
+error[E0207]: the type parameter `V` is not constrained by the impl trait, self type, or predicates
+  --> $DIR/missing_method_in_impl_with_unconstrained_type_param.rs:9:14
+   |
+LL |     impl<'a, V: ?Sized> Callable for &'a () {
+   |              ^ unconstrained type parameter
+
+error: aborting due to 1 previous error
+
+For more information about this error, try `rustc --explain E0207`.

tests/ui/dropck/unconstrained_const_param_on_drop.stderr

@@ -1,3 +1,12 @@
+error[E0207]: the const parameter `UNUSED` is not constrained by the impl trait, self type, or predicates
+  --> $DIR/unconstrained_const_param_on_drop.rs:3:6
+   |
+LL | impl<const UNUSED: usize> Drop for Foo {}
+   |      ^^^^^^^^^^^^^^^^^^^ unconstrained const parameter
+   |
+   = note: expressions using a const parameter must map each value to a distinct output value
+   = note: proving the result of expressions other than the parameter are unique is not supported
+
 error[E0367]: `Drop` impl requires `the constant `_` has type `usize`` but the struct it is implemented for does not
   --> $DIR/unconstrained_const_param_on_drop.rs:3:6
    |
@@ -10,15 +19,6 @@ note: the implementor must specify the same requirement
 LL | struct Foo {}
    | ^^^^^^^^^^
 
-error[E0207]: the const parameter `UNUSED` is not constrained by the impl trait, self type, or predicates
-  --> $DIR/unconstrained_const_param_on_drop.rs:3:6
-   |
-LL | impl<const UNUSED: usize> Drop for Foo {}
-   |      ^^^^^^^^^^^^^^^^^^^ unconstrained const parameter
-   |
-   = note: expressions using a const parameter must map each value to a distinct output value
-   = note: proving the result of expressions other than the parameter are unique is not supported
-
 error: aborting due to 2 previous errors
 
 Some errors have detailed explanations: E0207, E0367.

tests/ui/impl-unused-tps.stderr

@@ -1,3 +1,27 @@
+error[E0207]: the type parameter `U` is not constrained by the impl trait, self type, or predicates
+  --> $DIR/impl-unused-tps.rs:47:8
+   |
+LL | impl<T,U,V> Foo<T> for T
+   |        ^ unconstrained type parameter
+
+error[E0207]: the type parameter `V` is not constrained by the impl trait, self type, or predicates
+  --> $DIR/impl-unused-tps.rs:47:10
+   |
+LL | impl<T,U,V> Foo<T> for T
+   |          ^ unconstrained type parameter
+
+error[E0207]: the type parameter `U` is not constrained by the impl trait, self type, or predicates
+  --> $DIR/impl-unused-tps.rs:31:8
+   |
+LL | impl<T,U> Bar for T {
+   |        ^ unconstrained type parameter
+
+error[E0207]: the type parameter `U` is not constrained by the impl trait, self type, or predicates
+  --> $DIR/impl-unused-tps.rs:39:8
+   |
+LL | impl<T,U> Bar for T
+   |        ^ unconstrained type parameter
+
 error[E0119]: conflicting implementations of trait `Foo<_>` for type `[isize; 0]`
   --> $DIR/impl-unused-tps.rs:27:1
    |
@@ -26,30 +50,6 @@ error[E0207]: the type parameter `U` is not constrained by the impl trait, self
 LL | impl<T,U> Foo<T> for [isize;1] {
    |        ^ unconstrained type parameter
 
-error[E0207]: the type parameter `U` is not constrained by the impl trait, self type, or predicates
-  --> $DIR/impl-unused-tps.rs:31:8
-   |
-LL | impl<T,U> Bar for T {
-   |        ^ unconstrained type parameter
-
-error[E0207]: the type parameter `U` is not constrained by the impl trait, self type, or predicates
-  --> $DIR/impl-unused-tps.rs:39:8
-   |
-LL | impl<T,U> Bar for T
-   |        ^ unconstrained type parameter
-
-error[E0207]: the type parameter `U` is not constrained by the impl trait, self type, or predicates
-  --> $DIR/impl-unused-tps.rs:47:8
-   |
-LL | impl<T,U,V> Foo<T> for T
-   |        ^ unconstrained type parameter
-
-error[E0207]: the type parameter `V` is not constrained by the impl trait, self type, or predicates
-  --> $DIR/impl-unused-tps.rs:47:10
-   |
-LL | impl<T,U,V> Foo<T> for T
-   |          ^ unconstrained type parameter
-
 error: aborting due to 7 previous errors
 
 Some errors have detailed explanations: E0119, E0207, E0275.

tests/ui/type-alias-impl-trait/ice-failed-to-resolve-instance-for-110696.stderr

@@ -11,6 +11,12 @@ note: this opaque type is in the signature
 LL | type DummyT<T> = impl F;
    |                  ^^^^^^
 
+error[E0207]: the type parameter `T` is not constrained by the impl trait, self type, or predicates
+  --> $DIR/ice-failed-to-resolve-instance-for-110696.rs:41:6
+   |
+LL | impl<T: MyFrom<Phantom2<DummyT<U>>>, U> MyIndex<DummyT<T>> for Scope<U> {
+   |      ^ unconstrained type parameter
+
 error: item does not constrain `DummyT::{opaque#0}`, but has it in its signature
   --> $DIR/ice-failed-to-resolve-instance-for-110696.rs:44:8
    |
@@ -24,12 +30,6 @@ note: this opaque type is in the signature
 LL | type DummyT<T> = impl F;
    |                  ^^^^^^
 
-error[E0207]: the type parameter `T` is not constrained by the impl trait, self type, or predicates
-  --> $DIR/ice-failed-to-resolve-instance-for-110696.rs:41:6
-   |
-LL | impl<T: MyFrom<Phantom2<DummyT<U>>>, U> MyIndex<DummyT<T>> for Scope<U> {
-   |      ^ unconstrained type parameter
-
 error: aborting due to 3 previous errors
 
 For more information about this error, try `rustc --explain E0207`.