Rollup merge of #123900 - compiler-errors:nobound, r=lcnr

Stop using `PolyTraitRef` for closure/coroutine predicates already instantiated w placeholders
r? lcnr

Author: compiler-errors

compiler/rustc_hir_typeck/src/fn_ctxt/adjust_fulfillment_errors.rs

@@ -367,7 +367,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
 }),
 ) = error.code
  && let ty::Closure(def_id, _) | ty::Coroutine(def_id, ..) =
- expected_trait_ref.skip_binder().self_ty().kind()
+ expected_trait_ref.self_ty().kind()
  && span.overlaps(self.tcx.def_span(*def_id))
 {
 true

compiler/rustc_infer/src/infer/at.rs

@@ -424,25 +424,7 @@ impl<'tcx> ToTrace<'tcx> for ty::TraitRef<'tcx> {
 ) -> TypeTrace<'tcx>{
 TypeTrace{
 cause: cause.clone(),
-values:PolyTraitRefs(ExpectedFound::new(
- a_is_expected,
- ty::Binder::dummy(a),
- ty::Binder::dummy(b),
-)),
-}
-}
-}
-
-impl<'tcx>ToTrace<'tcx>for ty::PolyTraitRef<'tcx>{
-fnto_trace(
-cause:&ObligationCause<'tcx>,
-a_is_expected:bool,
-a:Self,
-b:Self,
-) -> TypeTrace<'tcx>{
-TypeTrace{
-cause: cause.clone(),
-values:PolyTraitRefs(ExpectedFound::new(a_is_expected, a, b)),
+values:TraitRefs(ExpectedFound::new(a_is_expected, a, b)),
 }
 }
 }

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

@@ -1653,7 +1653,7 @@ impl<'tcx> TypeErrCtxt<'_, 'tcx> {
 .report(diag);
 (false,Mismatch::Fixed("signature"))
 }
-ValuePairs::PolyTraitRefs(_) => (false,Mismatch::Fixed("trait")),
+ValuePairs::TraitRefs(_) => (false,Mismatch::Fixed("trait")),
 ValuePairs::Aliases(infer::ExpectedFound{ expected, .. }) => {
 (false,Mismatch::Fixed(self.tcx.def_descr(expected.def_id)))
 }
@@ -1969,8 +1969,8 @@ impl<'tcx> TypeErrCtxt<'_, 'tcx> {
 self.note_and_explain_type_err(diag, exp_found, cause, span, cause.body_id.to_def_id());
 }
 
-ifletSome(ValuePairs::PolyTraitRefs(exp_found)) = values
- && let ty::Closure(def_id, _) = exp_found.expected.skip_binder().self_ty().kind()
+ifletSome(ValuePairs::TraitRefs(exp_found)) = values
+ && let ty::Closure(def_id, _) = exp_found.expected.self_ty().kind()
  && letSome(def_id) = def_id.as_local()
  && terr.involves_regions()
 {
@@ -2188,7 +2188,7 @@ impl<'tcx> TypeErrCtxt<'_, 'tcx> {
  infer::Aliases(exp_found) => self.expected_found_str(exp_found),
  infer::ExistentialTraitRef(exp_found) => self.expected_found_str(exp_found),
  infer::ExistentialProjection(exp_found) => self.expected_found_str(exp_found),
- infer::PolyTraitRefs(exp_found) => {
+ infer::TraitRefs(exp_found) => {
 let pretty_exp_found = ty::error::ExpectedFound{
 expected: exp_found.expected.print_trait_sugared(),
 found: exp_found.found.print_trait_sugared(),

compiler/rustc_infer/src/infer/error_reporting/nice_region_error/placeholder_error.rs

@@ -195,13 +195,13 @@ impl<'tcx> NiceRegionError<'_, 'tcx> {
 value_pairs:&ValuePairs<'tcx>,
 ) -> Option<Diag<'tcx>>{
 let(expected_args, found_args, trait_def_id) = match value_pairs {
-ValuePairs::PolyTraitRefs(ExpectedFound{ expected, found })
-if expected.def_id() == found.def_id() =>
+ValuePairs::TraitRefs(ExpectedFound{ expected, found })
+if expected.def_id == found.def_id =>
 {
 // It's possible that the placeholders come from a binder
 // outside of this value pair. Use `no_bound_vars` as a
 // simple heuristic for that.
-(expected.no_bound_vars()?.args, found.no_bound_vars()?.args, expected.def_id())
+(expected.args, found.args, expected.def_id)
 }
  _ => returnNone,
 };

compiler/rustc_infer/src/infer/error_reporting/suggest.rs

@@ -599,7 +599,7 @@ impl<'tcx> TypeErrCtxt<'_, 'tcx> {
 &self,
 span:Span,
 hir: hir::Node<'_>,
-exp_found:&ty::error::ExpectedFound<ty::PolyTraitRef<'tcx>>,
+exp_found:&ty::error::ExpectedFound<ty::TraitRef<'tcx>>,
 diag:&mutDiag<'_>,
 ){
 // 0. Extract fn_decl from hir
@@ -614,10 +614,10 @@ impl<'tcx> TypeErrCtxt<'_, 'tcx> {
 
 // 1. Get the args of the closure.
 // 2. Assume exp_found is FnOnce / FnMut / Fn, we can extract function parameters from [1].
-letSome(expected) = exp_found.expected.skip_binder().args.get(1)else{
+letSome(expected) = exp_found.expected.args.get(1)else{
 return;
 };
-letSome(found) = exp_found.found.skip_binder().args.get(1)else{
+letSome(found) = exp_found.found.args.get(1)else{
 return;
 };
 let expected = expected.unpack();

compiler/rustc_infer/src/infer/mod.rs

@@ -403,7 +403,7 @@ pub enum ValuePairs<'tcx> {
 Regions(ExpectedFound<ty::Region<'tcx>>),
 Terms(ExpectedFound<ty::Term<'tcx>>),
 Aliases(ExpectedFound<ty::AliasTy<'tcx>>),
-PolyTraitRefs(ExpectedFound<ty::PolyTraitRef<'tcx>>),
+TraitRefs(ExpectedFound<ty::TraitRef<'tcx>>),
 PolySigs(ExpectedFound<ty::PolyFnSig<'tcx>>),
 ExistentialTraitRef(ExpectedFound<ty::PolyExistentialTraitRef<'tcx>>),
 ExistentialProjection(ExpectedFound<ty::PolyExistentialProjection<'tcx>>),
@@ -1882,15 +1882,15 @@ impl<'tcx> TypeTrace<'tcx> {
 }
 }
 
-pubfnpoly_trait_refs(
+pubfntrait_refs(
 cause:&ObligationCause<'tcx>,
 a_is_expected:bool,
-a: ty::PolyTraitRef<'tcx>,
-b: ty::PolyTraitRef<'tcx>,
+a: ty::TraitRef<'tcx>,
+b: ty::TraitRef<'tcx>,
 ) -> TypeTrace<'tcx>{
 TypeTrace{
 cause: cause.clone(),
-values:PolyTraitRefs(ExpectedFound::new(a_is_expected, a, b)),
+values:TraitRefs(ExpectedFound::new(a_is_expected, a, b)),
 }
 }
 

compiler/rustc_middle/src/traits/mod.rs

@@ -620,11 +620,10 @@ pub enum SelectionError<'tcx> {
 OpaqueTypeAutoTraitLeakageUnknown(DefId),
 }
 
-// FIXME(@lcnr): The `Binder` here should be unnecessary. Just use `TraitRef` instead.
 #[derive(Clone,Debug,TypeVisitable)]
 pubstructSignatureMismatchData<'tcx>{
-pubfound_trait_ref: ty::PolyTraitRef<'tcx>,
-pubexpected_trait_ref: ty::PolyTraitRef<'tcx>,
+pubfound_trait_ref: ty::TraitRef<'tcx>,
+pubexpected_trait_ref: ty::TraitRef<'tcx>,
 pubterr: ty::error::TypeError<'tcx>,
 }
 

compiler/rustc_trait_selection/src/traits/error_reporting/suggestions.rs

@@ -1879,19 +1879,19 @@ impl<'tcx> TypeErrCtxt<'_, 'tcx> {
 &self,
 span:Span,
 found_span:Option<Span>,
-found: ty::PolyTraitRef<'tcx>,
-expected: ty::PolyTraitRef<'tcx>,
+found: ty::TraitRef<'tcx>,
+expected: ty::TraitRef<'tcx>,
 cause:&ObligationCauseCode<'tcx>,
 found_node:Option<Node<'_>>,
 param_env: ty::ParamEnv<'tcx>,
 ) -> Diag<'tcx>{
 pub(crate)fnbuild_fn_sig_ty<'tcx>(
 infcx:&InferCtxt<'tcx>,
-trait_ref: ty::PolyTraitRef<'tcx>,
+trait_ref: ty::TraitRef<'tcx>,
 ) -> Ty<'tcx>{
-let inputs = trait_ref.skip_binder().args.type_at(1);
+let inputs = trait_ref.args.type_at(1);
 let sig = match inputs.kind(){
- ty::Tuple(inputs)if infcx.tcx.is_fn_trait(trait_ref.def_id()) => {
+ ty::Tuple(inputs)if infcx.tcx.is_fn_trait(trait_ref.def_id) => {
  infcx.tcx.mk_fn_sig(
 *inputs,
  infcx.next_ty_var(TypeVariableOrigin{
@@ -1915,10 +1915,10 @@ impl<'tcx> TypeErrCtxt<'_, 'tcx> {
 ),
 };
 
-Ty::new_fn_ptr(infcx.tcx,trait_ref.rebind(sig))
+Ty::new_fn_ptr(infcx.tcx,ty::Binder::dummy(sig))
 }
 
-let argument_kind = match expected.skip_binder().self_ty().kind(){
+let argument_kind = match expected.self_ty().kind(){
  ty::Closure(..) => "closure",
  ty::Coroutine(..) => "coroutine",
  _ => "function",

compiler/rustc_trait_selection/src/traits/error_reporting/type_err_ctxt_ext.rs

@@ -3380,11 +3380,11 @@ impl<'tcx> TypeErrCtxt<'_, 'tcx> {
 fnreport_cyclic_signature_error(
 &self,
 obligation:&PredicateObligation<'tcx>,
-found_trait_ref: ty::Binder<'tcx, ty::TraitRef<'tcx>>,
-expected_trait_ref: ty::Binder<'tcx, ty::TraitRef<'tcx>>,
+found_trait_ref: ty::TraitRef<'tcx>,
+expected_trait_ref: ty::TraitRef<'tcx>,
 terr:TypeError<'tcx>,
 ) -> Diag<'tcx>{
-let self_ty = found_trait_ref.self_ty().skip_binder();
+let self_ty = found_trait_ref.self_ty();
 let(cause, terr) = iflet ty::Closure(def_id, _) = self_ty.kind(){
 (
 ObligationCause::dummy_with_span(self.tcx.def_span(def_id)),
@@ -3394,7 +3394,7 @@ impl<'tcx> TypeErrCtxt<'_, 'tcx> {
 (obligation.cause.clone(), terr)
 };
 self.report_and_explain_type_error(
-TypeTrace::poly_trait_refs(&cause,true, expected_trait_ref, found_trait_ref),
+TypeTrace::trait_refs(&cause,true, expected_trait_ref, found_trait_ref),
  terr,
 )
 }
@@ -3434,17 +3434,14 @@ impl<'tcx> TypeErrCtxt<'_, 'tcx> {
 &self,
 obligation:&PredicateObligation<'tcx>,
 span:Span,
-found_trait_ref: ty::Binder<'tcx, ty::TraitRef<'tcx>>,
-expected_trait_ref: ty::Binder<'tcx, ty::TraitRef<'tcx>>,
+found_trait_ref: ty::TraitRef<'tcx>,
+expected_trait_ref: ty::TraitRef<'tcx>,
 ) -> Result<Diag<'tcx>,ErrorGuaranteed>{
 let found_trait_ref = self.resolve_vars_if_possible(found_trait_ref);
 let expected_trait_ref = self.resolve_vars_if_possible(expected_trait_ref);
 
  expected_trait_ref.self_ty().error_reported()?;
-
-letSome(found_trait_ty) = found_trait_ref.self_ty().no_bound_vars()else{
-self.dcx().bug("bound vars outside binder");
-};
+let found_trait_ty = found_trait_ref.self_ty();
 
 let found_did = match*found_trait_ty.kind(){
  ty::Closure(did, _) | ty::FnDef(did, _) | ty::Coroutine(did, ..) => Some(did),
@@ -3462,15 +3459,15 @@ impl<'tcx> TypeErrCtxt<'_, 'tcx> {
 
 letmut not_tupled = false;
 
-let found = match found_trait_ref.skip_binder().args.type_at(1).kind(){
+let found = match found_trait_ref.args.type_at(1).kind(){
  ty::Tuple(tys) => vec![ArgKind::empty(); tys.len()],
  _ => {
  not_tupled = true;
 vec![ArgKind::empty()]
 }
 };
 
-let expected_ty = expected_trait_ref.skip_binder().args.type_at(1);
+let expected_ty = expected_trait_ref.args.type_at(1);
 let expected = match expected_ty.kind(){
  ty::Tuple(tys) => {
  tys.iter().map(|t| ArgKind::from_expected_ty(t,Some(span))).collect()
@@ -3487,11 +3484,11 @@ impl<'tcx> TypeErrCtxt<'_, 'tcx> {
 // traits manually, but don't make it more confusing when it does
 // happen.
 Ok(
-ifSome(expected_trait_ref.def_id()) != self.tcx.lang_items().coroutine_trait()
+ifSome(expected_trait_ref.def_id) != self.tcx.lang_items().coroutine_trait()
  && not_tupled
 {
 self.report_and_explain_type_error(
-TypeTrace::poly_trait_refs(
+TypeTrace::trait_refs(
 &obligation.cause,
 true,
  expected_trait_ref,

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

@@ -1079,8 +1079,8 @@ impl<'cx, 'tcx> SelectionContext<'cx, 'tcx> {
 })
 .map_err(|terr| {
 SignatureMismatch(Box::new(SignatureMismatchData{
-expected_trait_ref:ty::Binder::dummy(obligation_trait_ref),
-found_trait_ref: ty::Binder::dummy(found_trait_ref),
+expected_trait_ref: obligation_trait_ref,
+ found_trait_ref,
  terr,
 }))
 })