Add new typing mode

Author: compiler-errors

compiler/rustc_infer/src/infer/mod.rs

@@ -968,6 +968,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::CheckObjectOverlap
             | TypingMode::PostBorrowckAnalysis { .. }
             | TypingMode::PostAnalysis => false,
         }
@@ -1260,6 +1261,7 @@ impl<'tcx> InferCtxt<'tcx> {
                 TypingMode::non_body_analysis()
             }
             mode @ (ty::TypingMode::Coherence
+            | TypingMode::CheckObjectOverlap
             | ty::TypingMode::PostBorrowckAnalysis { .. }
             | ty::TypingMode::PostAnalysis) => mode,
         };

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

@@ -87,7 +87,9 @@ impl<'tcx> InferCtxt<'tcx> {
         let process = |a: Ty<'tcx>, b: Ty<'tcx>| match *a.kind() {
             ty::Alias(ty::Opaque, ty::AliasTy { def_id, args, .. }) if def_id.is_local() => {
                 let def_id = def_id.expect_local();
-                if let ty::TypingMode::Coherence = self.typing_mode() {
+                if let ty::TypingMode::Coherence | ty::TypingMode::CheckObjectOverlap =
+                    self.typing_mode()
+                {
                     // See comment on `insert_hidden_type` for why this is sufficient in coherence
                     return Some(self.register_hidden_type(
                         OpaqueTypeKey { def_id, args },
@@ -226,7 +228,7 @@ impl<'tcx> InferCtxt<'tcx> {
         // these are the same span, but not in cases like `-> (impl
         // Foo, impl Bar)`.
         match self.typing_mode() {
-            ty::TypingMode::Coherence => {
+            ty::TypingMode::Coherence | ty::TypingMode::CheckObjectOverlap => {
                 // During intercrate we do not define opaque types but instead always
                 // force ambiguity unless the hidden type is known to not implement
                 // our trait.

compiler/rustc_infer/src/infer/relate/generalize.rs

@@ -519,7 +519,10 @@ impl<'tcx> TypeRelation<TyCtxt<'tcx>> for Generalizer<'_, 'tcx> {
                             //
                             // cc trait-system-refactor-initiative#108
                             if self.infcx.next_trait_solver()
-                                && !matches!(self.infcx.typing_mode(), TypingMode::Coherence)
+                                && !matches!(
+                                    self.infcx.typing_mode(),
+                                    TypingMode::Coherence | TypingMode::CheckObjectOverlap
+                                )
                                 && self.in_alias
                             {
                                 inner.type_variables().equate(vid, new_var_id);
@@ -650,7 +653,10 @@ impl<'tcx> TypeRelation<TyCtxt<'tcx>> for Generalizer<'_, 'tcx> {
                             // See the comment for type inference variables
                             // for more details.
                             if self.infcx.next_trait_solver()
-                                && !matches!(self.infcx.typing_mode(), TypingMode::Coherence)
+                                && !matches!(
+                                    self.infcx.typing_mode(),
+                                    TypingMode::Coherence | TypingMode::CheckObjectOverlap
+                                )
                                 && self.in_alias
                             {
                                 variable_table.union(vid, new_var_id);

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

@@ -380,7 +380,7 @@ where
 
         let mut candidates = vec![];
 
-        if let TypingMode::Coherence = self.typing_mode() {
+        if let TypingMode::Coherence | TypingMode::CheckObjectOverlap = self.typing_mode() {
             if let Ok(candidate) = self.consider_coherence_unknowable_candidate(goal) {
                 return vec![candidate];
             }
@@ -831,7 +831,7 @@ where
         candidates: &mut Vec<Candidate<I>>,
     ) {
         match self.typing_mode() {
-            TypingMode::Coherence => return,
+            TypingMode::Coherence | TypingMode::CheckObjectOverlap => return,
             TypingMode::Analysis { .. }
             | TypingMode::Borrowck { .. }
             | TypingMode::PostBorrowckAnalysis { .. }

compiler/rustc_next_trait_solver/src/solve/mod.rs

@@ -339,7 +339,9 @@ 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::Coherence | TypingMode::CheckObjectOverlap | 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 }

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

@@ -240,7 +240,7 @@ where
                         // would be relevant if any of the nested goals refer to the `term`.
                         // This is not the case here and we only prefer adding an ambiguous
                         // nested goal for consistency.
-                        ty::TypingMode::Coherence => {
+                        ty::TypingMode::Coherence | ty::TypingMode::CheckObjectOverlap => {
                             ecx.add_goal(GoalSource::Misc, goal.with(cx, PredicateKind::Ambiguous));
                             return ecx
                                 .evaluate_added_goals_and_make_canonical_response(Certainty::Yes);
@@ -280,7 +280,7 @@ where
                         // would be relevant if any of the nested goals refer to the `term`.
                         // This is not the case here and we only prefer adding an ambiguous
                         // nested goal for consistency.
-                        ty::TypingMode::Coherence => {
+                        ty::TypingMode::Coherence | ty::TypingMode::CheckObjectOverlap => {
                             ecx.add_goal(GoalSource::Misc, goal.with(cx, PredicateKind::Ambiguous));
                             return ecx
                                 .evaluate_added_goals_and_make_canonical_response(Certainty::Yes);

compiler/rustc_next_trait_solver/src/solve/normalizes_to/opaque_types.rs

@@ -23,7 +23,7 @@ where
         let expected = goal.predicate.term.as_type().expect("no such thing as an opaque const");
 
         match self.typing_mode() {
-            TypingMode::Coherence => {
+            TypingMode::Coherence | TypingMode::CheckObjectOverlap => {
                 // An impossible opaque type bound is the only way this goal will fail
                 // e.g. assigning `impl Copy := NotCopy`
                 self.add_item_bounds_for_hidden_type(

compiler/rustc_next_trait_solver/src/solve/search_graph.rs

@@ -58,7 +58,7 @@ where
             // example where this would matter. We likely should change these cycles to `NoSolution`
             // even in coherence once this is a bit more settled.
             PathKind::Inductive => match input.typing_mode {
-                TypingMode::Coherence => {
+                TypingMode::Coherence | TypingMode::CheckObjectOverlap => {
                     response_no_constraints(cx, input, Certainty::overflow(false))
                 }
                 TypingMode::Analysis { .. }

compiler/rustc_next_trait_solver/src/solve/trait_goals.rs

@@ -70,7 +70,7 @@ where
             // In intercrate mode, this is ambiguous. But outside of intercrate,
             // it's not a real impl.
             (ty::ImplPolarity::Reservation, _) => match ecx.typing_mode() {
-                TypingMode::Coherence => Certainty::AMBIGUOUS,
+                TypingMode::Coherence | TypingMode::CheckObjectOverlap => Certainty::AMBIGUOUS,
                 TypingMode::Analysis { .. }
                 | TypingMode::Borrowck { .. }
                 | TypingMode::PostBorrowckAnalysis { .. }
@@ -1257,7 +1257,7 @@ where
         &mut self,
         mut candidates: Vec<Candidate<I>>,
     ) -> Result<(CanonicalResponse<I>, Option<TraitGoalProvenVia>), NoSolution> {
-        if let TypingMode::Coherence = self.typing_mode() {
+        if let TypingMode::Coherence | TypingMode::CheckObjectOverlap = self.typing_mode() {
             let all_candidates: Vec<_> = candidates.into_iter().map(|c| c.result).collect();
             return if let Some(response) = self.try_merge_responses(&all_candidates) {
                 Ok((response, Some(TraitGoalProvenVia::Misc)))
@@ -1360,6 +1360,7 @@ where
                     }
                 }
                 TypingMode::Coherence
+                | TypingMode::CheckObjectOverlap
                 | TypingMode::PostAnalysis
                 | TypingMode::Borrowck { defining_opaque_types: _ }
                 | TypingMode::PostBorrowckAnalysis { defined_opaque_types: _ } => {}

compiler/rustc_trait_selection/src/solve/delegate.rs

@@ -178,6 +178,7 @@ impl<'tcx> rustc_next_trait_solver::delegate::SolverDelegate for SolverDelegate<
             // get a result which isn't correct for all monomorphizations.
             match self.typing_mode() {
                 TypingMode::Coherence
+                | TypingMode::CheckObjectOverlap
                 | TypingMode::Analysis { .. }
                 | TypingMode::Borrowck { .. }
                 | TypingMode::PostBorrowckAnalysis { .. } => false,

compiler/rustc_trait_selection/src/solve/fulfill.rs

@@ -229,6 +229,7 @@ where
                 defining_opaque_types_and_generators
             }
             TypingMode::Coherence
+            | TypingMode::CheckObjectOverlap
             | TypingMode::Borrowck { defining_opaque_types: _ }
             | TypingMode::PostBorrowckAnalysis { defined_opaque_types: _ }
             | TypingMode::PostAnalysis => return Default::default(),

compiler/rustc_trait_selection/src/traits/effects.rs

@@ -24,7 +24,7 @@ pub fn evaluate_host_effect_obligation<'tcx>(
     selcx: &mut SelectionContext<'_, 'tcx>,
     obligation: &HostEffectObligation<'tcx>,
 ) -> Result<ThinVec<PredicateObligation<'tcx>>, EvaluationFailure> {
-    if matches!(selcx.infcx.typing_mode(), TypingMode::Coherence) {
+    if matches!(selcx.infcx.typing_mode(), TypingMode::Coherence | TypingMode::CheckObjectOverlap) {
         span_bug!(
             obligation.cause.span,
             "should not select host obligation in old solver in intercrate mode"

compiler/rustc_trait_selection/src/traits/fulfill.rs

@@ -793,7 +793,11 @@ impl<'a, 'tcx> FulfillProcessor<'a, 'tcx> {
         stalled_on: &mut Vec<TyOrConstInferVar>,
     ) -> ProcessResult<PendingPredicateObligation<'tcx>, FulfillmentErrorCode<'tcx>> {
         let infcx = self.selcx.infcx;
-        if obligation.predicate.is_global() && !matches!(infcx.typing_mode(), TypingMode::Coherence)
+        if obligation.predicate.is_global()
+            && !matches!(
+                infcx.typing_mode(),
+                TypingMode::Coherence | TypingMode::CheckObjectOverlap
+            )
         {
             // no type variables present, can use evaluation for better caching.
             // FIXME: consider caching errors too.
@@ -848,7 +852,11 @@ impl<'a, 'tcx> FulfillProcessor<'a, 'tcx> {
     ) -> ProcessResult<PendingPredicateObligation<'tcx>, FulfillmentErrorCode<'tcx>> {
         let tcx = self.selcx.tcx();
         let infcx = self.selcx.infcx;
-        if obligation.predicate.is_global() && !matches!(infcx.typing_mode(), TypingMode::Coherence)
+        if obligation.predicate.is_global()
+            && !matches!(
+                infcx.typing_mode(),
+                TypingMode::Coherence | TypingMode::CheckObjectOverlap
+            )
         {
             // no type variables present, can use evaluation for better caching.
             // FIXME: consider caching errors too.

compiler/rustc_trait_selection/src/traits/normalize.rs

@@ -135,6 +135,7 @@ pub(super) fn needs_normalization<'tcx, T: TypeVisitable<TyCtxt<'tcx>>>(
     match infcx.typing_mode() {
         // FIXME(#132279): We likely want to reveal opaques during post borrowck analysis
         TypingMode::Coherence
+        | TypingMode::CheckObjectOverlap
         | TypingMode::Analysis { .. }
         | TypingMode::Borrowck { .. }
         | TypingMode::PostBorrowckAnalysis { .. } => flags.remove(ty::TypeFlags::HAS_TY_OPAQUE),
@@ -389,6 +390,7 @@ impl<'a, 'b, 'tcx> TypeFolder<TyCtxt<'tcx>> for AssocTypeNormalizer<'a, 'b, 'tcx
                 match self.selcx.infcx.typing_mode() {
                     // FIXME(#132279): We likely want to reveal opaques during post borrowck analysis
                     TypingMode::Coherence
+                    | TypingMode::CheckObjectOverlap
                     | TypingMode::Analysis { .. }
                     | TypingMode::Borrowck { .. }
                     | TypingMode::PostBorrowckAnalysis { .. } => ty.super_fold_with(self),

compiler/rustc_trait_selection/src/traits/project.rs

@@ -938,6 +938,7 @@ fn assemble_candidates_from_impls<'cx, 'tcx>(
                             // get a result which isn't correct for all monomorphizations.
                             match selcx.infcx.typing_mode() {
                                 TypingMode::Coherence
+                                | TypingMode::CheckObjectOverlap
                                 | TypingMode::Analysis { .. }
                                 | TypingMode::Borrowck { .. }
                                 | TypingMode::PostBorrowckAnalysis { .. } => {

compiler/rustc_trait_selection/src/traits/query/normalize.rs

@@ -215,6 +215,7 @@ impl<'a, 'tcx> FallibleTypeFolder<TyCtxt<'tcx>> for QueryNormalizer<'a, 'tcx> {
                 // Only normalize `impl Trait` outside of type inference, usually in codegen.
                 match self.infcx.typing_mode() {
                     TypingMode::Coherence
+                    | TypingMode::CheckObjectOverlap
                     | TypingMode::Analysis { .. }
                     | TypingMode::Borrowck { .. }
                     | TypingMode::PostBorrowckAnalysis { .. } => ty.try_super_fold_with(self)?,

compiler/rustc_trait_selection/src/traits/select/candidate_assembly.rs

@@ -779,7 +779,9 @@ impl<'cx, 'tcx> SelectionContext<'cx, 'tcx> {
                         //
                         // Note that this is only sound as projection candidates of opaque types
                         // are always applicable for auto traits.
-                    } else if let TypingMode::Coherence = self.infcx.typing_mode() {
+                    } else if let TypingMode::Coherence | TypingMode::CheckObjectOverlap =
+                        self.infcx.typing_mode()
+                    {
                         // We do not emit auto trait candidates for opaque types in coherence.
                         // Doing so can result in weird dependency cycles.
                         candidates.ambiguous = true;

compiler/rustc_trait_selection/src/traits/select/mod.rs

@@ -1004,8 +1004,10 @@ impl<'cx, 'tcx> SelectionContext<'cx, 'tcx> {
         previous_stack: TraitObligationStackList<'o, 'tcx>,
         mut obligation: PolyTraitObligation<'tcx>,
     ) -> Result<EvaluationResult, OverflowError> {
-        if !matches!(self.infcx.typing_mode(), TypingMode::Coherence)
-            && obligation.is_global()
+        if !matches!(
+            self.infcx.typing_mode(),
+            TypingMode::Coherence | TypingMode::CheckObjectOverlap
+        ) && obligation.is_global()
             && obligation.param_env.caller_bounds().iter().all(|bound| bound.has_param())
         {
             // If a param env has no global bounds, global obligations do not
@@ -1449,7 +1451,7 @@ impl<'cx, 'tcx> SelectionContext<'cx, 'tcx> {
     fn is_knowable<'o>(&mut self, stack: &TraitObligationStack<'o, 'tcx>) -> Result<(), Conflict> {
         let obligation = &stack.obligation;
         match self.infcx.typing_mode() {
-            TypingMode::Coherence => {}
+            TypingMode::Coherence | TypingMode::CheckObjectOverlap => {}
             TypingMode::Analysis { .. }
             | TypingMode::Borrowck { .. }
             | TypingMode::PostBorrowckAnalysis { .. }
@@ -1488,7 +1490,7 @@ impl<'cx, 'tcx> SelectionContext<'cx, 'tcx> {
             // the master cache. Since coherence executes pretty quickly,
             // it's not worth going to more trouble to increase the
             // hit-rate, I don't think.
-            TypingMode::Coherence => false,
+            TypingMode::Coherence | TypingMode::CheckObjectOverlap => false,
             // Avoid using the global cache when we're defining opaque types
             // as their hidden type may impact the result of candidate selection.
             //
@@ -2509,7 +2511,10 @@ impl<'tcx> SelectionContext<'_, 'tcx> {
         nested_obligations.extend(obligations);
 
         if impl_trait_header.polarity == ty::ImplPolarity::Reservation
-            && !matches!(self.infcx.typing_mode(), TypingMode::Coherence)
+            && !matches!(
+                self.infcx.typing_mode(),
+                TypingMode::Coherence | TypingMode::CheckObjectOverlap
+            )
         {
             debug!("reservation impls only apply in intercrate mode");
             return Err(());

compiler/rustc_ty_utils/src/instance.rs

@@ -156,6 +156,7 @@ fn resolve_associated_item<'tcx>(
                 // get a result which isn't correct for all monomorphizations.
                 match typing_env.typing_mode {
                     ty::TypingMode::Coherence
+                    | ty::TypingMode::CheckObjectOverlap
                     | ty::TypingMode::Analysis { .. }
                     | ty::TypingMode::Borrowck { .. }
                     | ty::TypingMode::PostBorrowckAnalysis { .. } => false,

compiler/rustc_type_ir/src/infer_ctxt.rs

@@ -67,21 +67,27 @@ pub enum TypingMode<I: Interner> {
     ///     let x: <() as Assoc>::Output = true;
     /// }
     /// ```
-    Analysis { defining_opaque_types_and_generators: I::LocalDefIds },
+    Analysis {
+        defining_opaque_types_and_generators: I::LocalDefIds,
+    },
     /// The behavior during MIR borrowck is identical to `TypingMode::Analysis`
     /// except that the initial value for opaque types is the type computed during
     /// HIR typeck with unique unconstrained region inference variables.
     ///
     /// This is currently only used with by the new solver as it results in new
     /// non-universal defining uses of opaque types, which is a breaking change.
     /// See tests/ui/impl-trait/non-defining-use/as-projection-term.rs.
-    Borrowck { defining_opaque_types: I::LocalDefIds },
+    Borrowck {
+        defining_opaque_types: I::LocalDefIds,
+    },
     /// Any analysis after borrowck for a given body should be able to use all the
     /// hidden types defined by borrowck, without being able to define any new ones.
     ///
     /// This is currently only used by the new solver, but should be implemented in
     /// the old solver as well.
-    PostBorrowckAnalysis { defined_opaque_types: I::LocalDefIds },
+    PostBorrowckAnalysis {
+        defined_opaque_types: I::LocalDefIds,
+    },
     /// After analysis, mostly during codegen and MIR optimizations, we're able to
     /// reveal all opaque types. As the concrete type should *never* be observable
     /// directly by the user, this should not be used by checks which may expose
@@ -91,6 +97,11 @@ pub enum TypingMode<I: Interner> {
     /// always run in `PostAnalysis` mode, even when used during analysis. This exposes
     /// some information about the underlying type to users, but not the type itself.
     PostAnalysis,
+
+    // Hack modes:
+
+    // TODUwU:
+    CheckObjectOverlap,
 }
 
 impl<I: Interner> TypingMode<I> {

compiler/rustc_type_ir/src/relate/combine.rs

@@ -132,7 +132,7 @@ where
                 // equal to any other type. This is an
                 // extremely heavy hammer, but can be relaxed in a forwards-compatible
                 // way later.
-                TypingMode::Coherence => {
+                TypingMode::Coherence | TypingMode::CheckObjectOverlap => {
                     relation.register_predicates([ty::Binder::dummy(ty::PredicateKind::Ambiguous)]);
                     Ok(a)
                 }
@@ -143,6 +143,15 @@ where
             }
         }
 
+        (ty::Dynamic(a_data, _, a_kind), ty::Dynamic(b_data, _, b_kind))
+            if a_data.principal_def_id() == b_data.principal_def_id()
+                && a_kind == b_kind
+                && matches!(infcx.typing_mode(), TypingMode::CheckObjectOverlap) =>
+        {
+            relation.register_predicates([ty::Binder::dummy(ty::PredicateKind::Ambiguous)]);
+            Ok(a)
+        }
+
         _ => structurally_relate_tys(relation, a, b),
     }
 }