Remove 'static requirement on try_as_dyn

Author: oli-obk

compiler/rustc_const_eval/src/interpret/intrinsics.rs

@@ -236,7 +236,10 @@ impl<'tcx, M: Machine<'tcx>> InterpCx<'tcx, M> {
                 };
 
                 let (infcx, param_env) =
-                    self.tcx.infer_ctxt().build_with_typing_env(self.typing_env);
+                    self.tcx.infer_ctxt().build_with_typing_env(ty::TypingEnv {
+                        typing_mode: ty::TypingMode::Reflection,
+                        ..self.typing_env
+                    });
 
                 let ocx = ObligationCtxt::new(&infcx);
                 ocx.register_obligations(preds.iter().map(|pred: PolyExistentialPredicate<'_>| {

compiler/rustc_hir/src/hir.rs

@@ -1,6 +1,7 @@
 // ignore-tidy-filelength
 use std::borrow::Cow;
 use std::fmt;
+use std::ops::ControlFlow;
 
 use rustc_abi::ExternAbi;
 use rustc_ast::attr::AttributeExt;
@@ -16,6 +17,7 @@ pub use rustc_ast::{
     MetaItemInner, MetaItemLit, Movability, Mutability, Pinnedness, UnOp,
 };
 use rustc_data_structures::fingerprint::Fingerprint;
+use rustc_data_structures::fx::FxHashSet;
 use rustc_data_structures::sorted_map::SortedMap;
 use rustc_data_structures::tagged_ptr::TaggedRef;
 use rustc_error_messages::{DiagArgValue, IntoDiagArg};
@@ -35,7 +37,7 @@ use crate::attrs::AttributeKind;
 use crate::def::{CtorKind, DefKind, MacroKinds, PerNS, Res};
 use crate::def_id::{DefId, LocalDefIdMap};
 pub(crate) use crate::hir_id::{HirId, ItemLocalId, ItemLocalMap, OwnerId};
-use crate::intravisit::{FnKind, VisitorExt};
+use crate::intravisit::{FnKind, Visitor, VisitorExt};
 use crate::lints::DelayedLints;
 
 #[derive(Debug, Copy, Clone, PartialEq, Eq, HashStable_Generic)]
@@ -4445,6 +4447,70 @@ pub struct Impl<'hir> {
     pub constness: Constness,
 }
 
+impl Impl<'_> {
+    pub fn is_fully_generic_for_reflection(&self) -> bool {
+        #[derive(Default)]
+        struct LifetimeFinder {
+            seen: FxHashSet<LocalDefId>,
+        }
+        impl<'v> Visitor<'v> for LifetimeFinder {
+            type Result = ControlFlow<()>;
+            fn visit_lifetime(&mut self, lifetime: &'v Lifetime) -> Self::Result {
+                match lifetime.kind {
+                    LifetimeKind::Param(def_id) => {
+                        if self.seen.insert(def_id) {
+                            ControlFlow::Continue(())
+                        } else {
+                            ControlFlow::Break(())
+                        }
+                    }
+                    LifetimeKind::ImplicitObjectLifetimeDefault
+                    | LifetimeKind::Error
+                    | LifetimeKind::Infer
+                    | LifetimeKind::Static => ControlFlow::Break(()),
+                }
+            }
+        }
+        let mut ty_lifetimes = LifetimeFinder::default();
+        if ty_lifetimes.visit_ty_unambig(self.self_ty).is_break() {
+            return false;
+        }
+        let ty_lifetimes = ty_lifetimes.seen;
+
+        #[derive(Default)]
+        struct LifetimeChecker {
+            ty_lifetimes: FxHashSet<LocalDefId>,
+        }
+        impl<'v> Visitor<'v> for LifetimeChecker {
+            type Result = ControlFlow<()>;
+            fn visit_lifetime(&mut self, lifetime: &'v Lifetime) -> Self::Result {
+                match lifetime.kind {
+                    LifetimeKind::Param(def_id) => {
+                        if self.ty_lifetimes.contains(&def_id) {
+                            ControlFlow::Break(())
+                        } else {
+                            ControlFlow::Continue(())
+                        }
+                    }
+                    LifetimeKind::ImplicitObjectLifetimeDefault
+                    | LifetimeKind::Error
+                    | LifetimeKind::Infer
+                    | LifetimeKind::Static => ControlFlow::Continue(()),
+                }
+            }
+        }
+
+        let mut checker = LifetimeChecker { ty_lifetimes };
+
+        // Pessimistic: if any of the lifetimes used in the type show up in where bounds
+        // don't allow this impl to be used.
+        self.generics
+            .predicates
+            .iter()
+            .all(|pred| checker.visit_where_predicate(pred).is_continue())
+    }
+}
+
 #[derive(Debug, Clone, Copy, HashStable_Generic)]
 pub struct TraitImplHeader<'hir> {
     pub safety: Safety,

compiler/rustc_hir_analysis/src/collect.rs

@@ -1345,6 +1345,7 @@ fn impl_trait_header(tcx: TyCtxt<'_>, def_id: LocalDefId) -> ty::ImplTraitHeader
         .unwrap_or_else(|| panic!("expected impl trait, found inherent impl on {def_id:?}"));
     let selfty = tcx.type_of(def_id).instantiate_identity();
     let is_rustc_reservation = tcx.has_attr(def_id, sym::rustc_reservation_impl);
+    let is_fully_generic_for_reflection = impl_.is_fully_generic_for_reflection();
 
     check_impl_constness(tcx, impl_.constness, &of_trait.trait_ref);
 
@@ -1355,6 +1356,7 @@ fn impl_trait_header(tcx: TyCtxt<'_>, def_id: LocalDefId) -> ty::ImplTraitHeader
         safety: of_trait.safety,
         polarity: polarity_of_impl(tcx, of_trait, is_rustc_reservation),
         constness: impl_.constness,
+        is_fully_generic_for_reflection,
     }
 }
 

compiler/rustc_infer/src/infer/mod.rs

@@ -1055,6 +1055,7 @@ impl<'tcx> InferCtxt<'tcx> {
             // and post-borrowck analysis mode. We may need to modify its uses
             // to support PostBorrowckAnalysis in the old solver as well.
             TypingMode::Coherence
+            | TypingMode::Reflection
             | TypingMode::PostBorrowckAnalysis { .. }
             | TypingMode::PostAnalysis => false,
         }
@@ -1379,6 +1380,7 @@ impl<'tcx> InferCtxt<'tcx> {
             }
             mode @ (ty::TypingMode::Coherence
             | ty::TypingMode::PostBorrowckAnalysis { .. }
+            | ty::TypingMode::Reflection
             | ty::TypingMode::PostAnalysis) => mode,
         };
         ty::TypingEnv { typing_mode, param_env }

compiler/rustc_infer/src/infer/opaque_types/mod.rs

@@ -276,7 +276,9 @@ impl<'tcx> InferCtxt<'tcx> {
                         .map(|obligation| obligation.as_goal()),
                 );
             }
-            mode @ (ty::TypingMode::PostBorrowckAnalysis { .. } | ty::TypingMode::PostAnalysis) => {
+            mode @ (ty::TypingMode::PostBorrowckAnalysis { .. }
+            | ty::TypingMode::PostAnalysis
+            | ty::TypingMode::Reflection) => {
                 bug!("insert hidden type in {mode:?}")
             }
         }

compiler/rustc_middle/src/ty/context.rs

@@ -689,6 +689,10 @@ impl<'tcx> Interner for TyCtxt<'tcx> {
         self.impl_polarity(impl_def_id)
     }
 
+    fn is_fully_generic_for_reflection(self, impl_def_id: Self::ImplId) -> bool {
+        self.impl_trait_header(impl_def_id).is_fully_generic_for_reflection
+    }
+
     fn trait_is_auto(self, trait_def_id: DefId) -> bool {
         self.trait_is_auto(trait_def_id)
     }

compiler/rustc_middle/src/ty/mod.rs

@@ -262,6 +262,10 @@ pub struct ImplTraitHeader<'tcx> {
     pub polarity: ImplPolarity,
     pub safety: hir::Safety,
     pub constness: hir::Constness,
+    /// Whether all generic parameters of the type are unique unconstrained generic parameters
+    /// of the impl. `Bar<'static>` or `Foo<'a, 'a>` or outlives bounds on the lifetimes cause
+    /// this boolean to be false and `try_as_dyn` to return `None`.
+    pub is_fully_generic_for_reflection: bool,
 }
 
 #[derive(Copy, Clone, PartialEq, Eq, Hash, TyEncodable, TyDecodable, HashStable, Debug)]

compiler/rustc_next_trait_solver/src/solve/assembly/mod.rs

@@ -928,6 +928,7 @@ where
             TypingMode::Coherence => return,
             TypingMode::Analysis { .. }
             | TypingMode::Borrowck { .. }
+            | TypingMode::Reflection
             | TypingMode::PostBorrowckAnalysis { .. }
             | TypingMode::PostAnalysis => {}
         }
@@ -991,6 +992,7 @@ where
             TypingMode::Analysis { .. } => self.opaques_with_sub_unified_hidden_type(self_ty),
             TypingMode::Coherence
             | TypingMode::Borrowck { .. }
+            | TypingMode::Reflection
             | TypingMode::PostBorrowckAnalysis { .. }
             | TypingMode::PostAnalysis => vec![],
         };

compiler/rustc_next_trait_solver/src/solve/effect_goals.rs

@@ -142,6 +142,7 @@ where
                 TypingMode::Coherence => Certainty::AMBIGUOUS,
                 TypingMode::Analysis { .. }
                 | TypingMode::Borrowck { .. }
+                | TypingMode::Reflection
                 | TypingMode::PostBorrowckAnalysis { .. }
                 | TypingMode::PostAnalysis => return Err(NoSolution),
             },

compiler/rustc_next_trait_solver/src/solve/mod.rs

@@ -368,7 +368,7 @@ where
     fn opaque_type_is_rigid(&self, def_id: I::DefId) -> bool {
         match self.typing_mode() {
             // Opaques are never rigid outside of analysis mode.
-            TypingMode::Coherence | TypingMode::PostAnalysis => false,
+            TypingMode::Reflection | TypingMode::Coherence | TypingMode::PostAnalysis => false,
             // During analysis, opaques are rigid unless they may be defined by
             // the current body.
             TypingMode::Analysis { defining_opaque_types_and_generators: non_rigid_opaques }