pub use self::ParamSpace::*;
pub use self::RegionSubsts::*;
-use middle::ty::{self, Ty, HasTypeFlags, RegionEscape};
-use middle::ty_fold::{self, TypeFoldable, TypeFolder};
+use middle::cstore;
+use middle::def_id::DefId;
+use middle::ty::{self, Ty};
+use middle::ty::fold::{TypeFoldable, TypeFolder};
+use serialize::{Encodable, Encoder, Decodable, Decoder};
use std::fmt;
use std::iter::IntoIterator;
use std::slice::Iter;
-> Substs<'tcx>
{
let Substs { types, regions } = self;
- let types = types.with_vec(FnSpace, m_types);
- let regions = regions.map(|r| r.with_vec(FnSpace, m_regions));
+ let types = types.with_slice(FnSpace, &m_types);
+ let regions = regions.map(|r| r.with_slice(FnSpace, &m_regions));
Substs { types: types, regions: regions }
}
- pub fn method_to_trait(self) -> Substs<'tcx> {
- let Substs { mut types, regions } = self;
+ pub fn with_method_from(self,
+ meth_substs: &Substs<'tcx>)
+ -> Substs<'tcx>
+ {
+ let Substs { types, regions } = self;
+ let types = types.with_slice(FnSpace, meth_substs.types.get_slice(FnSpace));
+ let regions = regions.map(|r| {
+ r.with_slice(FnSpace, meth_substs.regions().get_slice(FnSpace))
+ });
+ Substs { types: types, regions: regions }
+ }
+
+ /// Creates a trait-ref out of this substs, ignoring the FnSpace substs
+ pub fn to_trait_ref(&self, tcx: &ty::ctxt<'tcx>, trait_id: DefId)
+ -> ty::TraitRef<'tcx> {
+ let Substs { mut types, regions } = self.clone();
types.truncate(FnSpace, 0);
let regions = regions.map(|mut r| { r.truncate(FnSpace, 0); r });
- Substs { types: types, regions: regions }
+
+ ty::TraitRef {
+ def_id: trait_id,
+ substs: tcx.mk_substs(Substs { types: types, regions: regions })
+ }
+ }
+}
+
+impl<'tcx> Encodable for Substs<'tcx> {
+
+ fn encode<S: Encoder>(&self, s: &mut S) -> Result<(), S::Error> {
+ cstore::tls::with_encoding_context(s, |ecx, rbml_w| {
+ ecx.encode_substs(rbml_w, self);
+ Ok(())
+ })
+ }
+}
+
+impl<'tcx> Decodable for Substs<'tcx> {
+ fn decode<D: Decoder>(d: &mut D) -> Result<Substs<'tcx>, D::Error> {
+ cstore::tls::with_decoding_context(d, |dcx, rbml_r| {
+ Ok(dcx.decode_substs(rbml_r))
+ })
+ }
+}
+
+impl<'tcx> Decodable for &'tcx Substs<'tcx> {
+ fn decode<D: Decoder>(d: &mut D) -> Result<&'tcx Substs<'tcx>, D::Error> {
+ let substs = cstore::tls::with_decoding_context(d, |dcx, rbml_r| {
+ let substs = dcx.decode_substs(rbml_r);
+ dcx.tcx().mk_substs(substs)
+ });
+
+ Ok(substs)
}
}
}
}
- pub fn params_from_type(types: Vec<T>) -> VecPerParamSpace<T> {
- VecPerParamSpace::empty().with_vec(TypeSpace, types)
- }
-
/// `t` is the type space.
/// `s` is the self space.
/// `f` is the fn space.
}
}
- pub fn with_vec(mut self, space: ParamSpace, vec: Vec<T>)
+ pub fn with_slice(mut self, space: ParamSpace, slice: &[T])
-> VecPerParamSpace<T>
+ where T: Clone
{
assert!(self.is_empty_in(space));
- self.replace(space, vec);
+ for t in slice {
+ self.push(space, t.clone());
+ }
+
self
}
}
self.ty_for_param(p, t)
}
_ => {
- ty_fold::super_fold_ty(self, t)
+ t.super_fold_with(self)
}
};
return ty;
}
- let result = ty_fold::shift_regions(self.tcx(), self.region_binders_passed, &ty);
+ let result = ty::fold::shift_regions(self.tcx(), self.region_binders_passed, &ty);
debug!("shift_regions: shifted result = {:?}", result);
result
}
fn shift_region_through_binders(&self, region: ty::Region) -> ty::Region {
- ty_fold::shift_region(region, self.region_binders_passed)
+ ty::fold::shift_region(region, self.region_binders_passed)
}
}