nordic-dev.net/rust
nordic-dev.net/rust
2
0
Fork 0
mirror of https://github.com/rust-lang/rust.git synced 2025-01-19 19:23:10 +00:00
Code Issues Packages Projects Releases Wiki Activity

rustc_typeck: cleanup coercion logic that has been obsolete/unused for a while now.

Browse Source
This commit is contained in:
Eduard Burtescu 2015-01-18 11:20:29 +02:00
parent 6a478bdfd2
commit b48c4c8cf4
1 changed files with 7 additions and 119 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

126
src/librustc_typeck/check/coercion.rs
View File

@ -67,8 +67,7 @@ use middle::infer::combine::Combine;
use middle::infer::sub::Sub;
use middle::subst;
use middle::ty::{AutoPtr, AutoDerefRef, AdjustDerefRef, AutoUnsize, AutoUnsafe};
use middle::ty::{mt};
use middle::ty::{self, Ty};
use middle::ty::{self, mt, Ty};
use util::common::indent;
use util::ppaux;
use util::ppaux::Repr;
@ -118,57 +117,15 @@ impl<'f, 'tcx> Coerce<'f, 'tcx> {
// See above for details.
match b.sty {
ty::ty_ptr(mt_b) => {
match mt_b.ty.sty {
ty::ty_str => {
return self.unpack_actual_value(a, |a| {
self.coerce_unsafe_ptr(a, b, ast::MutImmutable)
});
}
ty::ty_trait(..) => {
let result = self.unpack_actual_value(a, |a| {
self.coerce_unsafe_object(a, b, mt_b.mutbl)
});
match result {
Ok(t) => return Ok(t),
Err(..) => {}
}
}
_ => {
return self.unpack_actual_value(a, |a| {
self.coerce_unsafe_ptr(a, b, mt_b.mutbl)
});
}
};
return self.unpack_actual_value(a, |a| {
self.coerce_unsafe_ptr(a, b, mt_b.mutbl)
});
}
ty::ty_rptr(_, mt_b) => {
match mt_b.ty.sty {
ty::ty_str => {
return self.unpack_actual_value(a, |a| {
self.coerce_borrowed_pointer(a, b, ast::MutImmutable)
});
}
ty::ty_trait(..) => {
let result = self.unpack_actual_value(a, |a| {
self.coerce_borrowed_object(a, b, mt_b.mutbl)
});
match result {
Ok(t) => return Ok(t),
Err(..) => {}
}
}
_ => {
return self.unpack_actual_value(a, |a| {
self.coerce_borrowed_pointer(a, b, mt_b.mutbl)
});
}
};
return self.unpack_actual_value(a, |a| {
self.coerce_borrowed_pointer(a, b, mt_b.mutbl)
});
}
_ => {}
@ -210,7 +167,6 @@ impl<'f, 'tcx> Coerce<'f, 'tcx> {
let r_borrow = self.fcx.infcx().next_region_var(coercion);
let inner_ty = match a.sty {
ty::ty_uniq(_) => return Err(ty::terr_mismatch),
ty::ty_rptr(_, mt_a) => {
if !can_coerce_mutbls(mt_a.mutbl, mutbl_b) {
return Err(ty::terr_mutability);
@ -397,74 +353,6 @@ impl<'f, 'tcx> Coerce<'f, 'tcx> {
)
}
fn coerce_borrowed_object(&self,
a: Ty<'tcx>,
b: Ty<'tcx>,
b_mutbl: ast::Mutability) -> CoerceResult<'tcx>
{
let tcx = self.tcx();
debug!("coerce_borrowed_object(a={}, b={}, b_mutbl={:?})",
a.repr(tcx),
b.repr(tcx), b_mutbl);
let coercion = Coercion(self.trace.clone());
let r_a = self.fcx.infcx().next_region_var(coercion);
self.coerce_object(a, b, b_mutbl,
|tr| ty::mk_rptr(tcx, tcx.mk_region(r_a),
ty::mt{ mutbl: b_mutbl, ty: tr }),
|| AutoPtr(r_a, b_mutbl, None))
}
fn coerce_unsafe_object(&self,
a: Ty<'tcx>,
b: Ty<'tcx>,
b_mutbl: ast::Mutability) -> CoerceResult<'tcx>
{
let tcx = self.tcx();
debug!("coerce_unsafe_object(a={}, b={}, b_mutbl={:?})",
a.repr(tcx),
b.repr(tcx), b_mutbl);
self.coerce_object(a, b, b_mutbl,
|tr| ty::mk_ptr(tcx, ty::mt{ mutbl: b_mutbl, ty: tr }),
|| AutoUnsafe(b_mutbl, None))
}
fn coerce_object<F, G>(&self,
a: Ty<'tcx>,
b: Ty<'tcx>,
b_mutbl: ast::Mutability,
mk_ty: F,
mk_adjust: G) -> CoerceResult<'tcx> where
F: FnOnce(Ty<'tcx>) -> Ty<'tcx>,
G: FnOnce() -> ty::AutoRef<'tcx>,
{
let tcx = self.tcx();
match a.sty {
ty::ty_rptr(_, ty::mt{ty, mutbl}) => match ty.sty {
ty::ty_trait(box ty::TyTrait { ref principal, ref bounds }) => {
debug!("mutbl={:?} b_mutbl={:?}", mutbl, b_mutbl);
let tr = ty::mk_trait(tcx, principal.clone(), bounds.clone());
try!(self.subtype(mk_ty(tr), b));
Ok(Some(AdjustDerefRef(AutoDerefRef {
autoderefs: 1,
autoref: Some(mk_adjust())
})))
}
_ => {
self.subtype(a, b)
}
},
_ => {
self.subtype(a, b)
}
}
}
fn coerce_from_fn_item(&self,
a: Ty<'tcx>,
fn_def_id_a: ast::DefId,