Allow trivial bounds on impls

Author: oli-obk

compiler/rustc_middle/src/ty/generics.rs

@@ -426,14 +426,15 @@ impl<'tcx> GenericPredicates<'tcx> {
             type Result = ControlFlow<()>;
             fn visit_region(&mut self, r: Region<'tcx>) -> Self::Result {
                 match r.kind() {
-                    RegionKind::ReEarlyParam(_param) => ControlFlow::Break(()),
-                    RegionKind::ReBound(..)
-                    | RegionKind::ReLateParam(_)
+                    RegionKind::ReEarlyParam(_)
                     | RegionKind::ReStatic
                     | RegionKind::ReVar(_)
                     | RegionKind::RePlaceholder(_)
                     | RegionKind::ReErased
-                    | RegionKind::ReError(_) => ControlFlow::Continue(()),
+                    | RegionKind::ReError(_) => ControlFlow::Break(()),
+                    RegionKind::ReBound(..) | RegionKind::ReLateParam(_) => {
+                        ControlFlow::Continue(())
+                    }
                 }
             }
 
@@ -454,10 +455,18 @@ impl<'tcx> GenericPredicates<'tcx> {
         // don't allow this impl to be used.
         self.predicates.iter().all(|(clause, _)| {
             match clause.kind().skip_binder() {
-                ClauseKind::Trait(_trait_predicate) => {
-                    // FIXME(try_as_dyn): allow trait bounds that do not mention lifetimes.
-                    // These bounds themselves are fine, as their impls either are fine or
-                    // rejected by this very check when encountered.
+                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(_)

compiler/rustc_next_trait_solver/src/solve/trait_goals.rs

@@ -2,14 +2,14 @@
 
 use rustc_type_ir::data_structures::IndexSet;
 use rustc_type_ir::fast_reject::DeepRejectCtxt;
-use rustc_type_ir::{ExistentialPredicate, GenericArgKind, inherent::*};
+use rustc_type_ir::inherent::*;
 use rustc_type_ir::lang_items::SolverTraitLangItem;
 use rustc_type_ir::solve::{
     AliasBoundKind, CandidatePreferenceMode, CanonicalResponse, SizedTraitKind,
 };
 use rustc_type_ir::{
-    self as ty, Interner, Movability, PredicatePolarity, TraitPredicate, TraitRef,
-    TypeVisitableExt as _, TypingMode, Upcast as _, elaborate,
+    self as ty, ExistentialPredicate, GenericArgKind, Interner, Movability, PredicatePolarity,
+    TraitPredicate, TraitRef, TypeVisitableExt as _, TypingMode, Upcast as _, elaborate,
 };
 use tracing::{debug, instrument, trace};
 

library/core/src/any.rs

@@ -910,7 +910,7 @@ pub const fn type_name_of_val<T: ?Sized>(_val: &T) -> &'static str {
 /// Trait that is automatically implemented for all `dyn Trait<'b, C> + 'a`
 /// * without assoc type bounds,
 /// * adds `T: 'a + 'b` requirements, and
-/// * `C: 'static` requirements.
+/// * `C: 'static` requirements on all params of the dyn trait.
 ///
 /// This is required for `try_as_dyn` to be able to soundly convert non-static
 /// types to `dyn Trait`.

tests/ui/any/try_as_dyn_generic_impl.rs

@@ -9,15 +9,15 @@ impl<T> Trait for Thing<T> {}
 
 const _: () = {
     let thing = Thing(1);
-    assert!(try_as_dyn::<_, dyn Trait>(&thing).is_none());
+    assert!(try_as_dyn::<_, dyn Trait>(&thing).is_some());
 };
 
 struct Thing2<T>(T);
 impl<T: std::fmt::Debug> Trait for Thing2<T> {}
 
 const _: () = {
     let thing = Thing2(1);
-    assert!(try_as_dyn::<_, dyn Trait>(&thing).is_none());
+    assert!(try_as_dyn::<_, dyn Trait>(&thing).is_some());
 };
 
 trait Trait2 {}