match next(st) {
'e' => ty::ErasedRegions,
'n' => {
- let mut regions = opt_vec::Empty;
+ let mut regions = vec!();
while peek(st) != '.' {
let r = parse_region(st, |x,y| conv(x,y));
regions.push(r);
}
assert_eq!(next(st), '.');
- ty::NonerasedRegions(regions)
+ ty::NonerasedRegions(opt_vec::from(regions))
}
_ => fail!("parse_bound_region: bad input")
}
use syntax::ast;
use syntax::ast_util;
use syntax::codemap::Span;
-use syntax::opt_vec::OptVec;
-use syntax::opt_vec;
use util::ppaux::Repr;
pub struct MoveData {
fn existing_base_paths(&self,
lp: @LoanPath)
- -> OptVec<MovePathIndex> {
- let mut result = opt_vec::Empty;
+ -> Vec<MovePathIndex> {
+ let mut result = vec!();
self.add_existing_base_paths(lp, &mut result);
result
}
fn add_existing_base_paths(&self,
lp: @LoanPath,
- result: &mut OptVec<MovePathIndex>) {
+ result: &mut Vec<MovePathIndex>) {
/*!
* Adds any existing move path indices for `lp` and any base
* paths of `lp` to `result`, but does not add new move paths
use middle::ty;
use syntax::ast;
use syntax::ast_util;
-use syntax::opt_vec;
use util::nodemap::NodeMap;
struct CFGBuilder<'a> {
fn add_contained_edge(&mut self,
source: CFGIndex,
target: CFGIndex) {
- let data = CFGEdgeData {exiting_scopes: opt_vec::Empty};
+ let data = CFGEdgeData {exiting_scopes: vec!() };
self.graph.add_edge(source, target, data);
}
from_index: CFGIndex,
to_loop: LoopScope,
to_index: CFGIndex) {
- let mut data = CFGEdgeData {exiting_scopes: opt_vec::Empty};
+ let mut data = CFGEdgeData {exiting_scopes: vec!() };
let mut scope_id = from_expr.id;
while scope_id != to_loop.loop_id {
+
data.exiting_scopes.push(scope_id);
scope_id = self.tcx.region_maps.encl_scope(scope_id);
}
use middle::ty;
use middle::typeck;
use syntax::ast;
-use syntax::opt_vec::OptVec;
use util::nodemap::NodeMap;
mod construct;
}
pub struct CFGEdgeData {
- exiting_scopes:
OptVec<ast::NodeId>
+ exiting_scopes: Vec<ast::NodeId>
}
pub type CFGIndex = graph::NodeIndex;
use util::nodemap::NodeMap;
use syntax::ast;
use syntax::codemap::Span;
-use syntax::opt_vec;
use syntax::opt_vec::OptVec;
use syntax::parse::token::special_idents;
use syntax::parse::token;
.collect()
}
-pub fn free_lifetimes(ty_params: &OptVec<ast::TyParam>) ->
OptVec<ast::Name> {
+pub fn free_lifetimes(ty_params: &OptVec<ast::TyParam>) -> Vec<ast::Name> {
/*!
* Gathers up and returns the names of any lifetimes that appear
* free in `ty_params`. Of course, right now, all lifetimes appear
* declarations; just being forwards compatible with future extensions.
*/
- let mut collector = FreeLifetimeCollector { names: opt_vec::Empty };
+ let mut collector = FreeLifetimeCollector { names: vec!() };
for ty_param in ty_params.iter() {
visit::walk_ty_param_bounds(&mut collector, &ty_param.bounds, ());
}
return collector.names;
struct FreeLifetimeCollector {
- names:
OptVec<ast::Name>,
+ names: Vec<ast::Name>,
}
impl Visitor<()> for FreeLifetimeCollector {
use middle::trans::type_::Type;
use middle::ty;
use syntax::ast;
-use syntax::opt_vec;
-use syntax::opt_vec::OptVec;
use util::ppaux::Repr;
pub struct CleanupScope<'a> {
kind: CleanupScopeKind<'a>,
// Cleanups to run upon scope exit.
- cleanups: OptVec<~Cleanup>,
+ cleanups: Vec<~Cleanup>,
- cached_early_exits: OptVec<CachedEarlyExit>,
+ cached_early_exits: Vec<CachedEarlyExit>,
cached_landing_pad: Option<BasicBlockRef>,
}
assert!(orig_scopes_len > 0);
// Remove any scopes that do not have cleanups on failure:
- let mut popped_scopes = opt_vec::Empty;
+ let mut popped_scopes = vec!();
while !self.top_scope(|s| s.needs_invoke()) {
debug!("top scope does not need invoke");
popped_scopes.push(self.pop_scope());
let orig_scopes_len = self.scopes_len();
let mut prev_llbb;
- let mut popped_scopes = opt_vec::Empty;
+ let mut popped_scopes = vec!();
// First we pop off all the cleanup stacks that are
// traversed until the exit is reached, pushing them
fn new(kind: CleanupScopeKind<'a>) -> CleanupScope<'a> {
CleanupScope {
kind: kind,
- cleanups: opt_vec::Empty,
- cached_early_exits: opt_vec::Empty,
+ cleanups: vec!(),
+ cached_early_exits: vec!(),
cached_landing_pad: None,
}
}
fn clear_cached_exits(&mut self) {
- self.cached_early_exits = opt_vec::Empty;
+ self.cached_early_exits = vec!();
self.cached_landing_pad = None;
}
// map bound 'a => free 'a
let region_params = {
- fn push_region_params(accum: OptVec<ty::Region>,
+ fn push_region_params(mut accum: Vec<ty::Region>,
free_id: ast::NodeId,
region_params: &[RegionParameterDef])
- -> OptVec<ty::Region> {
- let mut accum = accum;
+ -> Vec<ty::Region> {
for r in region_params.iter() {
accum.push(
ty::ReFree(ty::FreeRegion {
accum
}
- let t = push_region_params(opt_vec::Empty, free_id, item_region_params);
+ let t = push_region_params(vec!(), free_id, item_region_params);
push_region_params(t, free_id, method_region_params)
};
let free_substs = substs {
self_ty: self_ty,
tps: type_params,
- regions: ty::NonerasedRegions(region_params)
+ regions: ty::NonerasedRegions(opt_vec::from(region_params))
};
//
use syntax::ast;
use syntax::codemap::Span;
use syntax::parse::token;
+use syntax::opt_vec;
#[deriving(Eq)]
pub enum CheckTraitsFlag {
// Determine values for the early-bound lifetime parameters.
// FIXME -- permit users to manually specify lifetimes
- let mut all_regions = match candidate.rcvr_substs.regions {
- NonerasedRegions(ref v) => v.clone(),
+ let mut all_regions: Vec<Region> = match candidate.rcvr_substs.regions {
+ NonerasedRegions(ref v) => v.iter().map(|r| r.clone()).collect(),
ErasedRegions => tcx.sess.span_bug(self.span, "ErasedRegions")
};
let m_regions =
let all_substs = substs {
tps: vec::append(candidate.rcvr_substs.tps.clone(),
m_substs.as_slice()),
- regions: NonerasedRegions(all_regions),
+ regions: NonerasedRegions(opt_vec::from(all_regions)),
self_ty: candidate.rcvr_substs.self_ty,
};
assert_eq!(num_region_params, a_rs.len());
assert_eq!(num_region_params, b_rs.len());
- let mut rs = opt_vec::Empty;
+ 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);
};
rs.push(if_ok!(r));
}
- Ok(ty::NonerasedRegions(rs))
+ Ok(ty::NonerasedRegions(opt_vec::from(rs)))
}
}
}
use syntax::ast_map;
use syntax::ast_util;
use syntax::ast_util::name_to_dummy_lifetime;
-use syntax::opt_vec;
-use syntax::opt_vec::OptVec;
use syntax::parse::token;
use syntax::print::pprust;
use util::ppaux::UserString;
pub trait ErrorReporting {
fn report_region_errors(&self,
- errors: &OptVec<RegionResolutionError>);
+ errors: &Vec<RegionResolutionError>);
- fn process_errors(&self, errors: &OptVec<RegionResolutionError>)
- -> OptVec<RegionResolutionError>;
+ fn process_errors(&self, errors: &Vec<RegionResolutionError>)
+ -> Vec<RegionResolutionError>;
fn report_type_error(&self, trace: TypeTrace, terr: &ty::type_err);
impl<'a> ErrorReporting for InferCtxt<'a> {
fn report_region_errors(&self,
- errors: &OptVec<RegionResolutionError>) {
+ errors: &Vec<RegionResolutionError>) {
let p_errors = self.process_errors(errors);
let errors = if p_errors.is_empty() { errors } else { &p_errors };
for error in errors.iter() {
// complete view of what lifetimes should be the same.
// If the return value is an empty vector, it means that processing
// failed (so the return value of this method should not be used)
- fn process_errors(&self, errors: &OptVec<RegionResolutionError>)
- -> OptVec<RegionResolutionError> {
+ fn process_errors(&self, errors: &Vec<RegionResolutionError>)
+ -> Vec<RegionResolutionError> {
let mut var_origins = Vec::new();
let mut trace_origins = Vec::new();
let mut same_regions = Vec::new();
- let mut processed_errors = opt_vec::Empty;
+ let mut processed_errors = Vec::new();
for error in errors.iter() {
match *error {
ConcreteFailure(origin, sub, sup) => {
// declaration, we want to make sure that they are, in fact,
// from the same scope
if sr.scope_id != common_scope_id {
- return opt_vec::Empty;
+ return vec!();
}
}
let pe = ProcessedErrors(var_origins, trace_origins, same_regions);
use std::slice;
use collections::{HashMap, HashSet};
use syntax::ast;
-use syntax::opt_vec;
-use syntax::opt_vec::OptVec;
mod doc;
constraints, assuming such values can be found; if they cannot,
errors are reported.
*/
- pub fn resolve_regions(&self) -> OptVec<RegionResolutionError> {
+ pub fn resolve_regions(&self) -> Vec<RegionResolutionError> {
debug!("RegionVarBindings: resolve_regions()");
- let mut errors = opt_vec::Empty;
+ let mut errors = vec!();
let v = self.infer_variable_values(&mut errors);
let mut values = self.values.borrow_mut();
*values.get() = Some(v);
impl<'a> RegionVarBindings<'a> {
fn infer_variable_values(&self,
- errors: &mut OptVec<RegionResolutionError>)
+ errors: &mut Vec<RegionResolutionError>)
-> Vec<VarValue> {
let mut var_data = self.construct_var_data();
self.expansion(var_data.as_mut_slice());
fn collect_concrete_region_errors(
&self,
- errors: &mut OptVec<RegionResolutionError>)
+ errors: &mut Vec<RegionResolutionError>)
{
let constraints = self.constraints.borrow();
for (constraint, _) in constraints.get().iter() {
fn extract_values_and_collect_conflicts(
&self,
var_data: &[VarData],
- errors: &mut OptVec<RegionResolutionError>)
+ errors: &mut Vec<RegionResolutionError>)
-> Vec<VarValue> {
debug!("extract_values_and_collect_conflicts()");
var_data: &[VarData],
dup_vec: &mut [uint],
node_idx: RegionVid,
- errors: &mut OptVec<RegionResolutionError>)
+ errors: &mut Vec<RegionResolutionError>)
{
// Errors in expanding nodes result from a lower-bound that is
// not contained by an upper-bound.
var_data: &[VarData],
dup_vec: &mut [uint],
node_idx: RegionVid,
- errors: &mut OptVec<RegionResolutionError>)
+ errors: &mut Vec<RegionResolutionError>)
{
// Errors in contracting nodes result from two upper-bounds
// that have no intersection.
let num_inferred = self.terms_cx.num_inferred();
while index < num_inferred {
let item_id = inferred_infos.get(index).item_id;
- let mut item_variances = ty::ItemVariances {
- self_param: None,
- type_params: opt_vec::Empty,
- region_params: opt_vec::Empty
- };
+ let mut self_param = None;
+ let mut type_params = vec!();
+ let mut region_params = vec!();
+
while index < num_inferred &&
inferred_infos.get(index).item_id == item_id {
let info = inferred_infos.get(index);
match info.kind {
SelfParam => {
- assert!(item_variances.self_param.is_none());
- item_variances.self_param =
- Some(*solutions.get(index));
+ assert!(self_param.is_none());
+ self_param = Some(*solutions.get(index));
}
TypeParam => {
- item_variances.type_params
- .push(*solutions.get(index));
+ type_params.push(*solutions.get(index));
}
RegionParam => {
- item_variances.region_params
- .push(*solutions.get(index));
+ region_params.push(*solutions.get(index));
}
}
index += 1;
}
+ let item_variances = ty::ItemVariances {
+ self_param: self_param,
+ type_params: opt_vec::from(type_params),
+ region_params: opt_vec::from(region_params)
+ };
debug!("item_id={} item_variances={}",
item_id,
item_variances.repr(tcx));
methods: Vec<@ast::Method> ) -> @ast::Item {
let trait_path = self.path.to_path(cx, self.span, type_ident, generics);
- let mut trait_generics = self.generics.to_generics(cx, self.span,
- type_ident, generics);
+ let Generics { mut lifetimes, ty_params } =
+ self.generics.to_generics(cx, self.span, type_ident, generics);
+ let mut ty_params = opt_vec::take_vec(ty_params);
+
// Copy the lifetimes
- for l in generics.lifetimes.iter() {
- trait_generics.lifetimes.push(*l)
- };
+ lifetimes.extend(&mut generics.lifetimes.iter().map(|l| *l));
+
// Create the type parameters.
- for ty_param in generics.ty_params.iter() {
+ ty_params.extend(&mut generics.ty_params.iter().map(|ty_param| {
// I don't think this can be moved out of the loop, since
// a TyParamBound requires an ast id
- let mut bounds = opt_vec::from(
+ let mut bounds =
// extra restrictions on the generics parameters to the type being derived upon
self.additional_bounds.map(|p| {
cx.typarambound(p.to_path(cx, self.span,
type_ident, generics))
- }));
+ });
// require the current trait
bounds.push(cx.typarambound(trait_path.clone()));
- trait_generics.ty_params.push(cx.typaram(ty_param.ident, bounds, None));
- }
+ cx.typaram(ty_param.ident, opt_vec::from(bounds), None)
+ }));
+ let trait_generics = Generics {
+ lifetimes: lifetimes,
+ ty_params: opt_vec::from(ty_params)
+ };
// Create the reference to the trait.
let trait_ref = cx.trait_ref(trait_path);
}
impl<T> OptVec<T> {
- pub fn push(&mut self, t: T) {
- match *self {
- Vec(ref mut v) => {
- v.push(t);
- return;
- }
- Empty => {
- *self = Vec(vec!(t));
- }
- }
- }
-
- pub fn pop(&mut self) -> Option<T> {
- match *self {
- Vec(ref mut v) => v.pop(),
- Empty => None
- }
- }
-
pub fn last<'a>(&'a self) -> Option<&'a T> {
match *self {
Vec(ref v) => v.last(),
}
}
- pub fn swap_remove(&mut self, index: uint) {
- match *self {
- Empty => { fail!("index out of bounds"); }
- Vec(ref mut v) => {
- assert!(index < v.len());
- v.swap_remove(index);
- }
- }
- }
-
#[inline]
pub fn iter<'r>(&'r self) -> Items<'r, T> {
match *self {
}
}
-impl<T:Clone> OptVec<T> {
- pub fn prepend(&self, t: T) -> OptVec<T> {
- let mut v0 = vec!(t);
- match *self {
- Empty => {}
- Vec(ref v1) => { v0.push_all(v1.as_slice()); }
- }
- return Vec(v0);
- }
-}
-
impl<A:Eq> Eq for OptVec<A> {
fn eq(&self, other: &OptVec<A>) -> bool {
// Note: cannot use #[deriving(Eq)] here because
impl<A> FromIterator<A> for OptVec<A> {
fn from_iterator<T: Iterator<A>>(iterator: &mut T) -> OptVec<A> {
- let mut r = Empty;
- for x in *iterator {
- r.push(x);
- }
- r
+ let v: Vec<A> = iterator.collect();
+ from(v)
}
}
f: |&mut Parser| -> T)
-> OptVec<T> {
let mut first = true;
- let mut v = opt_vec::Empty;
+ let mut v = Vec::new();
while self.token != token::GT
&& self.token != token::BINOP(token::SHR) {
match sep {
}
v.push(f(self));
}
- return v;
+ return opt_vec::from(v);
}
pub fn parse_seq_to_gt<T>(
f: |&mut Parser| -> T)
-> Vec<T> {
let mut first: bool = true;
- let mut v: Vec<T> = Vec::new();
+ let mut v = vec!();
while self.token != *ket {
match sep.sep {
Some(ref t) => {
return None;
}
- let mut result = opt_vec::Empty;
+ let mut result = vec!();
loop {
match self.token {
token::LIFETIME(lifetime) => {
}
}
- return Some(result);
+ return Some(opt_vec::from(result));
}
// matches typaram = IDENT optbounds ( EQ ty )?
projects / rust.git / commitdiff