op: |&mut MemWriter, &ctxt, &T|) {
for &space in subst::ParamSpace::all().iter() {
mywrite!(w, "[");
- for t in v.get_vec(space).iter() {
+ for t in v.get_slice(space).iter() {
op(w, cx, t);
}
mywrite!(w, "]");
v: &subst::VecPerParamSpace<T>,
f: |&mut Encoder, &T|) {
for &space in subst::ParamSpace::all().iter() {
- ebml_w.emit_from_vec(v.get_vec(space).as_slice(),
+ ebml_w.emit_from_vec(v.get_slice(space),
|ebml_w, n| Ok(f(ebml_w, n))).unwrap();
}
}
vecs: (Vec<T>, Vec<T>, Vec<T>)
}
+impl<T:Clone> VecPerParamSpace<T> {
+ pub fn push_all(&mut self, space: ParamSpace, values: &[T]) {
+ self.get_mut_vec(space).push_all(values);
+ }
+}
+
impl<T> VecPerParamSpace<T> {
pub fn empty() -> VecPerParamSpace<T> {
VecPerParamSpace {
self.get_mut_vec(space).push(value);
}
+ pub fn pop(&mut self, space: ParamSpace) -> Option<T> {
+ self.get_mut_vec(space).pop()
+ }
+
+ pub fn truncate(&mut self, space: ParamSpace, len: uint) {
+ self.get_mut_vec(space).truncate(len)
+ }
+
+ pub fn replace(&mut self, space: ParamSpace, elems: Vec<T>) {
+ *self.get_mut_vec(space) = elems;
+ }
+
pub fn get_self<'a>(&'a self) -> Option<&'a T> {
let v = self.get_vec(SelfSpace);
assert!(v.len() <= 1);
self.get_vec(space).len()
}
- pub fn get_vec<'a>(&'a self, space: ParamSpace) -> &'a Vec<T> {
+ pub fn is_empty_in(&self, space: ParamSpace) -> bool {
+ self.get_vec(space).len() == 0
+ }
+
+ pub fn get_slice<'a>(&'a self, space: ParamSpace) -> &'a [T] {
+ self.get_vec(space).as_slice()
+ }
+
+ fn get_vec<'a>(&'a self, space: ParamSpace) -> &'a Vec<T> {
self.vecs.get(space as uint).unwrap()
}
- pub fn get_mut_vec<'a>(&'a mut self, space: ParamSpace) -> &'a mut Vec<T> {
+ fn get_mut_vec<'a>(&'a mut self, space: ParamSpace) -> &'a mut Vec<T> {
self.vecs.get_mut(space as uint).unwrap()
}
r.iter().chain(s.iter().chain(f.iter()))
}
- pub fn all_vecs(&self, pred: |&Vec<T>| -> bool) -> bool {
- self.vecs.iter().all(pred)
+ pub fn all_vecs(&self, pred: |&[T]| -> bool) -> bool {
+ self.vecs.iter().map(|v|v.as_slice()).all(pred)
}
pub fn all(&self, pred: |&T| -> bool) -> bool {
bcx.tcx(), ¶m_substs, &impl_res);
// Now we pull any vtables for parameters on the actual method.
- param_vtables
- .get_mut_vec(subst::FnSpace)
- .push_all(
- impl_vtables.get_vec(subst::FnSpace).as_slice());
+ param_vtables.push_all(subst::FnSpace,
+ impl_vtables.get_slice(subst::FnSpace));
param_vtables
}
// Maybe check that there is no self type here.
- let tps = substs.types.get_vec(subst::TypeSpace);
+ let tps = substs.types.get_slice(subst::TypeSpace);
if tps.len() > 0 {
output.push_char('<');
}
// Handle other generic parameters
- let actual_types = param_substs.substs.types.get_vec(subst::FnSpace);
+ let actual_types = param_substs.substs.types.get_slice(subst::FnSpace);
for (index, &ast::TyParam{ ident: ident, .. }) in generics.ty_params.iter().enumerate() {
- let actual_type = *actual_types.get(index);
+ let actual_type = actual_types[index];
// Add actual type name to <...> clause of function name
let actual_type_name = compute_debuginfo_type_name(cx,
actual_type,
// avoids creating more than one copy of the enum when one
// of the enum's variants refers to the enum itself.
let repr = adt::represent_type(cx, t);
- let tps = substs.types.get_vec(subst::TypeSpace);
+ let tps = substs.types.get_slice(subst::TypeSpace);
let name = llvm_type_name(cx, an_enum, did, tps);
adt::incomplete_type_of(cx, &*repr, name.as_slice())
}
// in *after* placing it into the type cache. This prevents
// infinite recursion with recursive struct types.
let repr = adt::represent_type(cx, t);
- let tps = substs.types.get_vec(subst::TypeSpace);
+ let tps = substs.types.get_slice(subst::TypeSpace);
let name = llvm_type_name(cx, a_struct, did, tps);
adt::incomplete_type_of(cx, &*repr, name.as_slice())
}
pub fn llvm_type_name(cx: &CrateContext,
what: named_ty,
did: ast::DefId,
- tps: &Vec<ty::t>)
+ tps: &[ty::t])
-> String
{
let name = match what {
}
pub fn has_type_params(&self, space: subst::ParamSpace) -> bool {
- !self.types.get_vec(space).is_empty()
+ !self.types.is_empty_in(space)
}
}
let mut types = VecPerParamSpace::empty();
for &space in subst::ParamSpace::all().iter() {
push_types_from_defs(tcx, &mut types, space,
- generics.types.get_vec(space));
+ generics.types.get_slice(space));
}
// map bound 'a => free 'a
let mut regions = VecPerParamSpace::empty();
for &space in subst::ParamSpace::all().iter() {
push_region_params(&mut regions, space, free_id,
- generics.regions.get_vec(space));
+ generics.regions.get_slice(space));
}
let free_substs = Substs {
let mut bounds = VecPerParamSpace::empty();
for &space in subst::ParamSpace::all().iter() {
push_bounds_from_defs(tcx, &mut bounds, space, &free_substs,
- generics.types.get_vec(space));
+ generics.types.get_slice(space));
}
debug!("construct_parameter_environment: free_id={} \
fn push_region_params(regions: &mut VecPerParamSpace<ty::Region>,
space: subst::ParamSpace,
free_id: ast::NodeId,
- region_params: &Vec<RegionParameterDef>)
+ region_params: &[RegionParameterDef])
{
for r in region_params.iter() {
regions.push(space, ty::free_region_from_def(free_id, r));
fn push_types_from_defs(tcx: &ty::ctxt,
types: &mut subst::VecPerParamSpace<ty::t>,
space: subst::ParamSpace,
- defs: &Vec<TypeParameterDef>) {
+ defs: &[TypeParameterDef]) {
for (i, def) in defs.iter().enumerate() {
let ty = ty::mk_param(tcx, space, i, def.def_id);
types.push(space, ty);
bounds: &mut subst::VecPerParamSpace<ParamBounds>,
space: subst::ParamSpace,
free_substs: &subst::Substs,
- defs: &Vec<TypeParameterDef>) {
+ defs: &[TypeParameterDef]) {
for def in defs.iter() {
let b = (*def.bounds).subst(tcx, free_substs);
bounds.push(space, b);
};
// Convert the type parameters supplied by the user.
- let ty_param_defs = decl_generics.types.get_vec(TypeSpace);
+ let ty_param_defs = decl_generics.types.get_slice(TypeSpace);
let supplied_ty_param_count = path.segments.iter().flat_map(|s| s.types.iter()).count();
let formal_ty_param_count = ty_param_defs.len();
let required_ty_param_count = ty_param_defs.iter()
// The subst we get in has Err as the "Self" type. For an object
// type, we don't put any type into the Self paramspace, so let's
// make a copy of rcvr_substs that has the Self paramspace empty.
- obj_substs.types.get_mut_vec(subst::SelfSpace).pop().unwrap();
+ obj_substs.types.pop(subst::SelfSpace).unwrap();
match method_ty.explicit_self {
ast::SelfStatic => {
let m_regions =
self.fcx.infcx().region_vars_for_defs(
self.span,
- candidate.method_ty.generics.regions.get_vec(subst::FnSpace));
+ candidate.method_ty.generics.regions.get_slice(subst::FnSpace));
let all_substs = candidate.rcvr_substs.clone().with_method(m_types, m_regions);
return;
}
- let it = trait_m.generics.types.get_vec(subst::FnSpace).iter()
- .zip(impl_m.generics.types.get_vec(subst::FnSpace).iter());
+ let it = trait_m.generics.types.get_slice(subst::FnSpace).iter()
+ .zip(impl_m.generics.types.get_slice(subst::FnSpace).iter());
// This code is best explained by example. Consider a trait:
//
let trait_to_skol_substs =
trait_to_impl_substs
.subst(tcx, &impl_to_skol_substs)
- .with_method(skol_tps.get_vec(subst::FnSpace).clone(),
- skol_regions.get_vec(subst::FnSpace).clone());
+ .with_method(Vec::from_slice(skol_tps.get_slice(subst::FnSpace)),
+ Vec::from_slice(skol_regions.get_slice(subst::FnSpace)));
let trait_fty = ty::mk_bare_fn(tcx, trait_m.fty.clone());
let trait_fty = trait_fty.subst(tcx, &trait_to_skol_substs);
let ity = ty::lookup_item_type(tcx, did);
let (n_tps, rps, raw_ty) =
(ity.generics.types.len(subst::TypeSpace),
- ity.generics.regions.get_vec(subst::TypeSpace),
+ ity.generics.regions.get_slice(subst::TypeSpace),
ity.ty);
let rps = vcx.infcx.region_vars_for_defs(span, rps);
// a problem.
for &space in ParamSpace::all().iter() {
adjust_type_parameters(fcx, span, space, type_defs, &mut substs);
- assert_eq!(substs.types.get_vec(space).len(),
- type_defs.get_vec(space).len());
+ assert_eq!(substs.types.len(space), type_defs.len(space));
adjust_region_parameters(fcx, span, space, region_defs, &mut substs);
- assert_eq!(substs.regions().get_vec(space).len(),
- region_defs.get_vec(space).len());
+ assert_eq!(substs.regions().len(space), region_defs.len(space));
}
fcx.write_ty_substs(node_id, polytype.ty, ty::ItemSubsts {
*/
{
- let type_count = type_defs.get_vec(space).len();
- assert_eq!(substs.types.get_vec(space).len(), 0);
+ let type_count = type_defs.len(space);
+ assert_eq!(substs.types.len(space), 0);
for (i, &typ) in segment.types.iter().enumerate() {
let t = fcx.to_ty(&*typ);
if i < type_count {
but found {} parameter(s)",
type_count,
segment.types.len()).as_slice());
- substs.types.get_mut_vec(space).truncate(0);
+ substs.types.truncate(space, 0);
}
}
}
{
- let region_count = region_defs.get_vec(space).len();
- assert_eq!(substs.regions().get_vec(space).len(), 0);
+ let region_count = region_defs.len(space);
+ assert_eq!(substs.regions().len(space), 0);
for (i, lifetime) in segment.lifetimes.iter().enumerate() {
let r = ast_region_to_region(fcx.tcx(), lifetime);
if i < region_count {
expected {} parameter(s) but found {} parameter(s)",
region_count,
segment.lifetimes.len()).as_slice());
- substs.mut_regions().get_mut_vec(space).truncate(0);
+ substs.mut_regions().truncate(space, 0);
}
}
}
defs: &VecPerParamSpace<ty::TypeParameterDef>,
substs: &mut Substs)
{
- let provided_len = substs.types.get_vec(space).len();
- let desired = defs.get_vec(space).as_slice();
+ let provided_len = substs.types.len(space);
+ let desired = defs.get_slice(space);
let required_len = desired.iter()
.take_while(|d| d.default.is_none())
.count();
// Nothing specified at all: supply inference variables for
// everything.
if provided_len == 0 {
- let provided = substs.types.get_mut_vec(space);
- *provided = fcx.infcx().next_ty_vars(desired.len());
+ substs.types.replace(space,
+ fcx.infcx().next_ty_vars(desired.len()));
return;
}
qualifier,
required_len,
provided_len).as_slice());
- let provided = substs.types.get_mut_vec(space);
- *provided = Vec::from_elem(desired.len(), ty::mk_err());
+ substs.types.replace(space,
+ Vec::from_elem(desired.len(), ty::mk_err()));
return;
}
let default = default.subst_spanned(fcx.tcx(), substs, Some(span));
substs.types.push(space, default);
}
- assert_eq!(substs.types.get_vec(space).len(), desired.len());
+ assert_eq!(substs.types.len(space), desired.len());
debug!("Final substs: {}", substs.repr(fcx.tcx()));
}
defs: &VecPerParamSpace<ty::RegionParameterDef>,
substs: &mut Substs)
{
- let provided = substs.mut_regions().get_mut_vec(space);
- let desired = defs.get_vec(space);
+ let provided_len = substs.mut_regions().len(space);
+ let desired = defs.get_slice(space);
// Enforced by `push_explicit_parameters_from_segment_to_substs()`.
- assert!(provided.len() <= desired.len());
+ assert!(provided_len <= desired.len());
// If nothing was provided, just use inference variables.
- if provided.len() == 0 {
- *provided = fcx.infcx().region_vars_for_defs(span, desired);
+ if provided_len == 0 {
+ substs.mut_regions().replace(
+ space,
+ fcx.infcx().region_vars_for_defs(span, desired));
return;
}
// If just the right number were provided, everybody is happy.
- if provided.len() == desired.len() {
+ if provided_len == desired.len() {
return;
}
expected {} parameter(s) \
but found {} parameter(s)",
desired.len(),
- provided.len()).as_slice());
+ provided_len).as_slice());
- *provided = fcx.infcx().region_vars_for_defs(span, desired);
+ substs.mut_regions().replace(
+ space,
+ fcx.infcx().region_vars_for_defs(span, desired));
}
}
*/
let meth_tps: Vec<ty::t> =
- method.generics.types.get_vec(subst::FnSpace)
+ method.generics.types.get_slice(subst::FnSpace)
.iter()
.map(|def| ty::mk_param_from_def(tcx, def))
.collect();
let meth_regions: Vec<ty::Region> =
- method.generics.regions.get_vec(subst::FnSpace)
+ method.generics.regions.get_slice(subst::FnSpace)
.iter()
.map(|def| ty::ReEarlyBound(def.def_id.node, def.space,
def.index, def.name))
// replace the type parameters declared on the trait with those
// from the impl
for &space in [subst::TypeSpace, subst::SelfSpace].iter() {
- *method_generics.types.get_mut_vec(space) =
- impl_poly_type.generics.types.get_vec(space).clone();
- *method_generics.regions.get_mut_vec(space) =
- impl_poly_type.generics.regions.get_vec(space).clone();
+ method_generics.types.replace(
+ space,
+ Vec::from_slice(impl_poly_type.generics.types.get_slice(space)));
+ method_generics.regions.replace(
+ space,
+ Vec::from_slice(impl_poly_type.generics.regions.get_slice(space)));
}
debug!("subst_receiver_types_in_method_ty: method_generics={}",
let mut substs = subst::Substs::empty();
for &space in subst::ParamSpace::all().iter() {
- let a_tps = a_subst.types.get_vec(space);
- let b_tps = b_subst.types.get_vec(space);
- let tps = if_ok!(self.tps(space,
- a_tps.as_slice(),
- b_tps.as_slice()));
-
- let a_regions = a_subst.regions().get_vec(space);
- let b_regions = b_subst.regions().get_vec(space);
- let r_variances = variances.regions.get_vec(space);
+ let a_tps = a_subst.types.get_slice(space);
+ let b_tps = b_subst.types.get_slice(space);
+ let tps = if_ok!(self.tps(space, a_tps, b_tps));
+
+ let a_regions = a_subst.regions().get_slice(space);
+ let b_regions = b_subst.regions().get_slice(space);
+ let r_variances = variances.regions.get_slice(space);
let regions = if_ok!(relate_region_params(self,
item_def_id,
r_variances,
a_regions,
b_regions));
- *substs.types.get_mut_vec(space) = tps;
- *substs.mut_regions().get_mut_vec(space) = regions;
+ substs.types.replace(space, tps);
+ substs.mut_regions().replace(space, regions);
}
return Ok(substs);
fn relate_region_params<C:Combine>(this: &C,
item_def_id: ast::DefId,
- variances: &Vec<ty::Variance>,
- a_rs: &Vec<ty::Region>,
- b_rs: &Vec<ty::Region>)
+ variances: &[ty::Variance],
+ a_rs: &[ty::Region],
+ b_rs: &[ty::Region])
-> cres<Vec<ty::Region>>
{
let tcx = this.infcx().tcx;
assert_eq!(num_region_params, b_rs.len());
let mut rs = vec!();
for i in range(0, num_region_params) {
- let a_r = *a_rs.get(i);
- let b_r = *b_rs.get(i);
- let variance = *variances.get(i);
+ let a_r = a_rs[i];
+ let b_r = b_rs[i];
+ let variance = variances[i];
let r = match variance {
ty::Invariant => {
eq_regions(this, a_r, b_r)
pub fn region_vars_for_defs(&self,
span: Span,
- defs: &Vec<ty::RegionParameterDef>)
+ defs: &[ty::RegionParameterDef])
-> Vec<ty::Region> {
defs.iter()
.map(|d| self.next_region_var(EarlyBoundRegion(span, d.name)))
assert!(generics.regions.len(subst::FnSpace) == 0);
let type_parameter_count = generics.types.len(subst::TypeSpace);
- let region_param_defs = generics.regions.get_vec(subst::TypeSpace);
+ let region_param_defs = generics.regions.get_slice(subst::TypeSpace);
let regions = self.region_vars_for_defs(span, region_param_defs);
let type_parameters = self.next_ty_vars(type_parameter_count);
subst::Substs::new_type(type_parameters, regions)
// All type parameters on enums and structs should be
// in the TypeSpace.
- assert!(generics.types.get_vec(subst::SelfSpace).is_empty());
- assert!(generics.types.get_vec(subst::FnSpace).is_empty());
- assert!(generics.regions.get_vec(subst::SelfSpace).is_empty());
- assert!(generics.regions.get_vec(subst::FnSpace).is_empty());
+ assert!(generics.types.is_empty_in(subst::SelfSpace));
+ assert!(generics.types.is_empty_in(subst::FnSpace));
+ assert!(generics.regions.is_empty_in(subst::SelfSpace));
+ assert!(generics.regions.is_empty_in(subst::FnSpace));
self.add_constraints_from_substs(
def_id,
- generics.types.get_vec(subst::TypeSpace),
- generics.regions.get_vec(subst::TypeSpace),
+ generics.types.get_slice(subst::TypeSpace),
+ generics.regions.get_slice(subst::TypeSpace),
substs,
variance);
}
// Traits DO have a Self type parameter, but it is
// erased from object types.
- assert!(!generics.types.get_vec(subst::SelfSpace).is_empty() &&
- substs.types.get_vec(subst::SelfSpace).is_empty());
+ assert!(!generics.types.is_empty_in(subst::SelfSpace) &&
+ substs.types.is_empty_in(subst::SelfSpace));
// Traits never declare region parameters in the self
// space.
- assert!(generics.regions.get_vec(subst::SelfSpace).is_empty());
+ assert!(generics.regions.is_empty_in(subst::SelfSpace));
// Traits never declare type/region parameters in the
// fn space.
- assert!(generics.types.get_vec(subst::FnSpace).is_empty());
- assert!(generics.regions.get_vec(subst::FnSpace).is_empty());
+ assert!(generics.types.is_empty_in(subst::FnSpace));
+ assert!(generics.regions.is_empty_in(subst::FnSpace));
self.add_constraints_from_substs(
def_id,
- generics.types.get_vec(subst::TypeSpace),
- generics.regions.get_vec(subst::TypeSpace),
+ generics.types.get_slice(subst::TypeSpace),
+ generics.regions.get_slice(subst::TypeSpace),
substs,
variance);
}
/// object, etc) appearing in a context with ambient variance `variance`
fn add_constraints_from_substs(&mut self,
def_id: ast::DefId,
- type_param_defs: &Vec<ty::TypeParameterDef>,
- region_param_defs: &Vec<ty::RegionParameterDef>,
+ type_param_defs: &[ty::TypeParameterDef],
+ region_param_defs: &[ty::RegionParameterDef],
substs: &subst::Substs,
variance: VarianceTermPtr<'a>) {
debug!("add_constraints_from_substs(def_id={:?})", def_id);
}
}
- let tps = substs.types.get_vec(subst::TypeSpace);
- let ty_params = generics.types.get_vec(subst::TypeSpace);
+ let tps = substs.types.get_slice(subst::TypeSpace);
+ let ty_params = generics.types.get_slice(subst::TypeSpace);
let has_defaults = ty_params.last().map_or(false, |def| def.default.is_some());
let num_defaults = if has_defaults && !cx.sess.verbose() {
ty_params.iter().zip(tps.iter()).rev().take_while(|&(def, &actual)| {
}
if cx.sess.verbose() {
- for t in substs.types.get_vec(subst::SelfSpace).iter() {
+ for t in substs.types.get_slice(subst::SelfSpace).iter() {
strs.push(format!("for {}", t.repr(cx)));
}
}
impl<T:Repr> Repr for subst::VecPerParamSpace<T> {
fn repr(&self, tcx: &ctxt) -> String {
format!("[{};{};{}]",
- self.get_vec(subst::TypeSpace).repr(tcx),
- self.get_vec(subst::SelfSpace).repr(tcx),
- self.get_vec(subst::FnSpace).repr(tcx))
+ self.get_slice(subst::TypeSpace).repr(tcx),
+ self.get_slice(subst::SelfSpace).repr(tcx),
+ self.get_slice(subst::FnSpace).repr(tcx))
}
}
}
fn external_path(name: &str, substs: &subst::Substs) -> Path {
- let lifetimes = substs.regions().get_vec(subst::TypeSpace)
+ let lifetimes = substs.regions().get_slice(subst::TypeSpace)
.iter()
.filter_map(|v| v.clean())
.collect();
- let types = substs.types.get_vec(subst::TypeSpace).clean();
+ let types = Vec::from_slice(substs.types.get_slice(subst::TypeSpace));
+ let types = types.clean();
Path {
global: false,
segments: vec
projects / rust.git / commitdiff