Skip to content

Commit 46b01ab

Browse files
WaffleLapkinWaffleLapkin
committed
Replace tcx.mk_trait_ref with ty::TraitRef::new 
1 parent 2d8c905 commit 46b01ab

File tree

41 files changed

+193
-125
lines changed

Some content is hidden

Large Commits have some content hidden by default. Use the searchbox below for content that may be hidden.

41 files changed

+193
-125
lines changed

‎compiler/rustc_borrowck/src/diagnostics/mod.rs

+1-1
Original file line numberDiff line numberDiff line change
@@ -1111,7 +1111,7 @@ impl<'cx, 'tcx> MirBorrowckCtxt<'cx, 'tcx> {
11111111
});
11121112
}
11131113
if let Some(clone_trait) = tcx.lang_items().clone_trait()
1114-
&& let trait_ref = tcx.mk_trait_ref(clone_trait, [ty])
1114+
&& let trait_ref = ty::TraitRef::new(tcx, clone_trait, [ty])
11151115
&& let o = Obligation::new(
11161116
tcx,
11171117
ObligationCause::dummy(),

‎compiler/rustc_borrowck/src/type_check/mod.rs

+16-9
Original file line numberDiff line numberDiff line change
@@ -538,7 +538,8 @@ impl<'a, 'b, 'tcx> TypeVerifier<'a, 'b, 'tcx> {
538538

539539
if let PlaceContext::NonMutatingUse(NonMutatingUseContext::Copy) = context {
540540
let tcx = self.tcx();
541-
let trait_ref = tcx.at(self.last_span).mk_trait_ref(LangItem::Copy, [place_ty.ty]);
541+
let trait_ref =
542+
ty::TraitRef::from_lang_item(tcx.at(self.last_span), LangItem::Copy, [place_ty.ty]);
542543

543544
// To have a `Copy` operand, the type `T` of the
544545
// value must be `Copy`. Note that we prove that `T: Copy`,
@@ -1237,8 +1238,11 @@ impl<'a, 'tcx> TypeChecker<'a, 'tcx> {
12371238

12381239
self.check_rvalue(body, rv, location);
12391240
if !self.unsized_feature_enabled() {
1240-
let trait_ref =
1241-
tcx.at(self.last_span).mk_trait_ref(LangItem::Sized, [place_ty]);
1241+
let trait_ref = ty::TraitRef::from_lang_item(
1242+
tcx.at(self.last_span),
1243+
LangItem::Sized,
1244+
[place_ty],
1245+
);
12421246
self.prove_trait_ref(
12431247
trait_ref,
12441248
location.to_locations(),
@@ -1810,7 +1814,8 @@ impl<'a, 'tcx> TypeChecker<'a, 'tcx> {
18101814
Operand::Move(place) => {
18111815
// Make sure that repeated elements implement `Copy`.
18121816
let ty = place.ty(body, tcx).ty;
1813-
let trait_ref = tcx.at(span).mk_trait_ref(LangItem::Copy, [ty]);
1817+
let trait_ref =
1818+
ty::TraitRef::from_lang_item(tcx.at(span), LangItem::Copy, [ty]);
18141819

18151820
self.prove_trait_ref(
18161821
trait_ref,
@@ -1823,7 +1828,7 @@ impl<'a, 'tcx> TypeChecker<'a, 'tcx> {
18231828
}
18241829

18251830
&Rvalue::NullaryOp(NullOp::SizeOf | NullOp::AlignOf, ty) => {
1826-
let trait_ref = tcx.at(span).mk_trait_ref(LangItem::Sized, [ty]);
1831+
let trait_ref = ty::TraitRef::from_lang_item(tcx.at(span), LangItem::Sized, [ty]);
18271832

18281833
self.prove_trait_ref(
18291834
trait_ref,
@@ -1835,7 +1840,7 @@ impl<'a, 'tcx> TypeChecker<'a, 'tcx> {
18351840
Rvalue::ShallowInitBox(operand, ty) => {
18361841
self.check_operand(operand, location);
18371842

1838-
let trait_ref = tcx.at(span).mk_trait_ref(LangItem::Sized, [*ty]);
1843+
let trait_ref = ty::TraitRef::from_lang_item(tcx.at(span), LangItem::Sized, [*ty]);
18391844

18401845
self.prove_trait_ref(
18411846
trait_ref,
@@ -1932,9 +1937,11 @@ impl<'a, 'tcx> TypeChecker<'a, 'tcx> {
19321937

19331938
CastKind::Pointer(PointerCast::Unsize) => {
19341939
let &ty = ty;
1935-
let trait_ref = tcx
1936-
.at(span)
1937-
.mk_trait_ref(LangItem::CoerceUnsized, [op.ty(body, tcx), ty]);
1940+
let trait_ref = ty::TraitRef::from_lang_item(
1941+
tcx.at(span),
1942+
LangItem::CoerceUnsized,
1943+
[op.ty(body, tcx), ty],
1944+
);
19381945

19391946
self.prove_trait_ref(
19401947
trait_ref,

‎compiler/rustc_const_eval/src/transform/check_consts/qualifs.rs

+6-2
Original file line numberDiff line numberDiff line change
@@ -157,8 +157,12 @@ impl Qualif for NeedsNonConstDrop {
157157
cx.tcx,
158158
ObligationCause::dummy_with_span(cx.body.span),
159159
cx.param_env,
160-
ty::Binder::dummy(cx.tcx.at(cx.body.span).mk_trait_ref(LangItem::Destruct, [ty]))
161-
.with_constness(ty::BoundConstness::ConstIfConst),
160+
ty::Binder::dummy(ty::TraitRef::from_lang_item(
161+
cx.tcx.at(cx.body.span),
162+
LangItem::Destruct,
163+
[ty],
164+
))
165+
.with_constness(ty::BoundConstness::ConstIfConst),
162166
);
163167

164168
let infcx = cx.tcx.infer_ctxt().build();

‎compiler/rustc_hir_analysis/src/astconv/mod.rs

+2-2
Original file line numberDiff line numberDiff line change
@@ -689,7 +689,7 @@ impl<'o, 'tcx> dyn AstConv<'tcx> + 'o {
689689
let assoc_bindings = self.create_assoc_bindings_for_generic_args(args);
690690

691691
let poly_trait_ref =
692-
ty::Binder::bind_with_vars(tcx.mk_trait_ref(trait_def_id, substs), bound_vars);
692+
ty::Binder::bind_with_vars(ty::TraitRef::new(tcx, trait_def_id, substs), bound_vars);
693693

694694
debug!(?poly_trait_ref, ?assoc_bindings);
695695
bounds.push_trait_bound(tcx, poly_trait_ref, span, constness);
@@ -822,7 +822,7 @@ impl<'o, 'tcx> dyn AstConv<'tcx> + 'o {
822822
if let Some(b) = trait_segment.args().bindings.first() {
823823
prohibit_assoc_ty_binding(self.tcx(), b.span, Some((trait_segment, span)));
824824
}
825-
self.tcx().mk_trait_ref(trait_def_id, substs)
825+
ty::TraitRef::new(self.tcx(), trait_def_id, substs)
826826
}
827827

828828
#[instrument(level = "debug", skip(self, span))]

‎compiler/rustc_hir_analysis/src/autoderef.rs

+1-1
Original file line numberDiff line numberDiff line change
@@ -123,7 +123,7 @@ impl<'a, 'tcx> Autoderef<'a, 'tcx> {
123123
let tcx = self.infcx.tcx;
124124

125125
// <ty as Deref>
126-
let trait_ref = tcx.mk_trait_ref(tcx.lang_items().deref_trait()?, [ty]);
126+
let trait_ref = ty::TraitRef::new(tcx, tcx.lang_items().deref_trait()?, [ty]);
127127

128128
let cause = traits::ObligationCause::misc(self.span, self.body_id);
129129

‎compiler/rustc_hir_analysis/src/bounds.rs

+1-1
Original file line numberDiff line numberDiff line change
@@ -57,7 +57,7 @@ impl<'tcx> Bounds<'tcx> {
5757

5858
pub fn push_sized(&mut self, tcx: TyCtxt<'tcx>, ty: Ty<'tcx>, span: Span) {
5959
let sized_def_id = tcx.require_lang_item(LangItem::Sized, Some(span));
60-
let trait_ref = ty::Binder::dummy(tcx.mk_trait_ref(sized_def_id, [ty]));
60+
let trait_ref = ty::Binder::dummy(ty::TraitRef::new(tcx, sized_def_id, [ty]));
6161
// Preferable to put this obligation first, since we report better errors for sized ambiguity.
6262
self.predicates.insert(0, (trait_ref.without_const().to_predicate(tcx), span));
6363
}

‎compiler/rustc_hir_analysis/src/check/check.rs

+1-1
Original file line numberDiff line numberDiff line change
@@ -538,7 +538,7 @@ fn check_item_type(tcx: TyCtxt<'_>, id: hir::ItemId) {
538538
tcx,
539539
assoc_item,
540540
assoc_item,
541-
tcx.mk_trait_ref(id.owner_id.to_def_id(), trait_substs),
541+
ty::TraitRef::new(tcx, id.owner_id.to_def_id(), trait_substs),
542542
);
543543
}
544544
_ => {}

‎compiler/rustc_hir_analysis/src/check/wfcheck.rs

+1-1
Original file line numberDiff line numberDiff line change
@@ -1784,7 +1784,7 @@ fn receiver_is_implemented<'tcx>(
17841784
receiver_ty: Ty<'tcx>,
17851785
) -> bool {
17861786
let tcx = wfcx.tcx();
1787-
let trait_ref = ty::Binder::dummy(tcx.mk_trait_ref(receiver_trait_def_id, [receiver_ty]));
1787+
let trait_ref = ty::Binder::dummy(ty::TraitRef::new(tcx, receiver_trait_def_id, [receiver_ty]));
17881788

17891789
let obligation = traits::Obligation::new(tcx, cause, wfcx.param_env, trait_ref);
17901790

‎compiler/rustc_hir_analysis/src/coherence/builtin.rs

+8-3
Original file line numberDiff line numberDiff line change
@@ -340,7 +340,8 @@ fn visit_implementation_of_dispatch_from_dyn(tcx: TyCtxt<'_>, impl_did: LocalDef
340340
tcx,
341341
cause.clone(),
342342
param_env,
343-
ty::Binder::dummy(tcx.mk_trait_ref(
343+
ty::Binder::dummy(ty::TraitRef::new(
344+
tcx,
344345
dispatch_from_dyn_trait,
345346
[field.ty(tcx, substs_a), field.ty(tcx, substs_b)],
346347
)),
@@ -579,8 +580,12 @@ pub fn coerce_unsized_info<'tcx>(tcx: TyCtxt<'tcx>, impl_did: LocalDefId) -> Coe
579580
// Register an obligation for `A: Trait<B>`.
580581
let ocx = ObligationCtxt::new(&infcx);
581582
let cause = traits::ObligationCause::misc(span, impl_did);
582-
let obligation =
583-
Obligation::new(tcx, cause, param_env, tcx.mk_trait_ref(trait_def_id, [source, target]));
583+
let obligation = Obligation::new(
584+
tcx,
585+
cause,
586+
param_env,
587+
ty::TraitRef::new(tcx, trait_def_id, [source, target]),
588+
);
584589
ocx.register_obligation(obligation);
585590
let errors = ocx.select_all_or_error();
586591
if !errors.is_empty() {

‎compiler/rustc_hir_typeck/src/coercion.rs

+6-4
Original file line numberDiff line numberDiff line change
@@ -601,7 +601,7 @@ impl<'f, 'tcx> Coerce<'f, 'tcx> {
601601
self.tcx,
602602
cause,
603603
self.fcx.param_env,
604-
self.tcx.mk_trait_ref(coerce_unsized_did, [coerce_source, coerce_target])
604+
ty::TraitRef::new(self.tcx, coerce_unsized_did, [coerce_source, coerce_target])
605605
)];
606606

607607
let mut has_unsized_tuple_coercion = false;
@@ -764,9 +764,11 @@ impl<'f, 'tcx> Coerce<'f, 'tcx> {
764764
self.tcx,
765765
self.cause.clone(),
766766
self.param_env,
767-
ty::Binder::dummy(
768-
self.tcx.at(self.cause.span).mk_trait_ref(hir::LangItem::PointerLike, [a]),
769-
),
767+
ty::Binder::dummy(ty::TraitRef::from_lang_item(
768+
self.tcx.at(self.cause.span),
769+
hir::LangItem::PointerLike,
770+
[a],
771+
)),
770772
));
771773

772774
Ok(InferOk {

‎compiler/rustc_hir_typeck/src/fn_ctxt/adjust_fulfillment_errors.rs

+2-1
Original file line numberDiff line numberDiff line change
@@ -481,7 +481,8 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
481481
// For the purposes of this function, we hope that it is a `struct` type, and that our current `expr` is a literal of
482482
// that struct type.
483483
let impl_trait_self_ref = if self.tcx.is_trait_alias(obligation.impl_or_alias_def_id) {
484-
self.tcx.mk_trait_ref(
484+
ty::TraitRef::new(
485+
self.tcx,
485486
obligation.impl_or_alias_def_id,
486487
ty::InternalSubsts::identity_for_item(self.tcx, obligation.impl_or_alias_def_id),
487488
)

‎compiler/rustc_hir_typeck/src/fn_ctxt/checks.rs

+1-1
Original file line numberDiff line numberDiff line change
@@ -1911,7 +1911,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
19111911
_ => {
19121912
// Look for a user-provided impl of a `Fn` trait, and point to it.
19131913
let new_def_id = self.probe(|_| {
1914-
let trait_ref = self.tcx.mk_trait_ref(
1914+
let trait_ref = ty::TraitRef::new(self.tcx,
19151915
call_kind.to_def_id(self.tcx),
19161916
[
19171917
callee_ty,

‎compiler/rustc_hir_typeck/src/fn_ctxt/suggestions.rs

+2-2
Original file line numberDiff line numberDiff line change
@@ -1096,7 +1096,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
10961096
self.tcx,
10971097
self.misc(expr.span),
10981098
self.param_env,
1099-
ty::Binder::dummy(self.tcx.mk_trait_ref(
1099+
ty::Binder::dummy(ty::TraitRef::new(self.tcx,
11001100
into_def_id,
11011101
[expr_ty, expected_ty]
11021102
)),
@@ -1438,7 +1438,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
14381438
&& !results.expr_adjustments(callee_expr).iter().any(|adj| matches!(adj.kind, ty::adjustment::Adjust::Deref(..)))
14391439
// Check that we're in fact trying to clone into the expected type
14401440
&& self.can_coerce(*pointee_ty, expected_ty)
1441-
&& let trait_ref = ty::Binder::dummy(self.tcx.mk_trait_ref(clone_trait_did, [expected_ty]))
1441+
&& let trait_ref = ty::Binder::dummy(ty::TraitRef::new(self.tcx, clone_trait_did, [expected_ty]))
14421442
// And the expected type doesn't implement `Clone`
14431443
&& !self.predicate_must_hold_considering_regions(&traits::Obligation::new(
14441444
self.tcx,

‎compiler/rustc_hir_typeck/src/method/mod.rs

+1-1
Original file line numberDiff line numberDiff line change
@@ -316,7 +316,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
316316
self.var_for_def(cause.span, param)
317317
});
318318

319-
let trait_ref = self.tcx.mk_trait_ref(trait_def_id, substs);
319+
let trait_ref = ty::TraitRef::new(self.tcx, trait_def_id, substs);
320320

321321
// Construct an obligation
322322
let poly_trait_ref = ty::Binder::dummy(trait_ref);

‎compiler/rustc_hir_typeck/src/method/probe.rs

+1-1
Original file line numberDiff line numberDiff line change
@@ -954,7 +954,7 @@ impl<'a, 'tcx> ProbeContext<'a, 'tcx> {
954954
) {
955955
debug!("assemble_extension_candidates_for_trait(trait_def_id={:?})", trait_def_id);
956956
let trait_substs = self.fresh_item_substs(trait_def_id);
957-
let trait_ref = self.tcx.mk_trait_ref(trait_def_id, trait_substs);
957+
let trait_ref = ty::TraitRef::new(self.tcx, trait_def_id, trait_substs);
958958

959959
if self.tcx.is_trait_alias(trait_def_id) {
960960
// For trait aliases, recursively assume all explicitly named traits are relevant

‎compiler/rustc_hir_typeck/src/method/suggest.rs

+2-1
Original file line numberDiff line numberDiff line change
@@ -72,7 +72,8 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
7272
self.autoderef(span, ty).any(|(ty, _)| {
7373
info!("check deref {:?} impl FnOnce", ty);
7474
self.probe(|_| {
75-
let trait_ref = tcx.mk_trait_ref(
75+
let trait_ref = ty::TraitRef::new(
76+
tcx,
7677
fn_once,
7778
[
7879
ty,

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

+10-5
Original file line numberDiff line numberDiff line change
@@ -261,11 +261,16 @@ impl<'tcx> NiceRegionError<'_, 'tcx> {
261261
(false, None, None, Some(span), String::new())
262262
};
263263

264-
let expected_trait_ref = self
265-
.cx
266-
.resolve_vars_if_possible(self.cx.tcx.mk_trait_ref(trait_def_id, expected_substs));
267-
let actual_trait_ref =
268-
self.cx.resolve_vars_if_possible(self.cx.tcx.mk_trait_ref(trait_def_id, actual_substs));
264+
let expected_trait_ref = self.cx.resolve_vars_if_possible(ty::TraitRef::new(
265+
self.cx.tcx,
266+
trait_def_id,
267+
expected_substs,
268+
));
269+
let actual_trait_ref = self.cx.resolve_vars_if_possible(ty::TraitRef::new(
270+
self.cx.tcx,
271+
trait_def_id,
272+
actual_substs,
273+
));
269274

270275
// Search the expected and actual trait references to see (a)
271276
// whether the sub/sup placeholders appear in them (sometimes

‎compiler/rustc_infer/src/traits/engine.rs

+1-1
Original file line numberDiff line numberDiff line change
@@ -18,7 +18,7 @@ pub trait TraitEngine<'tcx>: 'tcx {
1818
def_id: DefId,
1919
cause: ObligationCause<'tcx>,
2020
) {
21-
let trait_ref = infcx.tcx.mk_trait_ref(def_id, [ty]);
21+
let trait_ref = ty::TraitRef::new(infcx.tcx, def_id, [ty]);
2222
self.register_predicate_obligation(
2323
infcx,
2424
Obligation {

‎compiler/rustc_middle/src/ty/print/mod.rs

+5-2
Original file line numberDiff line numberDiff line change
@@ -169,8 +169,11 @@ pub trait Printer<'tcx>: Sized {
169169
self.path_append(
170170
|cx: Self| {
171171
if trait_qualify_parent {
172-
let trait_ref =
173-
cx.tcx().mk_trait_ref(parent_def_id, parent_substs.iter().copied());
172+
let trait_ref = ty::TraitRef::new(
173+
cx.tcx(),
174+
parent_def_id,
175+
parent_substs.iter().copied(),
176+
);
174177
cx.path_qualified(trait_ref.self_ty(), Some(trait_ref))
175178
} else {
176179
cx.print_def_path(parent_def_id, parent_substs)

‎compiler/rustc_middle/src/ty/relate.rs

+1-1
Original file line numberDiff line numberDiff line change
@@ -315,7 +315,7 @@ impl<'tcx> Relate<'tcx> for ty::TraitRef<'tcx> {
315315
Err(TypeError::Traits(expected_found(relation, a.def_id, b.def_id)))
316316
} else {
317317
let substs = relate_substs(relation, a.substs, b.substs)?;
318-
Ok(relation.tcx().mk_trait_ref(a.def_id, substs))
318+
Ok(ty::TraitRef::new(relation.tcx(), a.def_id, substs))
319319
}
320320
}
321321
}

‎compiler/rustc_middle/src/ty/sty.rs

+13-8
Original file line numberDiff line numberDiff line change
@@ -728,13 +728,13 @@ impl<'tcx> PolyExistentialPredicate<'tcx> {
728728
ExistentialPredicate::AutoTrait(did) => {
729729
let generics = tcx.generics_of(did);
730730
let trait_ref = if generics.params.len() == 1 {
731-
tcx.mk_trait_ref(did, [self_ty])
731+
ty::TraitRef::new(tcx, did, [self_ty])
732732
} else {
733733
// If this is an ill-formed auto trait, then synthesize
734734
// new error substs for the missing generics.
735735
let err_substs =
736736
ty::InternalSubsts::extend_with_error(tcx, did, &[self_ty.into()]);
737-
tcx.mk_trait_ref(did, err_substs)
737+
ty::TraitRef::new(tcx, did, err_substs)
738738
};
739739
self.rebind(trait_ref).without_const().to_predicate(tcx)
740740
}
@@ -850,17 +850,22 @@ impl<'tcx> TraitRef<'tcx> {
850850
substs: SubstsRef<'tcx>,
851851
) -> ty::TraitRef<'tcx> {
852852
let defs = tcx.generics_of(trait_id);
853-
tcx.mk_trait_ref(trait_id, tcx.mk_substs(&substs[..defs.params.len()]))
853+
ty::TraitRef::new(tcx, trait_id, tcx.mk_substs(&substs[..defs.params.len()]))
854854
}
855855

856856
/// Returns a `TraitRef` of the form `P0: Foo<P1..Pn>` where `Pi`
857857
/// are the parameters defined on trait.
858858
pub fn identity(tcx: TyCtxt<'tcx>, def_id: DefId) -> Binder<'tcx, TraitRef<'tcx>> {
859-
ty::Binder::dummy(tcx.mk_trait_ref(def_id, InternalSubsts::identity_for_item(tcx, def_id)))
859+
ty::Binder::dummy(ty::TraitRef::new(
860+
tcx,
861+
def_id,
862+
InternalSubsts::identity_for_item(tcx, def_id),
863+
))
860864
}
861865

862866
pub fn with_self_ty(self, tcx: TyCtxt<'tcx>, self_ty: Ty<'tcx>) -> Self {
863-
tcx.mk_trait_ref(
867+
ty::TraitRef::new(
868+
tcx,
864869
self.def_id,
865870
[self_ty.into()].into_iter().chain(self.substs.iter().skip(1)),
866871
)
@@ -926,7 +931,7 @@ impl<'tcx> ExistentialTraitRef<'tcx> {
926931
// otherwise the escaping vars would be captured by the binder
927932
// debug_assert!(!self_ty.has_escaping_bound_vars());
928933

929-
tcx.mk_trait_ref(self.def_id, [self_ty.into()].into_iter().chain(self.substs.iter()))
934+
ty::TraitRef::new(tcx, self.def_id, [self_ty.into()].into_iter().chain(self.substs.iter()))
930935
}
931936
}
932937

@@ -1245,7 +1250,7 @@ impl<'tcx> AliasTy<'tcx> {
12451250
let trait_def_id = self.trait_def_id(tcx);
12461251
let trait_generics = tcx.generics_of(trait_def_id);
12471252
(
1248-
tcx.mk_trait_ref(trait_def_id, self.substs.truncate_to(tcx, trait_generics)),
1253+
ty::TraitRef::new(tcx, trait_def_id, self.substs.truncate_to(tcx, trait_generics)),
12491254
&self.substs[trait_generics.count()..],
12501255
)
12511256
}
@@ -1259,7 +1264,7 @@ impl<'tcx> AliasTy<'tcx> {
12591264
/// as well.
12601265
pub fn trait_ref(self, tcx: TyCtxt<'tcx>) -> ty::TraitRef<'tcx> {
12611266
let def_id = self.trait_def_id(tcx);
1262-
tcx.mk_trait_ref(def_id, self.substs.truncate_to(tcx, tcx.generics_of(def_id)))
1267+
ty::TraitRef::new(tcx, def_id, self.substs.truncate_to(tcx, tcx.generics_of(def_id)))
12631268
}
12641269

12651270
pub fn self_ty(self) -> Ty<'tcx> {

‎compiler/rustc_mir_build/src/thir/pattern/const_to_pat.rs

+1-1
Original file line numberDiff line numberDiff line change
@@ -191,7 +191,7 @@ impl<'tcx> ConstToPat<'tcx> {
191191
self.tcx(),
192192
ObligationCause::dummy(),
193193
self.param_env,
194-
self.tcx().mk_trait_ref(partial_eq_trait_id, [ty, ty]),
194+
ty::TraitRef::new(self.tcx(), partial_eq_trait_id, [ty, ty]),
195195
);
196196

197197
// FIXME: should this call a `predicate_must_hold` variant instead?

0 commit comments

Comments
 (0)