Rollup of 9 pull requests

compiler/rustc_hir_analysis/src/check/check.rs

@@ -576,7 +576,6 @@ fn find_and_apply_rpit_args<'tcx>(
  struct Visitor<'tcx> {
  tcx: TyCtxt<'tcx>,
  opaque: DefId,
- function: DefId,
  seen: FxHashSet<DefId>,
  }
  impl<'tcx> ty::TypeVisitor<TyCtxt<'tcx>> for Visitor<'tcx> {
@@ -601,19 +600,6 @@ fn find_and_apply_rpit_args<'tcx>(
  }
  }
  }
- ty::Alias(ty::Projection, alias) => {
- if self.tcx.is_impl_trait_in_trait(alias.def_id)
- && self.tcx.impl_trait_in_trait_parent_fn(alias.def_id) == self.function
- {
- // If we're lowering to associated item, install the opaque type which is just
- // the `type_of` of the trait's associated item. If we're using the old lowering
- // strategy, then just reinterpret the associated type like an opaque :^)
- self.tcx
- .type_of(alias.def_id)
- .instantiate(self.tcx, alias.args)
- .visit_with(self)?;
- }
- }
  ty::Alias(ty::Weak, alias) => {
  self.tcx
  .type_of(alias.def_id)
@@ -627,7 +613,7 @@ fn find_and_apply_rpit_args<'tcx>(
  }
  }
  if let ControlFlow::Break(args) =
- ret.visit_with(&mut Visitor { tcx, function, opaque, seen: Default::default() })
+ ret.visit_with(&mut Visitor { tcx, opaque, seen: Default::default() })
  {
  trace!(?args);
  trace!("expected: {hidden_ty:#?}");

compiler/rustc_hir_analysis/src/check/wfcheck.rs

@@ -246,8 +246,11 @@ fn check_item<'tcx>(tcx: TyCtxt<'tcx>, item: &'tcx hir::Item<'tcx>) {
  // `ForeignItem`s are handled separately.
  hir::ItemKind::ForeignMod { .. } => {}
  hir::ItemKind::TyAlias(hir_ty, ..) => {
- if tcx.type_of(item.owner_id.def_id).skip_binder().has_opaque_types() {
- // Bounds are respected for `type X = impl Trait` and `type X = (impl Trait, Y);`
+ if tcx.features().lazy_type_alias
+ || tcx.type_of(item.owner_id).skip_binder().has_opaque_types()
+ {
+ // Bounds of lazy type aliases and of eager ones that contain opaque types are respected.
+ // E.g: `type X = impl Trait;`, `type X = (impl Trait, Y);`.
  check_item_type(tcx, def_id, hir_ty.span, UnsizedHandling::Allow);
  }
  }

compiler/rustc_hir_analysis/src/collect/item_bounds.rs

@@ -3,7 +3,7 @@ use crate::astconv::{AstConv, PredicateFilter};
 use rustc_hir as hir;
 use rustc_infer::traits::util;
 use rustc_middle::ty::GenericArgs;
-use rustc_middle::ty::{self, Ty, TyCtxt};
+use rustc_middle::ty::{self, Ty, TyCtxt, TypeFoldable, TypeFolder};
 use rustc_span::def_id::{DefId, LocalDefId};
 use rustc_span::Span;
 
@@ -113,14 +113,35 @@ pub(super) fn explicit_item_bounds(
  ..
  }) => associated_type_bounds(tcx, def_id, bounds, *span),
  hir::Node::Item(hir::Item {
- kind: hir::ItemKind::OpaqueTy(hir::OpaqueTy { bounds, .. }),
+ kind: hir::ItemKind::OpaqueTy(hir::OpaqueTy { bounds, in_trait: false, .. }),
  span,
  ..
  }) => {
  let args = GenericArgs::identity_for_item(tcx, def_id);
  let item_ty = Ty::new_opaque(tcx, def_id.to_def_id(), args);
  opaque_type_bounds(tcx, def_id, bounds, item_ty, *span)
  }
+ // Since RPITITs are astconv'd as projections in `ast_ty_to_ty`, when we're asking
+ // for the item bounds of the *opaques* in a trait's default method signature, we
+ // need to map these projections back to opaques.
+ hir::Node::Item(hir::Item {
+ kind: hir::ItemKind::OpaqueTy(hir::OpaqueTy { bounds, in_trait: true, origin, .. }),
+ span,
+ ..
+ }) => {
+ let (hir::OpaqueTyOrigin::FnReturn(fn_def_id)
+ | hir::OpaqueTyOrigin::AsyncFn(fn_def_id)) = *origin
+ else {
+ bug!()
+ };
+ let args = GenericArgs::identity_for_item(tcx, def_id);
+ let item_ty = Ty::new_opaque(tcx, def_id.to_def_id(), args);
+ tcx.arena.alloc_slice(
+ &opaque_type_bounds(tcx, def_id, bounds, item_ty, *span)
+ .to_vec()
+ .fold_with(&mut AssocTyToOpaque { tcx, fn_def_id: fn_def_id.to_def_id() }),
+ )
+ }
  hir::Node::Item(hir::Item { kind: hir::ItemKind::TyAlias(..), .. }) => &[],
  _ => bug!("item_bounds called on {:?}", def_id),
  };
@@ -135,3 +156,26 @@ pub(super) fn item_bounds(
  tcx.mk_clauses_from_iter(util::elaborate(tcx, bounds.iter().map(|&(bound, _span)| bound)))
  })
 }
+
+struct AssocTyToOpaque<'tcx> {
+ tcx: TyCtxt<'tcx>,
+ fn_def_id: DefId,
+}
+
+impl<'tcx> TypeFolder<TyCtxt<'tcx>> for AssocTyToOpaque<'tcx> {
+ fn interner(&self) -> TyCtxt<'tcx> {
+ self.tcx
+ }
+
+ fn fold_ty(&mut self, ty: Ty<'tcx>) -> Ty<'tcx> {
+ if let ty::Alias(ty::Projection, projection_ty) = ty.kind()
+ && let Some(ty::ImplTraitInTraitData::Trait { fn_def_id, .. })
+ = self.tcx.opt_rpitit_info(projection_ty.def_id)
+ && fn_def_id == self.fn_def_id
+ {
+ self.tcx.type_of(projection_ty.def_id).instantiate(self.tcx, projection_ty.args)
+ } else {
+ ty
+ }
+ }
+}

compiler/rustc_hir_typeck/src/_match.rs

@@ -558,18 +558,17 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
  {
  let pred = clause.kind().rebind(match clause.kind().skip_binder() {
  ty::ClauseKind::Trait(trait_pred) => {
- // FIXME(rpitit): This will need to be fixed when we move to associated types
  assert!(matches!(
  *trait_pred.trait_ref.self_ty().kind(),
- ty::Alias(_, ty::AliasTy { def_id, args: alias_args, .. })
+ ty::Alias(ty::Opaque, ty::AliasTy { def_id, args: alias_args, .. })
  if def_id == rpit_def_id && args == alias_args
  ));
  ty::ClauseKind::Trait(trait_pred.with_self_ty(self.tcx, ty))
  }
  ty::ClauseKind::Projection(mut proj_pred) => {
  assert!(matches!(
  *proj_pred.projection_ty.self_ty().kind(),
- ty::Alias(_, ty::AliasTy { def_id, args: alias_args, .. })
+ ty::Alias(ty::Opaque, ty::AliasTy { def_id, args: alias_args, .. })
  if def_id == rpit_def_id && args == alias_args
  ));
  proj_pred = proj_pred.with_self_ty(self.tcx, ty);

compiler/rustc_hir_typeck/src/closure.rs

@@ -723,11 +723,6 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
  .iter_instantiated_copied(self.tcx, args)
  .find_map(|(p, s)| get_future_output(p.as_predicate(), s))?,
  ty::Error(_) => return None,
- ty::Alias(ty::Projection, proj) if self.tcx.is_impl_trait_in_trait(proj.def_id) => self
- .tcx
- .explicit_item_bounds(proj.def_id)
- .iter_instantiated_copied(self.tcx, proj.args)
- .find_map(|(p, s)| get_future_output(p.as_predicate(), s))?,
  _ => span_bug!(
  self.tcx.def_span(expr_def_id),
  "async fn generator return type not an inference variable: {ret_ty}"

compiler/rustc_infer/src/infer/opaque_types.rs

@@ -619,13 +619,6 @@ impl<'tcx> InferCtxt<'tcx> {
  {
  hidden_ty
  }
- // FIXME(RPITIT): This can go away when we move to associated types
- // FIXME(inherent_associated_types): Extend this to support `ty::Inherent`, too.
- ty::Alias(ty::Projection, ty::AliasTy { def_id: def_id2, args: args2, .. })
- if def_id == def_id2 && args == args2 =>
- {
- hidden_ty
- }
  _ => ty,
  },
  lt_op: |lt| lt,

compiler/rustc_lint/src/builtin.rs

@@ -1458,15 +1458,20 @@ impl TypeAliasBounds {
 
 impl<'tcx> LateLintPass<'tcx> for TypeAliasBounds {
  fn check_item(&mut self, cx: &LateContext<'_>, item: &hir::Item<'_>) {
- let hir::ItemKind::TyAlias(ty, type_alias_generics) = &item.kind else { return };
- if cx.tcx.type_of(item.owner_id.def_id).skip_binder().has_opaque_types() {
- // Bounds are respected for `type X = impl Trait` and `type X = (impl Trait, Y);`
+ let hir::ItemKind::TyAlias(hir_ty, type_alias_generics) = &item.kind else { return };
+
+ if cx.tcx.features().lazy_type_alias {
+ // Bounds of lazy type aliases are respected.
  return;
  }
- if cx.tcx.type_of(item.owner_id).skip_binder().has_inherent_projections() {
- // Bounds are respected for `type X = … Type::Inherent …`
+
+ let ty = cx.tcx.type_of(item.owner_id).skip_binder();
+ if ty.has_opaque_types() || ty.has_inherent_projections() {
+ // Bounds of type aliases that contain opaque types or inherent projections are respected.
+ // E.g: `type X = impl Trait;`, `type X = (impl Trait, Y);`, `type X = Type::Inherent;`.
  return;
  }
+
  // There must not be a where clause
  if type_alias_generics.predicates.is_empty() {
  return;
@@ -1491,7 +1496,7 @@ impl<'tcx> LateLintPass<'tcx> for TypeAliasBounds {
  if !where_spans.is_empty() {
  let sub = (!suggested_changing_assoc_types).then(|| {
  suggested_changing_assoc_types = true;
- SuggestChangingAssocTypes { ty }
+ SuggestChangingAssocTypes { ty: hir_ty }
  });
  cx.emit_spanned_lint(
  TYPE_ALIAS_BOUNDS,
@@ -1507,7 +1512,7 @@ impl<'tcx> LateLintPass<'tcx> for TypeAliasBounds {
  let suggestion = BuiltinTypeAliasGenericBoundsSuggestion { suggestions: inline_sugg };
  let sub = (!suggested_changing_assoc_types).then(|| {
  suggested_changing_assoc_types = true;
- SuggestChangingAssocTypes { ty }
+ SuggestChangingAssocTypes { ty: hir_ty }
  });
  cx.emit_spanned_lint(
  TYPE_ALIAS_BOUNDS,

compiler/rustc_lint/src/multiple_supertrait_upcastable.rs

@@ -10,6 +10,7 @@ declare_lint! {
  /// ### Example
  ///
  /// ```rust
+ /// #![feature(multiple_supertrait_upcastable)]
  /// trait A {}
  /// trait B {}
  ///

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)
@@ -2613,19 +2625,6 @@ impl<'tcx> TyCtxt<'tcx> {
  matches!(self.trait_of_item(def_id), Some(trait_id) if self.has_attr(trait_id, sym::const_trait))
  }
 
- pub fn impl_trait_in_trait_parent_fn(self, mut def_id: DefId) -> DefId {
- match self.opt_rpitit_info(def_id) {
- Some(ImplTraitInTraitData::Trait { fn_def_id, .. })
- | Some(ImplTraitInTraitData::Impl { fn_def_id, .. }) => fn_def_id,
- None => {
- while let def_kind = self.def_kind(def_id) && def_kind != DefKind::AssocFn {
- def_id = self.parent(def_id);
- }
- def_id
- }
- }
- }
-
  /// Returns the `DefId` of the item within which the `impl Trait` is declared.
  /// For type-alias-impl-trait this is the `type` alias.
  /// For impl-trait-in-assoc-type this is the assoc type.

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)
  }
 }