ty::RawPtr(mt_b) => {
return self.coerce_unsafe_ptr(a, b, mt_b.mutbl);
}
-
- ty::Ref(r_b, ty, mutbl) => {
- let mt_b = ty::TypeAndMut { ty, mutbl };
- return self.coerce_borrowed_pointer(a, b, r_b, mt_b);
+ ty::Ref(r_b, _, mutbl_b) => {
+ return self.coerce_borrowed_pointer(a, b, r_b, mutbl_b);
}
-
_ => {}
}
a: Ty<'tcx>,
b: Ty<'tcx>,
r_b: ty::Region<'tcx>,
- mt_b: TypeAndMut<'tcx>,
+ mutbl_b: hir::Mutability,
) -> CoerceResult<'tcx> {
debug!("coerce_borrowed_pointer(a={:?}, b={:?})", a, b);
let (r_a, mt_a) = match a.kind {
ty::Ref(r_a, ty, mutbl) => {
let mt_a = ty::TypeAndMut { ty, mutbl };
- coerce_mutbls(mt_a.mutbl, mt_b.mutbl)?;
+ coerce_mutbls(mt_a.mutbl, mutbl_b)?;
(r_a, mt_a)
}
_ => return self.unify_and(a, b, identity),
r_a // [3] above
} else {
if r_borrow_var.is_none() {
- // create var lazilly, at most once
+ // create var lazily, at most once
let coercion = Coercion(span);
let r = self.next_region_var(coercion);
r_borrow_var = Some(r); // [4] above
r,
TypeAndMut {
ty: referent_ty,
- mutbl: mt_b.mutbl, // [1] above
+ mutbl: mutbl_b, // [1] above
},
);
match self.unify(derefd_ty_a, b) {
// `self.x` both have `&mut `type would be a move of
// `self.x`, but we auto-coerce it to `foo(&mut *self.x)`,
// which is a borrow.
- assert_eq!(mt_b.mutbl, hir::Mutability::Not); // can only coerce &T -> &U
+ assert_eq!(mutbl_b, hir::Mutability::Not); // can only coerce &T -> &U
return success(vec![], ty, obligations);
}
- let needs = Needs::maybe_mut_place(mt_b.mutbl);
+ let needs = Needs::maybe_mut_place(mutbl_b);
let InferOk { value: mut adjustments, obligations: o } =
autoderef.adjust_steps_as_infer_ok(self, needs);
obligations.extend(o);
ty::Ref(r_borrow, _, _) => r_borrow,
_ => span_bug!(span, "expected a ref type, got {:?}", ty),
};
- let mutbl = match mt_b.mutbl {
+ let mutbl = match mutbl_b {
hir::Mutability::Not => AutoBorrowMutability::Not,
hir::Mutability::Mut => {
AutoBorrowMutability::Mut { allow_two_phase_borrow: self.allow_two_phase }