Rollup merge of #114169 - lcnr:unsize, r=compiler-errors

refactor builtin unsize handling, extend comments

r? `@compiler-errors`

compiler/rustc_middle/src/traits/solve.rs

@@ -57,6 +57,7 @@ pub enum Certainty {
 
 impl Certainty {
  pub const AMBIGUOUS: Certainty = Certainty::Maybe(MaybeCause::Ambiguity);
+ pub const OVERFLOW: Certainty = Certainty::Maybe(MaybeCause::Overflow);
 
  /// Use this function to merge the certainty of multiple nested subgoals.
  ///
@@ -66,7 +67,7 @@ impl Certainty {
  /// success, we merge these two responses. This results in ambiguity.
  ///
  /// If we unify ambiguity with overflow, we return overflow. This doesn't matter
- /// inside of the solver as we distinguish ambiguity from overflow. It does
+ /// inside of the solver as we do not distinguish ambiguity from overflow. It does
  /// however matter for diagnostics. If `T: Foo` resulted in overflow and `T: Bar`
  /// in ambiguity without changing the inference state, we still want to tell the
  /// user that `T: Baz` results in overflow.

compiler/rustc_middle/src/ty/mod.rs

@@ -1359,12 +1359,24 @@ impl<'tcx> ToPredicate<'tcx, Clause<'tcx>> for PolyTraitPredicate<'tcx> {
  }
 }
 
+impl<'tcx> ToPredicate<'tcx> for OutlivesPredicate<ty::Region<'tcx>, ty::Region<'tcx>> {
+ fn to_predicate(self, tcx: TyCtxt<'tcx>) -> Predicate<'tcx> {
+ ty::Binder::dummy(PredicateKind::Clause(ClauseKind::RegionOutlives(self))).to_predicate(tcx)
+ }
+}
+
 impl<'tcx> ToPredicate<'tcx> for PolyRegionOutlivesPredicate<'tcx> {
  fn to_predicate(self, tcx: TyCtxt<'tcx>) -> Predicate<'tcx> {
  self.map_bound(|p| PredicateKind::Clause(ClauseKind::RegionOutlives(p))).to_predicate(tcx)
  }
 }
 
+impl<'tcx> ToPredicate<'tcx> for OutlivesPredicate<Ty<'tcx>, ty::Region<'tcx>> {
+ fn to_predicate(self, tcx: TyCtxt<'tcx>) -> Predicate<'tcx> {
+ ty::Binder::dummy(PredicateKind::Clause(ClauseKind::TypeOutlives(self))).to_predicate(tcx)
+ }
+}
+
 impl<'tcx> ToPredicate<'tcx> for PolyTypeOutlivesPredicate<'tcx> {
  fn to_predicate(self, tcx: TyCtxt<'tcx>) -> Predicate<'tcx> {
  self.map_bound(|p| PredicateKind::Clause(ClauseKind::TypeOutlives(p))).to_predicate(tcx)

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

@@ -7,7 +7,7 @@ use rustc_hir::def_id::DefId;
 use rustc_infer::traits::query::NoSolution;
 use rustc_infer::traits::Reveal;
 use rustc_middle::traits::solve::inspect::CandidateKind;
-use rustc_middle::traits::solve::{CanonicalResponse, Certainty, Goal, MaybeCause, QueryResult};
+use rustc_middle::traits::solve::{CanonicalResponse, Certainty, Goal, QueryResult};
 use rustc_middle::traits::BuiltinImplSource;
 use rustc_middle::ty::fast_reject::{SimplifiedType, TreatParams};
 use rustc_middle::ty::{self, Ty, TyCtxt};
@@ -299,7 +299,7 @@ pub(super) trait GoalKind<'tcx>:
  /// for unsize coercion in hir typeck and because it is difficult to
  /// otherwise recompute this for codegen. This is a bit of a mess but the
  /// easiest way to maintain the existing behavior for now.
- fn consider_builtin_unsize_and_upcast_candidates(
+ fn consider_builtin_unsize_candidates(
  ecx: &mut EvalCtxt<'_, 'tcx>,
  goal: Goal<'tcx, Self>,
  ) -> Vec<(CanonicalResponse<'tcx>, BuiltinImplSource)>;
@@ -402,7 +402,7 @@ impl<'tcx> EvalCtxt<'_, 'tcx> {
  ecx.with_incremented_depth(
  |ecx| {
  let result = ecx.evaluate_added_goals_and_make_canonical_response(
- Certainty::Maybe(MaybeCause::Overflow),
+ Certainty::OVERFLOW,
  )?;
  Ok(vec![Candidate {
  source: CandidateSource::BuiltinImpl(BuiltinImplSource::Misc),
@@ -624,7 +624,7 @@ impl<'tcx> EvalCtxt<'_, 'tcx> {
  // There may be multiple unsize candidates for a trait with several supertraits:
  // `trait Foo: Bar<A> + Bar<B>` and `dyn Foo: Unsize<dyn Bar<_>>`
  if lang_items.unsize_trait() == Some(trait_def_id) {
- for (result, source) in G::consider_builtin_unsize_and_upcast_candidates(self, goal) {
+ for (result, source) in G::consider_builtin_unsize_candidates(self, goal) {
  candidates.push(Candidate { source: CandidateSource::BuiltinImpl(source), result });
  }
  }

compiler/rustc_trait_selection/src/solve/eval_ctxt.rs

@@ -11,8 +11,8 @@ use rustc_infer::traits::ObligationCause;
 use rustc_middle::infer::unify_key::{ConstVariableOrigin, ConstVariableOriginKind};
 use rustc_middle::traits::solve::inspect;
 use rustc_middle::traits::solve::{
- CanonicalInput, CanonicalResponse, Certainty, IsNormalizesToHack, MaybeCause,
- PredefinedOpaques, PredefinedOpaquesData, QueryResult,
+ CanonicalInput, CanonicalResponse, Certainty, IsNormalizesToHack, PredefinedOpaques,
+ PredefinedOpaquesData, QueryResult,
 };
 use rustc_middle::traits::DefiningAnchor;
 use rustc_middle::ty::{
@@ -475,7 +475,7 @@ impl<'a, 'tcx> EvalCtxt<'a, 'tcx> {
  let mut new_goals = NestedGoals::new();
 
  let response = self.repeat_while_none(
- |_| Ok(Certainty::Maybe(MaybeCause::Overflow)),
+ |_| Ok(Certainty::OVERFLOW),
  |this| {
  this.inspect.evaluate_added_goals_loop_start();
 

compiler/rustc_trait_selection/src/solve/eval_ctxt/select.rs

@@ -338,7 +338,7 @@ fn rematch_unsize<'tcx>(
  .into_obligations(),
  );
 
- // Similar to ADTs, require that the rest of the fields are equal.
+ // Similar to ADTs, require that we can unsize the tail.
  nested.push(Obligation::new(
  tcx,
  ObligationCause::dummy(),

compiler/rustc_trait_selection/src/solve/project_goals.rs

@@ -503,7 +503,7 @@ impl<'tcx> assembly::GoalKind<'tcx> for ProjectionPredicate<'tcx> {
  )
  }
 
- fn consider_builtin_unsize_and_upcast_candidates(
+ fn consider_builtin_unsize_candidates(
  _ecx: &mut EvalCtxt<'_, 'tcx>,
  goal: Goal<'tcx, Self>,
  ) -> Vec<(CanonicalResponse<'tcx>, BuiltinImplSource)> {

compiler/rustc_trait_selection/src/solve/search_graph/mod.rs

@@ -9,9 +9,7 @@ use cache::ProvisionalCache;
 use overflow::OverflowData;
 use rustc_index::IndexVec;
 use rustc_middle::dep_graph::DepKind;
-use rustc_middle::traits::solve::{
- CanonicalInput, Certainty, EvaluationCache, MaybeCause, QueryResult,
-};
+use rustc_middle::traits::solve::{CanonicalInput, Certainty, EvaluationCache, QueryResult};
 use rustc_middle::ty::TyCtxt;
 use std::{collections::hash_map::Entry, mem};
 
@@ -146,11 +144,7 @@ impl<'tcx> SearchGraph<'tcx> {
  {
  Err(cache.provisional_result(entry_index))
  } else {
- Err(super::response_no_constraints(
- tcx,
- input,
- Certainty::Maybe(MaybeCause::Overflow),
- ))
+ Err(super::response_no_constraints(tcx, input, Certainty::OVERFLOW))
  }
  }
  }

compiler/rustc_trait_selection/src/solve/search_graph/overflow.rs

@@ -1,6 +1,6 @@
 use rustc_infer::infer::canonical::Canonical;
 use rustc_infer::traits::query::NoSolution;
-use rustc_middle::traits::solve::{Certainty, MaybeCause, QueryResult};
+use rustc_middle::traits::solve::{Certainty, QueryResult};
 use rustc_middle::ty::TyCtxt;
 use rustc_session::Limit;
 
@@ -115,6 +115,6 @@ impl<'tcx> SearchGraph<'tcx> {
  goal: Canonical<'tcx, impl Sized>,
  ) -> QueryResult<'tcx> {
  self.overflow_data.deal_with_overflow();
- response_no_constraints(tcx, goal, Certainty::Maybe(MaybeCause::Overflow))
+ response_no_constraints(tcx, goal, Certainty::OVERFLOW)
  }
 }