Elaborate bounds before checking impl correctness

Author: oli-obk

compiler/rustc_hir_analysis/src/collect.rs

@@ -1346,7 +1346,11 @@ pub fn suggest_impl_trait<'tcx>(
 
 fn impl_is_fully_generic_for_reflection(tcx: TyCtxt<'_>, def_id: LocalDefId) -> bool {
     tcx.impl_trait_header(def_id).is_fully_generic_for_reflection()
-        && tcx.explicit_predicates_of(def_id).is_fully_generic_for_reflection()
+        && rustc_trait_selection::traits::elaborate(
+            tcx,
+            tcx.predicates_of(def_id).instantiate_identity(tcx).into_iter(),
+        )
+        .all(|(clause, _)| clause.is_fully_generic_for_reflection())
 }
 
 fn impl_trait_header(tcx: TyCtxt<'_>, def_id: LocalDefId) -> ty::ImplTraitHeader<'_> {

compiler/rustc_middle/src/ty/generics.rs

@@ -1,15 +1,12 @@
-use std::ops::ControlFlow;
-
 use rustc_ast as ast;
 use rustc_data_structures::fx::FxHashMap;
 use rustc_hir::def_id::DefId;
 use rustc_macros::{HashStable, TyDecodable, TyEncodable};
 use rustc_span::{Span, Symbol, kw};
-use rustc_type_ir::{TypeSuperVisitable as _, TypeVisitable, TypeVisitor};
 use tracing::instrument;
 
 use super::{Clause, InstantiatedPredicates, ParamConst, ParamTy, Ty, TyCtxt};
-use crate::ty::{self, ClauseKind, EarlyBinder, GenericArgsRef, Region, RegionKind, TyKind};
+use crate::ty::{self, EarlyBinder, GenericArgsRef};
 
 #[derive(Clone, Debug, TyEncodable, TyDecodable, HashStable)]
 pub enum GenericParamDefKind {
@@ -423,70 +420,6 @@ impl<'tcx> GenericPredicates<'tcx> {
         instantiated.predicates.extend(self.predicates.iter().map(|(p, _)| p));
         instantiated.spans.extend(self.predicates.iter().map(|(_, s)| s));
     }
-
-    /// Allow simple where bounds like `T: Debug`, but prevent any kind of
-    /// outlives bounds or uses of generic parameters on the right hand side.
-    pub fn is_fully_generic_for_reflection(self) -> bool {
-        struct ParamChecker;
-        impl<'tcx> TypeVisitor<TyCtxt<'tcx>> for ParamChecker {
-            type Result = ControlFlow<()>;
-            fn visit_region(&mut self, r: Region<'tcx>) -> Self::Result {
-                match r.kind() {
-                    RegionKind::ReEarlyParam(_) | RegionKind::ReStatic | RegionKind::ReError(_) => {
-                        ControlFlow::Break(())
-                    }
-                    RegionKind::ReVar(_)
-                    | RegionKind::RePlaceholder(_)
-                    | RegionKind::ReErased
-                    | RegionKind::ReLateParam(_) => {
-                        bug!("unexpected lifetime in impl: {r:?}")
-                    }
-                    RegionKind::ReBound(..) => ControlFlow::Continue(()),
-                }
-            }
-
-            fn visit_ty(&mut self, t: Ty<'tcx>) -> Self::Result {
-                match t.kind() {
-                    TyKind::Param(_p) => {
-                        // Reject using parameters used in the type in where bounds
-                        return ControlFlow::Break(());
-                    }
-                    TyKind::Alias(..) => return ControlFlow::Break(()),
-                    _ => (),
-                }
-                t.super_visit_with(self)
-            }
-        }
-
-        // Pessimistic: if any of the parameters have where bounds
-        // don't allow this impl to be used.
-        self.predicates.iter().all(|(clause, _)| {
-            match clause.kind().skip_binder() {
-                ClauseKind::Trait(trait_predicate) => {
-                    // In a `T: Trait`, if the rhs bound does not contain any generic params
-                    // or 'static lifetimes, then it cannot transitively cause such requirements,
-                    // considering we apply the fully-generic-for-reflection rules to any impls for
-                    // that trait, too.
-                    if matches!(trait_predicate.self_ty().kind(), ty::Param(_))
-                        && trait_predicate.trait_ref.args[1..]
-                            .iter()
-                            .all(|arg| arg.visit_with(&mut ParamChecker).is_continue())
-                    {
-                        return true;
-                    }
-                }
-                ClauseKind::RegionOutlives(_)
-                | ClauseKind::TypeOutlives(_)
-                | ClauseKind::Projection(_)
-                | ClauseKind::ConstArgHasType(_, _)
-                | ClauseKind::WellFormed(_)
-                | ClauseKind::ConstEvaluatable(_)
-                | ClauseKind::HostEffect(_)
-                | ClauseKind::UnstableFeature(_) => {}
-            }
-            clause.visit_with(&mut ParamChecker).is_continue()
-        })
-    }
 }
 
 /// `[const]` bounds for a given item. This is represented using a struct much like

compiler/rustc_middle/src/ty/predicate.rs

@@ -1,12 +1,14 @@
 use std::cmp::Ordering;
+use std::ops::ControlFlow;
 
 use rustc_data_structures::intern::Interned;
 use rustc_hir::def_id::DefId;
 use rustc_macros::{HashStable, extension};
-use rustc_type_ir as ir;
+use rustc_type_ir::{self as ir, TypeSuperVisitable as _, TypeVisitable as _, TypeVisitor};
 
 use crate::ty::{
-    self, DebruijnIndex, EarlyBinder, Ty, TyCtxt, TypeFlags, Upcast, UpcastFrom, WithCachedTypeInfo,
+    self, DebruijnIndex, EarlyBinder, Region, RegionKind, Ty, TyCtxt, TypeFlags, Upcast,
+    UpcastFrom, WithCachedTypeInfo,
 };
 
 pub type TraitRef<'tcx> = ir::TraitRef<TyCtxt<'tcx>>;
@@ -215,6 +217,68 @@ impl<'tcx> Clause<'tcx> {
             None
         }
     }
+
+    /// Allow simple where bounds like `T: Debug`, but prevent any kind of
+    /// outlives bounds or uses of generic parameters on the right hand side.
+    pub fn is_fully_generic_for_reflection(self) -> bool {
+        struct ParamChecker;
+        impl<'tcx> TypeVisitor<TyCtxt<'tcx>> for ParamChecker {
+            type Result = ControlFlow<()>;
+            fn visit_region(&mut self, r: Region<'tcx>) -> Self::Result {
+                match r.kind() {
+                    RegionKind::ReEarlyParam(_) | RegionKind::ReStatic | RegionKind::ReError(_) => {
+                        ControlFlow::Break(())
+                    }
+                    RegionKind::ReVar(_)
+                    | RegionKind::RePlaceholder(_)
+                    | RegionKind::ReErased
+                    | RegionKind::ReLateParam(_) => {
+                        bug!("unexpected lifetime in impl: {r:?}")
+                    }
+                    RegionKind::ReBound(..) => ControlFlow::Continue(()),
+                }
+            }
+
+            fn visit_ty(&mut self, t: Ty<'tcx>) -> Self::Result {
+                match t.kind() {
+                    ty::Param(_p) => {
+                        // Reject using parameters used in the type in where bounds
+                        return ControlFlow::Break(());
+                    }
+                    ty::Alias(..) => return ControlFlow::Break(()),
+                    _ => (),
+                }
+                t.super_visit_with(self)
+            }
+        }
+
+        // Pessimistic: if any of the parameters have where bounds
+        // don't allow this impl to be used.
+        match self.kind().skip_binder() {
+            ClauseKind::Trait(trait_predicate) => {
+                // In a `T: Trait`, if the rhs bound does not contain any generic params
+                // or 'static lifetimes, then it cannot transitively cause such requirements,
+                // considering we apply the fully-generic-for-reflection rules to any impls for
+                // that trait, too.
+                if matches!(trait_predicate.self_ty().kind(), ty::Param(_))
+                    && trait_predicate.trait_ref.args[1..]
+                        .iter()
+                        .all(|arg| arg.visit_with(&mut ParamChecker).is_continue())
+                {
+                    return true;
+                }
+            }
+            ClauseKind::RegionOutlives(_)
+            | ClauseKind::TypeOutlives(_)
+            | ClauseKind::Projection(_)
+            | ClauseKind::ConstArgHasType(_, _)
+            | ClauseKind::WellFormed(_)
+            | ClauseKind::ConstEvaluatable(_)
+            | ClauseKind::HostEffect(_)
+            | ClauseKind::UnstableFeature(_) => {}
+        }
+        self.visit_with(&mut ParamChecker).is_continue()
+    }
 }
 
 impl<'tcx> rustc_type_ir::inherent::Clauses<TyCtxt<'tcx>> for ty::Clauses<'tcx> {}

tests/ui/any/try_as_dyn_elaborated_bounds.rs

@@ -17,8 +17,7 @@ impl<T: Trait> Other for Foo<T> {}
 
 const _: () = {
     let foo = Foo(());
-    // TODO
-    assert!(try_as_dyn::<Foo<()>, dyn Other>(&foo).is_some());
+    assert!(try_as_dyn::<Foo<()>, dyn Other>(&foo).is_none());
 };
 
 fn main() {}