bjoernager/rust
bjoernager/rust
1
Fork 0
Code Issues Pull requests Activity

Migrate all users of opt_vec to owned_slice, delete opt_vec.

Browse source 
syntax::opt_vec is now entirely unused, and so can go.
This commit is contained in:
Huon Wilson 2014-03-20 01:52:37 +11:00
parent 0384952a65
commit e33676b793
35 changed files with 162 additions and 340 deletions
Download patch file Download diff file Expand all files Collapse all files

6
src/librustc/front/std_inject.rs
View file

@ -18,7 +18,7 @@ use syntax::codemap::DUMMY_SP;
use syntax::codemap;
use syntax::fold::Folder;
use syntax::fold;
use syntax::opt_vec;
use syntax::owned_slice::OwnedSlice;
use syntax::parse::token::InternedString;
use syntax::parse::token;
use syntax::util::small_vector::SmallVector;
@ -164,12 +164,12 @@ impl<'a> fold::Folder for PreludeInjector<'a> {
ast::PathSegment {
identifier: token::str_to_ident("std"),
lifetimes: Vec::new(),
types: opt_vec::Empty,
types: OwnedSlice::empty(),
},
ast::PathSegment {
identifier: token::str_to_ident("prelude"),
lifetimes: Vec::new(),
types: opt_vec::Empty,
types: OwnedSlice::empty(),
}),
};

6
src/librustc/front/test.rs
View file

@ -31,7 +31,7 @@ use syntax::ext::base::ExtCtxt;
use syntax::ext::expand::ExpansionConfig;
use syntax::fold::Folder;
use syntax::fold;
use syntax::opt_vec;
use syntax::owned_slice::OwnedSlice;
use syntax::parse::token::InternedString;
use syntax::parse::token;
use syntax::print::pprust;
@ -377,7 +377,7 @@ fn path_node(ids: Vec<ast::Ident> ) -> ast::Path {
segments: ids.move_iter().map(|identifier| ast::PathSegment {
identifier: identifier,
lifetimes: Vec::new(),
types: opt_vec::Empty,
types: OwnedSlice::empty(),
}).collect()
}
}
@ -389,7 +389,7 @@ fn path_node_global(ids: Vec<ast::Ident> ) -> ast::Path {
segments: ids.move_iter().map(|identifier| ast::PathSegment {
identifier: identifier,
lifetimes: Vec::new(),
types: opt_vec::Empty,
types: OwnedSlice::empty(),
}).collect()
}
}

4
src/librustc/metadata/tydecode.rs
View file

@ -24,7 +24,7 @@ use syntax::abi::AbiSet;
use syntax::abi;
use syntax::ast;
use syntax::ast::*;
use syntax::opt_vec;
use syntax::owned_slice::OwnedSlice;
use syntax::parse::token;
// Compact string representation for ty::t values. API ty_str &
@ -198,7 +198,7 @@ fn parse_region_substs(st: &mut PState, conv: conv_did) -> ty::RegionSubsts {
regions.push(r);
}
assert_eq!(next(st), '.');
ty::NonerasedRegions(opt_vec::from(regions))
ty::NonerasedRegions(OwnedSlice::from_vec(regions))
}
_ => fail!("parse_bound_region: bad input")
}

4
src/librustc/middle/kind.rs
View file

@ -19,7 +19,7 @@ use util::ppaux::UserString;
use syntax::ast::*;
use syntax::attr;
use syntax::codemap::Span;
use syntax::opt_vec;
use syntax::owned_slice::OwnedSlice;
use syntax::print::pprust::expr_to_str;
use syntax::{visit,ast_util};
use syntax::visit::Visitor;
@ -92,7 +92,7 @@ fn check_struct_safe_for_destructor(cx: &mut Context,
let struct_tpt = ty::lookup_item_type(cx.tcx, struct_did);
if !struct_tpt.generics.has_type_params() {
let struct_ty = ty::mk_struct(cx.tcx, struct_did, ty::substs {
regions: ty::NonerasedRegions(opt_vec::Empty),
regions: ty::NonerasedRegions(OwnedSlice::empty()),
self_ty: None,
tps: Vec::new()
});

4
src/librustc/middle/privacy.rs
View file

@ -28,7 +28,7 @@ use syntax::ast_util::{is_local, def_id_of_def, local_def};
use syntax::attr;
use syntax::codemap::Span;
use syntax::parse::token;
use syntax::opt_vec;
use syntax::owned_slice::OwnedSlice;
use syntax::visit;
use syntax::visit::Visitor;
@ -842,7 +842,7 @@ impl<'a> Visitor<()> for PrivacyVisitor<'a> {
let seg = ast::PathSegment {
identifier: pid.node.name,
lifetimes: Vec::new(),
types: opt_vec::Empty,
types: OwnedSlice::empty(),
};
let segs = vec!(seg);
let path = ast::Path {

4
src/librustc/middle/resolve.rs
View file

@ -27,7 +27,7 @@ use syntax::parse::token::special_idents;
use syntax::parse::token;
use syntax::print::pprust::path_to_str;
use syntax::codemap::{Span, DUMMY_SP, Pos};
use syntax::opt_vec::OptVec;
use syntax::owned_slice::OwnedSlice;
use syntax::visit;
use syntax::visit::Visitor;
@ -3969,7 +3969,7 @@ impl<'a> Resolver<'a> {
}
fn resolve_type_parameters(&mut self,
type_parameters: &OptVec<TyParam>) {
type_parameters: &OwnedSlice<TyParam>) {
for type_parameter in type_parameters.iter() {
for bound in type_parameter.bounds.iter() {
self.resolve_type_parameter_bound(type_parameter.id, bound);

4
src/librustc/middle/resolve_lifetime.rs
View file

@ -21,7 +21,7 @@ use driver::session::Session;
use util::nodemap::NodeMap;
use syntax::ast;
use syntax::codemap::Span;
use syntax::opt_vec::OptVec;
use syntax::owned_slice::OwnedSlice;
use syntax::parse::token::special_idents;
use syntax::parse::token;
use syntax::print::pprust::{lifetime_to_str};
@ -412,7 +412,7 @@ pub fn early_bound_lifetimes<'a>(generics: &'a ast::Generics) -> Vec<ast::Lifeti
.collect()
}
pub fn free_lifetimes(ty_params: &OptVec<ast::TyParam>) -> Vec<ast::Name> {
pub fn free_lifetimes(ty_params: &OwnedSlice<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

6
src/librustc/middle/subst.rs
View file

@ -17,7 +17,7 @@ use util::ppaux::Repr;
use std::rc::Rc;
use syntax::codemap::Span;
use syntax::opt_vec::OptVec;
use syntax::owned_slice::OwnedSlice;
///////////////////////////////////////////////////////////////////////////
// Public trait `Subst`
@ -145,10 +145,10 @@ impl<T:Subst> Subst for Rc<T> {
}
}
impl<T:Subst> Subst for OptVec<T> {
impl<T:Subst> Subst for OwnedSlice<T> {
fn subst_spanned(&self, tcx: &ty::ctxt,
substs: &ty::substs,
span: Option<Span>) -> OptVec<T> {
span: Option<Span>) -> OwnedSlice<T> {
self.map(|t| t.subst_spanned(tcx, substs, span))
}
}

5
src/librustc/middle/trans/debuginfo.rs
View file

@ -150,7 +150,8 @@ use std::ptr;
use std::sync::atomics;
use std::slice;
use syntax::codemap::{Span, Pos};
use syntax::{abi, ast, codemap, ast_util, ast_map, opt_vec};
use syntax::{abi, ast, codemap, ast_util, ast_map};
use syntax::owned_slice::OwnedSlice;
use syntax::parse::token;
use syntax::parse::token::special_idents;
@ -539,7 +540,7 @@ pub fn create_function_debug_context(cx: &CrateContext,
return FunctionWithoutDebugInfo;
}
let empty_generics = ast::Generics { lifetimes: Vec::new(), ty_params: opt_vec::Empty };
let empty_generics = ast::Generics { lifetimes: Vec::new(), ty_params: OwnedSlice::empty() };
let fnitem = cx.tcx.map.get(fn_ast_id);

4
src/librustc/middle/trans/type_of.rs
View file

@ -20,7 +20,7 @@ use util::ppaux::Repr;
use middle::trans::type_::Type;
use syntax::ast;
use syntax::opt_vec;
use syntax::owned_slice::OwnedSlice;
pub fn arg_is_indirect(ccx: &CrateContext, arg_ty: ty::t) -> bool {
!type_is_immediate(ccx, arg_ty)
@ -324,7 +324,7 @@ pub fn llvm_type_name(cx: &CrateContext,
an_enum => { "enum" }
};
let tstr = ppaux::parameterized(cx.tcx(), ty::item_path_str(cx.tcx(), did),
&ty::NonerasedRegions(opt_vec::Empty),
&ty::NonerasedRegions(OwnedSlice::empty()),
tps, did, false);
if did.krate == 0 {
format!("{}.{}", name, tstr)

15
src/librustc/middle/ty.rs
View file

@ -51,8 +51,7 @@ use syntax::codemap::Span;
use syntax::parse::token;
use syntax::parse::token::InternedString;
use syntax::{ast, ast_map};
use syntax::opt_vec::OptVec;
use syntax::opt_vec;
use syntax::owned_slice::OwnedSlice;
use syntax::abi::AbiSet;
use syntax;
use collections::enum_set::{EnumSet, CLike};
@ -192,8 +191,8 @@ pub enum ast_ty_to_ty_cache_entry {
#[deriving(Clone, Eq, Decodable, Encodable)]
pub struct ItemVariances {
self_param: Option<Variance>,
type_params: OptVec<Variance>,
region_params: OptVec<Variance>
type_params: OwnedSlice<Variance>,
region_params: OwnedSlice<Variance>
}
#[deriving(Clone, Eq, Decodable, Encodable, Show)]
@ -646,7 +645,7 @@ pub enum BoundRegion {
#[deriving(Clone, Eq, Hash)]
pub enum RegionSubsts {
ErasedRegions,
NonerasedRegions(OptVec<ty::Region>)
NonerasedRegions(OwnedSlice<ty::Region>)
}
/**
@ -4658,7 +4657,7 @@ pub fn visitor_object_ty(tcx: &ctxt,
Err(s) => { return Err(s); }
};
let substs = substs {
regions: ty::NonerasedRegions(opt_vec::Empty),
regions: ty::NonerasedRegions(OwnedSlice::empty()),
self_ty: None,
tps: Vec::new()
};
@ -5092,7 +5091,7 @@ pub fn construct_parameter_environment(
let free_substs = substs {
self_ty: self_ty,
tps: type_params,
regions: ty::NonerasedRegions(opt_vec::from(region_params))
regions: ty::NonerasedRegions(OwnedSlice::from_vec(region_params))
};
//
@ -5130,7 +5129,7 @@ impl substs {
substs {
self_ty: None,
tps: Vec::new(),
regions: NonerasedRegions(opt_vec::Empty)
regions: NonerasedRegions(OwnedSlice::empty())
}
}
}

7
src/librustc/middle/typeck/astconv.rs
View file

@ -63,8 +63,7 @@ use util::ppaux::Repr;
use syntax::abi::AbiSet;
use syntax::{ast, ast_util};
use syntax::codemap::Span;
use syntax::opt_vec::OptVec;
use syntax::opt_vec;
use syntax::owned_slice::OwnedSlice;
use syntax::print::pprust::{lifetime_to_str, path_to_str};
pub trait AstConv {
@ -229,7 +228,7 @@ fn ast_path_substs<AC:AstConv,RS:RegionScope>(
.collect();
let mut substs = substs {
regions: ty::NonerasedRegions(opt_vec::from(regions)),
regions: ty::NonerasedRegions(OwnedSlice::from_vec(regions)),
self_ty: self_ty,
tps: tps
};
@ -816,7 +815,7 @@ pub fn ty_of_closure<AC:AstConv,RS:RegionScope>(
}
}
fn conv_builtin_bounds(tcx: &ty::ctxt, ast_bounds: &Option<OptVec<ast::TyParamBound>>,
fn conv_builtin_bounds(tcx: &ty::ctxt, ast_bounds: &Option<OwnedSlice<ast::TyParamBound>>,
store: ty::TraitStore)
-> ty::BuiltinBounds {
//! Converts a list of bounds from the AST into a `BuiltinBounds`

4
src/librustc/middle/typeck/check/method.rs
View file

@ -104,7 +104,7 @@ use syntax::ast::{MutMutable, MutImmutable};
use syntax::ast;
use syntax::codemap::Span;
use syntax::parse::token;
use syntax::opt_vec;
use syntax::owned_slice::OwnedSlice;
#[deriving(Eq)]
pub enum CheckTraitsFlag {
@ -1120,7 +1120,7 @@ impl<'a> LookupContext<'a> {
let all_substs = substs {
tps: vec::append(candidate.rcvr_substs.tps.clone(),
m_substs.as_slice()),
regions: NonerasedRegions(opt_vec::from(all_regions)),
regions: NonerasedRegions(OwnedSlice::from_vec(all_regions)),
self_ty: candidate.rcvr_substs.self_ty,
};

13
src/librustc/middle/typeck/check/mod.rs
View file

@ -129,8 +129,7 @@ use syntax::ast_util;
use syntax::attr;
use syntax::codemap::Span;
use syntax::codemap;
use syntax::opt_vec::OptVec;
use syntax::opt_vec;
use syntax::owned_slice::OwnedSlice;
use syntax::parse::token;
use syntax::print::pprust;
use syntax::visit;
@ -903,7 +902,7 @@ fn compare_impl_method(tcx: &ty::ctxt,
impl_m.generics.type_param_defs().iter().enumerate().
map(|(i,t)| ty::mk_param(tcx, i + impl_tps, t.def_id)).
collect();
let dummy_impl_regions: OptVec<ty::Region> =
let dummy_impl_regions: OwnedSlice<ty::Region> =
impl_generics.region_param_defs().iter().
map(|l| ty::ReFree(ty::FreeRegion {
scope_id: impl_m_body_id,
@ -2631,7 +2630,7 @@ fn check_expr_with_unifier(fcx: &FnCtxt,
}
};
let regions =
ty::NonerasedRegions(opt_vec::Empty);
ty::NonerasedRegions(OwnedSlice::empty());
let sty = ty::mk_struct(tcx,
gc_struct_id,
substs {
@ -3706,7 +3705,7 @@ pub fn instantiate_path(fcx: &FnCtxt,
let num_expected_regions = tpt.generics.region_param_defs().len();
let num_supplied_regions = pth.segments.last().unwrap().lifetimes.len();
let regions = if num_expected_regions == num_supplied_regions {
opt_vec::from(pth.segments.last().unwrap().lifetimes.map(
OwnedSlice::from_vec(pth.segments.last().unwrap().lifetimes.map(
|l| ast_region_to_region(fcx.tcx(), l)))
} else {
if num_supplied_regions != 0 {
@ -3971,7 +3970,7 @@ pub fn may_break(cx: &ty::ctxt, id: ast::NodeId, b: ast::P<ast::Block>) -> bool
pub fn check_bounds_are_used(ccx: &CrateCtxt,
span: Span,
tps: &OptVec<ast::TyParam>,
tps: &OwnedSlice<ast::TyParam>,
ty: ty::t) {
debug!("check_bounds_are_used(n_tps={}, ty={})",
tps.len(), ppaux::ty_to_str(ccx.tcx, ty));
@ -4087,7 +4086,7 @@ pub fn check_intrinsic_type(ccx: &CrateCtxt, it: &ast::ForeignItem) {
Ok(did) => (1u, Vec::new(), ty::mk_struct(ccx.tcx, did, substs {
self_ty: None,
tps: Vec::new(),
regions: ty::NonerasedRegions(opt_vec::Empty)
regions: ty::NonerasedRegions(OwnedSlice::empty())
}) ),
Err(msg) => { tcx.sess.span_fatal(it.span, msg); }
}

12
src/librustc/middle/typeck/collect.rs
View file

@ -60,7 +60,7 @@ use syntax::parse::token::special_idents;
use syntax::parse::token;
use syntax::print::pprust::{path_to_str};
use syntax::visit;
use syntax::opt_vec::OptVec;
use syntax::owned_slice::OwnedSlice;
struct CollectItemTypesVisitor<'a> {
ccx: &'a CrateCtxt<'a>
@ -987,14 +987,14 @@ pub fn ty_generics_for_fn_or_method(ccx: &CrateCtxt,
pub fn ty_generics(ccx: &CrateCtxt,
lifetimes: &Vec<ast::Lifetime>,
ty_params: &OptVec<ast::TyParam>,
ty_params: &OwnedSlice<ast::TyParam>,
base_index: uint) -> ty::Generics {
return ty::Generics {
region_param_defs: Rc::new(lifetimes.iter().map(|l| {
ty::RegionParameterDef { name: l.name,
def_id: local_def(l.id) }
}).collect()),
type_param_defs: Rc::new(ty_params.mapi_to_vec(|offset, param| {
type_param_defs: Rc::new(ty_params.iter().enumerate().map(|(offset, param)| {
let existing_def_opt = {
let ty_param_defs = ccx.tcx.ty_param_defs.borrow();
ty_param_defs.get().find(&param.id).map(|&def| def)
@ -1015,13 +1015,13 @@ pub fn ty_generics(ccx: &CrateCtxt,
ty_param_defs.get().insert(param.id, def);
def
})
}).move_iter().collect()),
}).collect()),
};
fn compute_bounds(
ccx: &CrateCtxt,
param_ty: ty::param_ty,
ast_bounds: &OptVec<ast::TyParamBound>) -> ty::ParamBounds
ast_bounds: &OwnedSlice<ast::TyParamBound>) -> ty::ParamBounds
{
/*!
* Translate the AST's notion of ty param bounds (which are an
@ -1113,7 +1113,7 @@ pub fn mk_item_substs(ccx: &CrateCtxt,
ty_generics.type_param_defs().iter().enumerate().map(
|(i, t)| ty::mk_param(ccx.tcx, i, t.def_id)).collect();
let regions: OptVec<ty::Region> =
let regions: OwnedSlice<ty::Region> =
ty_generics.region_param_defs().iter().enumerate().map(
|(i, l)| ty::ReEarlyBound(l.def_id.node, i, l.name)).collect();

4
src/librustc/middle/typeck/infer/combine.rs
View file

@ -66,7 +66,7 @@ use std::result;
use syntax::ast::{Onceness, Purity};
use syntax::ast;
use syntax::opt_vec;
use syntax::owned_slice::OwnedSlice;
use syntax::abi::AbiSet;
pub trait Combine {
@ -176,7 +176,7 @@ pub trait Combine {
};
rs.push(if_ok!(r));
}
Ok(ty::NonerasedRegions(opt_vec::from(rs)))
Ok(ty::NonerasedRegions(OwnedSlice::from_vec(rs)))
}
}
}

4
src/librustc/middle/typeck/infer/mod.rs
View file

@ -43,7 +43,7 @@ use syntax::ast::{MutImmutable, MutMutable};
use syntax::ast;
use syntax::codemap;
use syntax::codemap::Span;
use syntax::opt_vec::OptVec;
use syntax::owned_slice::OwnedSlice;
use util::common::indent;
use util::ppaux::{bound_region_to_str, ty_to_str, trait_ref_to_str, Repr};
@ -668,7 +668,7 @@ impl<'a> InferCtxt<'a> {
pub fn region_vars_for_defs(&self,
span: Span,
defs: &[ty::RegionParameterDef])
-> OptVec<ty::Region> {
-> OwnedSlice<ty::Region> {
defs.iter()
.map(|d| self.next_region_var(EarlyBoundRegion(span, d.name)))
.collect()

4
src/librustc/middle/typeck/rscope.rs
View file

@ -14,7 +14,7 @@ use middle::ty;
use std::cell::Cell;
use syntax::ast;
use syntax::codemap::Span;
use syntax::opt_vec::OptVec;
use syntax::owned_slice::OwnedSlice;
/// Defines strategies for handling regions that are omitted. For
/// example, if one writes the type `&Foo`, then the lifetime of
@ -74,7 +74,7 @@ impl RegionScope for BindingRscope {
}
pub fn bound_type_regions(defs: &[ty::RegionParameterDef])
-> OptVec<ty::Region> {
-> OwnedSlice<ty::Region> {
assert!(defs.iter().all(|def| def.def_id.krate == ast::LOCAL_CRATE));
defs.iter().enumerate().map(
|(i, def)| ty::ReEarlyBound(def.def_id.node, i, def.name)).collect()

10
src/librustc/middle/typeck/variance.rs
View file

@ -199,7 +199,7 @@ use middle::ty;
use std::fmt;
use syntax::ast;
use syntax::ast_util;
use syntax::opt_vec;
use syntax::owned_slice::OwnedSlice;
use syntax::visit;
use syntax::visit::Visitor;
use util::ppaux::Repr;
@ -286,8 +286,8 @@ fn determine_parameters_to_be_inferred<'a>(tcx: &'a ty::ctxt,
// cache and share the variance struct used for items with
// no type/region parameters
empty_variances: @ty::ItemVariances { self_param: None,
type_params: opt_vec::Empty,
region_params: opt_vec::Empty }
type_params: OwnedSlice::empty(),
region_params: OwnedSlice::empty() }
};
visit::walk_crate(&mut terms_cx, krate, ());
@ -928,8 +928,8 @@ impl<'a> SolveContext<'a> {
let item_variances = ty::ItemVariances {
self_param: self_param,
type_params: opt_vec::from(type_params),
region_params: opt_vec::from(region_params)
type_params: OwnedSlice::from_vec(type_params),
region_params: OwnedSlice::from_vec(region_params)
};
debug!("item_id={} item_variances={}",
item_id,

10
src/librustc/util/ppaux.rs
View file

@ -29,8 +29,7 @@ use syntax::codemap::{Span, Pos};
use syntax::parse::token;
use syntax::print::pprust;
use syntax::{ast, ast_util};
use syntax::opt_vec;
use syntax::opt_vec::OptVec;
use syntax::owned_slice::OwnedSlice;
/// Produces a string suitable for debugging output.
pub trait Repr {
@ -606,12 +605,9 @@ impl<'a, T:Repr> Repr for &'a [T] {
}
}
impl<T:Repr> Repr for OptVec<T> {
impl<T:Repr> Repr for OwnedSlice<T> {
fn repr(&self, tcx: &ctxt) -> ~str {
match *self {
opt_vec::Empty => ~"[]",
opt_vec::Vec(ref v) => repr_vec(tcx, v.as_slice())
}
repr_vec(tcx, self.as_slice())
}
}

7
src/librustdoc/clean.rs
View file

@ -62,12 +62,9 @@ impl<T: Clean<U>, U> Clean<Option<U>> for Option<T> {
}
}
impl<T: Clean<U>, U> Clean<Vec<U>> for syntax::opt_vec::OptVec<T> {
impl<T: Clean<U>, U> Clean<Vec<U>> for syntax::owned_slice::OwnedSlice<T> {
fn clean(&self) -> Vec<U> {
match self {
&syntax::opt_vec::Empty => Vec::new(),
&syntax::opt_vec::Vec(ref v) => v.clean()
}
self.iter().map(|x| x.clean()).collect()
}
}

13
src/libstd/vec.rs
View file

@ -121,6 +121,19 @@ impl<T> Vec<T> {
}
}
/// Create a `Vec<T>` directly from the raw constituents.
///
/// This is highly unsafe:
///
/// - if `ptr` is null, then `length` and `capacity` should be 0
/// - `ptr` must point to an allocation of size `capacity`
/// - there must be `length` valid instances of type `T` at the
/// beginning of that allocation
/// - `ptr` must be allocated by the default `Vec` allocator
pub unsafe fn from_raw_parts(length: uint, capacity: uint, ptr: *mut T) -> Vec<T> {
Vec { len: length, cap: capacity, ptr: ptr }
}
/// Consumes the `Vec`, partitioning it based on a predcate.
///
/// Partitions the `Vec` into two `Vec`s `(A,B)`, where all elements of `A`

12
src/libsyntax/ast.rs
View file

@ -13,7 +13,7 @@
use codemap::{Span, Spanned, DUMMY_SP};
use abi::AbiSet;
use ast_util;
use opt_vec::OptVec;
use owned_slice::OwnedSlice;
use parse::token::{InternedString, special_idents, str_to_ident};
use parse::token;
@ -143,7 +143,7 @@ pub struct PathSegment {
/// The lifetime parameters for this path segment.
lifetimes: Vec<Lifetime>,
/// The type parameters for this path segment, if present.
types: OptVec<P<Ty>>,
types: OwnedSlice<P<Ty>>,
}
pub type CrateNum = u32;
@ -180,14 +180,14 @@ pub enum TyParamBound {
pub struct TyParam {
ident: Ident,
id: NodeId,
bounds: OptVec<TyParamBound>,
bounds: OwnedSlice<TyParamBound>,
default: Option<P<Ty>>
}
#[deriving(Clone, Eq, Encodable, Decodable, Hash)]
pub struct Generics {
lifetimes: Vec<Lifetime>,
ty_params: OptVec<TyParam>,
ty_params: OwnedSlice<TyParam>,
}
impl Generics {
@ -799,7 +799,7 @@ pub struct ClosureTy {
// implement issue #7264. None means "fn()", which means infer a default
// bound based on pointer sigil during typeck. Some(Empty) means "fn:()",
// which means use no bounds (e.g., not even Owned on a ~fn()).
bounds: Option<OptVec<TyParamBound>>,
bounds: Option<OwnedSlice<TyParamBound>>,
}
#[deriving(Eq, Encodable, Decodable, Hash)]
@ -823,7 +823,7 @@ pub enum Ty_ {
TyClosure(@ClosureTy),
TyBareFn(@BareFnTy),
TyTup(Vec<P<Ty>> ),
TyPath(Path, Option<OptVec<TyParamBound>>, NodeId), // for #7264; see above
TyPath(Path, Option<OwnedSlice<TyParamBound>>, NodeId), // for #7264; see above
TyTypeof(@Expr),
// TyInfer means the type should be inferred instead of it having been
// specified. This can appear anywhere in a type.

10
src/libsyntax/ast_util.rs
View file

@ -13,7 +13,7 @@ use ast;
use ast_util;
use codemap;
use codemap::Span;
use opt_vec;
use owned_slice::OwnedSlice;
use parse::token;
use print::pprust;
use visit::Visitor;
@ -196,7 +196,7 @@ pub fn ident_to_path(s: Span, identifier: Ident) -> Path {
ast::PathSegment {
identifier: identifier,
lifetimes: Vec::new(),
types: opt_vec::Empty,
types: OwnedSlice::empty(),
}
),
}
@ -318,7 +318,7 @@ pub static as_prec: uint = 12u;
pub fn empty_generics() -> Generics {
Generics {lifetimes: Vec::new(),
ty_params: opt_vec::Empty}
ty_params: OwnedSlice::empty()}
}
// ______________________________________________________________________
@ -709,12 +709,12 @@ pub fn get_inner_tys(ty: P<Ty>) -> Vec<P<Ty>> {
mod test {
use ast::*;
use super::*;
use opt_vec;
use owned_slice::OwnedSlice;
fn ident_to_segment(id : &Ident) -> PathSegment {
PathSegment {identifier:id.clone(),
lifetimes: Vec::new(),
types: opt_vec::Empty}
types: OwnedSlice::empty()}
}
#[test] fn idents_name_eq_test() {

33
src/libsyntax/ext/build.rs
View file

@ -16,8 +16,7 @@ use codemap::{Span, respan, DUMMY_SP};
use ext::base::ExtCtxt;
use ext::quote::rt::*;
use fold::Folder;
use opt_vec;
use opt_vec::OptVec;
use owned_slice::OwnedSlice;
use parse::token::special_idents;
use parse::token;
@ -48,7 +47,7 @@ pub trait AstBuilder {
fn ty_mt(&self, ty: P<ast::Ty>, mutbl: ast::Mutability) -> ast::MutTy;
fn ty(&self, span: Span, ty: ast::Ty_) -> P<ast::Ty>;
fn ty_path(&self, ast::Path, Option<OptVec<ast::TyParamBound>>) -> P<ast::Ty>;
fn ty_path(&self, ast::Path, Option<OwnedSlice<ast::TyParamBound>>) -> P<ast::Ty>;
fn ty_ident(&self, span: Span, idents: ast::Ident) -> P<ast::Ty>;
fn ty_rptr(&self, span: Span,
@ -61,14 +60,14 @@ pub trait AstBuilder {
fn ty_infer(&self, sp: Span) -> P<ast::Ty>;
fn ty_nil(&self) -> P<ast::Ty>;
fn ty_vars(&self, ty_params: &OptVec<ast::TyParam>) -> Vec<P<ast::Ty>> ;
fn ty_vars_global(&self, ty_params: &OptVec<ast::TyParam>) -> Vec<P<ast::Ty>> ;
fn ty_vars(&self, ty_params: &OwnedSlice<ast::TyParam>) -> Vec<P<ast::Ty>> ;
fn ty_vars_global(&self, ty_params: &OwnedSlice<ast::TyParam>) -> Vec<P<ast::Ty>> ;
fn ty_field_imm(&self, span: Span, name: Ident, ty: P<ast::Ty>) -> ast::TypeField;
fn strip_bounds(&self, bounds: &Generics) -> Generics;
fn typaram(&self,
id: ast::Ident,
bounds: OptVec<ast::TyParamBound>,
bounds: OwnedSlice<ast::TyParamBound>,
default: Option<P<ast::Ty>>) -> ast::TyParam;
fn trait_ref(&self, path: ast::Path) -> ast::TraitRef;
@ -274,13 +273,13 @@ impl<'a> AstBuilder for ExtCtxt<'a> {
ast::PathSegment {
identifier: ident,
lifetimes: Vec::new(),
types: opt_vec::Empty,
types: OwnedSlice::empty(),
}
}).collect();
segments.push(ast::PathSegment {
identifier: last_identifier,
lifetimes: lifetimes,
types: opt_vec::from(types),
types: OwnedSlice::from_vec(types),
});
ast::Path {
span: sp,
@ -304,7 +303,7 @@ impl<'a> AstBuilder for ExtCtxt<'a> {
})
}
fn ty_path(&self, path: ast::Path, bounds: Option<OptVec<ast::TyParamBound>>)
fn ty_path(&self, path: ast::Path, bounds: Option<OwnedSlice<ast::TyParamBound>>)
-> P<ast::Ty> {
self.ty(path.span,
ast::TyPath(path, bounds, ast::DUMMY_NODE_ID))
@ -366,7 +365,7 @@ impl<'a> AstBuilder for ExtCtxt<'a> {
fn typaram(&self,
id: ast::Ident,
bounds: OptVec<ast::TyParamBound>,
bounds: OwnedSlice<ast::TyParamBound>,
default: Option<P<ast::Ty>>) -> ast::TyParam {
ast::TyParam {
ident: id,
@ -379,20 +378,18 @@ impl<'a> AstBuilder for ExtCtxt<'a> {
// these are strange, and probably shouldn't be used outside of
// pipes. Specifically, the global version possible generates
// incorrect code.
fn ty_vars(&self, ty_params: &OptVec<ast::TyParam>) -> Vec<P<ast::Ty>> {
opt_vec::take_vec(
ty_params.map(|p| self.ty_ident(DUMMY_SP, p.ident)))
fn ty_vars(&self, ty_params: &OwnedSlice<ast::TyParam>) -> Vec<P<ast::Ty>> {
ty_params.iter().map(|p| self.ty_ident(DUMMY_SP, p.ident)).collect()
}
fn ty_vars_global(&self, ty_params: &OptVec<ast::TyParam>) -> Vec<P<ast::Ty>> {
opt_vec::take_vec(
ty_params.map(|p| self.ty_path(
self.path_global(DUMMY_SP, vec!(p.ident)), None)))
fn ty_vars_global(&self, ty_params: &OwnedSlice<ast::TyParam>) -> Vec<P<ast::Ty>> {
ty_params.iter().map(|p| self.ty_path(
self.path_global(DUMMY_SP, vec!(p.ident)), None)).collect()
}
fn strip_bounds(&self, generics: &Generics) -> Generics {
let new_params = generics.ty_params.map(|ty_param| {
ast::TyParam { bounds: opt_vec::Empty, ..*ty_param }
ast::TyParam { bounds: OwnedSlice::empty(), ..*ty_param }
});
Generics {
ty_params: new_params,

4
src/libsyntax/ext/concat_idents.rs
View file

@ -12,7 +12,7 @@ use ast;
use codemap::Span;
use ext::base::*;
use ext::base;
use opt_vec;
use owned_slice::OwnedSlice;
use parse::token;
use parse::token::{str_to_ident};
@ -52,7 +52,7 @@ pub fn expand_syntax_ext(cx: &mut ExtCtxt, sp: Span, tts: &[ast::TokenTree])
ast::PathSegment {
identifier: res,
lifetimes: Vec::new(),
types: opt_vec::Empty,
types: OwnedSlice::empty(),
}
)
}

10
src/libsyntax/ext/deriving/generic.rs
View file

@ -184,7 +184,7 @@ use ext::base::ExtCtxt;
use ext::build::AstBuilder;
use codemap;
use codemap::Span;
use opt_vec;
use owned_slice::OwnedSlice;
use parse::token::InternedString;
use std::vec;
@ -362,7 +362,7 @@ impl<'a> TraitDef<'a> {
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);
let mut ty_params = ty_params.into_vec();
// Copy the lifetimes
lifetimes.extend(&mut generics.lifetimes.iter().map(|l| *l));
@ -380,11 +380,11 @@ impl<'a> TraitDef<'a> {
// require the current trait
bounds.push(cx.typarambound(trait_path.clone()));
cx.typaram(ty_param.ident, opt_vec::from(bounds), None)
cx.typaram(ty_param.ident, OwnedSlice::from_vec(bounds), None)
}));
let trait_generics = Generics {
lifetimes: lifetimes,
ty_params: opt_vec::from(ty_params)
ty_params: OwnedSlice::from_vec(ty_params)
};
// Create the reference to the trait.
@ -400,7 +400,7 @@ impl<'a> TraitDef<'a> {
// Create the type of `self`.
let self_type = cx.ty_path(
cx.path_all(self.span, false, vec!( type_ident ), self_lifetimes,
opt_vec::take_vec(self_ty_params)), None);
self_ty_params.into_vec()), None);
let attr = cx.attribute(
self.span,

19
src/libsyntax/ext/deriving/ty.rs
View file

@ -18,7 +18,7 @@ use ast::{P,Expr,Generics,Ident};
use ext::base::ExtCtxt;
use ext::build::AstBuilder;
use codemap::{Span,respan};
use opt_vec;
use owned_slice::OwnedSlice;
/// The types of pointers
pub enum PtrTy<'a> {
@ -116,11 +116,10 @@ fn mk_lifetime(cx: &ExtCtxt, span: Span, lt: &Option<&str>) -> Option<ast::Lifet
}
fn mk_lifetimes(cx: &ExtCtxt, span: Span, lt: &Option<&str>) -> Vec<ast::Lifetime> {
let lifetimes = match *lt {
Some(ref s) => opt_vec::with(cx.lifetime(span, cx.ident_of(*s).name)),
None => opt_vec::Empty
};
opt_vec::take_vec(lifetimes)
match *lt {
Some(ref s) => vec!(cx.lifetime(span, cx.ident_of(*s).name)),
None => vec!()
}
}
impl<'a> Ty<'a> {
@ -173,7 +172,7 @@ impl<'a> Ty<'a> {
let lifetimes = self_generics.lifetimes.clone();
cx.path_all(span, false, vec!(self_ty), lifetimes,
opt_vec::take_vec(self_params))
self_params.into_vec())
}
Literal(ref p) => {
p.to_path(cx, span, self_ty, self_generics)
@ -187,18 +186,18 @@ impl<'a> Ty<'a> {
fn mk_ty_param(cx: &ExtCtxt, span: Span, name: &str, bounds: &[Path],
self_ident: Ident, self_generics: &Generics) -> ast::TyParam {
let bounds = opt_vec::from(
let bounds =
bounds.iter().map(|b| {
let path = b.to_path(cx, span, self_ident, self_generics);
cx.typarambound(path)
}).collect());
}).collect();
cx.typaram(cx.ident_of(name), bounds, None)
}
fn mk_generics(lifetimes: Vec<ast::Lifetime> , ty_params: Vec<ast::TyParam> ) -> Generics {
Generics {
lifetimes: lifetimes,
ty_params: opt_vec::from(ty_params)
ty_params: OwnedSlice::from_vec(ty_params)
}
}

10
src/libsyntax/fold.rs
View file

@ -13,7 +13,7 @@ use ast;
use ast_util;
use codemap::{respan, Span, Spanned};
use parse::token;
use opt_vec::OptVec;
use owned_slice::OwnedSlice;
use util::small_vector::SmallVector;
// We may eventually want to be able to fold over type parameters, too.
@ -424,8 +424,8 @@ pub fn fold_ty_param<T: Folder>(tp: &TyParam, fld: &mut T) -> TyParam {
}
}
pub fn fold_ty_params<T: Folder>(tps: &OptVec<TyParam>, fld: &mut T)
-> OptVec<TyParam> {
pub fn fold_ty_params<T: Folder>(tps: &OwnedSlice<TyParam>, fld: &mut T)
-> OwnedSlice<TyParam> {
tps.map(|tp| fold_ty_param(tp, fld))
}
@ -493,8 +493,8 @@ fn fold_mt<T: Folder>(mt: &MutTy, folder: &mut T) -> MutTy {
}
}
fn fold_opt_bounds<T: Folder>(b: &Option<OptVec<TyParamBound>>, folder: &mut T)
-> Option<OptVec<TyParamBound>> {
fn fold_opt_bounds<T: Folder>(b: &Option<OwnedSlice<TyParamBound>>, folder: &mut T)
-> Option<OwnedSlice<TyParamBound>> {
b.as_ref().map(|bounds| {
bounds.map(|bound| {
fold_ty_param_bound(bound, folder)

1
src/libsyntax/lib.rs
View file

@ -50,7 +50,6 @@ pub mod syntax {
}
pub mod owned_slice;
pub mod opt_vec;
pub mod attr;
pub mod diagnostic;
pub mod codemap;

174
src/libsyntax/opt_vec.rs
View file

@ -1,174 +0,0 @@
// Copyright 2012 The Rust Project Developers. See the COPYRIGHT
// file at the top-level directory of this distribution and at
// http://rust-lang.org/COPYRIGHT.
//
// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
// option. This file may not be copied, modified, or distributed
// except according to those terms.
/*!
* Defines a type OptVec<T> that can be used in place of ~[T].
* OptVec avoids the need for allocation for empty vectors.
* OptVec implements the iterable interface as well as
* other useful things like `push()` and `len()`.
*/
use std::default::Default;
use std::slice;
#[deriving(Clone, Encodable, Decodable, Hash)]
pub enum OptVec<T> {
Empty,
Vec(Vec<T> )
}
pub fn with<T>(t: T) -> OptVec<T> {
Vec(vec!(t))
}
pub fn from<T>(t: Vec<T> ) -> OptVec<T> {
if t.len() == 0 {
Empty
} else {
Vec(t)
}
}
impl<T> OptVec<T> {
pub fn last<'a>(&'a self) -> Option<&'a T> {
match *self {
Vec(ref v) => v.last(),
Empty => None
}
}
pub fn mut_last<'a>(&'a mut self) -> Option<&'a mut T> {
match *self {
Vec(ref mut v) => v.mut_last(),
Empty => None
}
}
pub fn map<U>(&self, op: |&T| -> U) -> OptVec<U> {
match *self {
Empty => Empty,
Vec(ref v) => Vec(v.map(op))
}
}
pub fn map_move<U>(self, op: |T| -> U) -> OptVec<U> {
match self {
Empty => Empty,
Vec(v) => Vec(v.move_iter().map(op).collect())
}
}
pub fn get<'a>(&'a self, i: uint) -> &'a T {
match *self {
Empty => fail!("invalid index {}", i),
Vec(ref v) => v.get(i)
}
}
pub fn is_empty(&self) -> bool {
self.len() == 0
}
pub fn len(&self) -> uint {
match *self {
Empty => 0,
Vec(ref v) => v.len()
}
}
#[inline]
pub fn iter<'r>(&'r self) -> Items<'r, T> {
match *self {
Empty => Items{iter: None},
Vec(ref v) => Items{iter: Some(v.iter())}
}
}
#[inline]
pub fn map_to_vec<B>(&self, op: |&T| -> B) -> Vec<B> {
self.iter().map(op).collect()
}
pub fn mapi_to_vec<B>(&self, op: |uint, &T| -> B) -> Vec<B> {
let mut index = 0;
self.map_to_vec(|a| {
let i = index;
index += 1;
op(i, a)
})
}
}
pub fn take_vec<T>(v: OptVec<T>) -> Vec<T> {
match v {
Empty => Vec::new(),
Vec(v) => v
}
}
impl<A:Eq> Eq for OptVec<A> {
fn eq(&self, other: &OptVec<A>) -> bool {
// Note: cannot use #[deriving(Eq)] here because
// (Empty, Vec(~[])) ought to be equal.
match (self, other) {
(&Empty, &Empty) => true,
(&Empty, &Vec(ref v)) => v.is_empty(),
(&Vec(ref v), &Empty) => v.is_empty(),
(&Vec(ref v1), &Vec(ref v2)) => *v1 == *v2
}
}
fn ne(&self, other: &OptVec<A>) -> bool {
!self.eq(other)
}
}
impl<T> Default for OptVec<T> {
fn default() -> OptVec<T> { Empty }
}
pub struct Items<'a, T> {
priv iter: Option<slice::Items<'a, T>>
}
impl<'a, T> Iterator<&'a T> for Items<'a, T> {
#[inline]
fn next(&mut self) -> Option<&'a T> {
match self.iter {
Some(ref mut x) => x.next(),
None => None
}
}
#[inline]
fn size_hint(&self) -> (uint, Option<uint>) {
match self.iter {
Some(ref x) => x.size_hint(),
None => (0, Some(0))
}
}
}
impl<'a, T> DoubleEndedIterator<&'a T> for Items<'a, T> {
#[inline]
fn next_back(&mut self) -> Option<&'a T> {
match self.iter {
Some(ref mut x) => x.next_back(),
None => None
}
}
}
impl<A> FromIterator<A> for OptVec<A> {
fn from_iterator<T: Iterator<A>>(iterator: &mut T) -> OptVec<A> {
let v: Vec<A> = iterator.collect();
from(v)
}
}

22
src/libsyntax/parse/mod.rs
View file

@ -279,7 +279,7 @@ mod test {
use std::io::MemWriter;
use std::str;
use codemap::{Span, BytePos, Spanned};
use opt_vec;
use owned_slice::OwnedSlice;
use ast;
use abi;
use parse::parser::Parser;
@ -312,7 +312,7 @@ mod test {
ast::PathSegment {
identifier: str_to_ident("a"),
lifetimes: Vec::new(),
types: opt_vec::Empty,
types: OwnedSlice::empty(),
}
),
}),
@ -331,12 +331,12 @@ mod test {
ast::PathSegment {
identifier: str_to_ident("a"),
lifetimes: Vec::new(),
types: opt_vec::Empty,
types: OwnedSlice::empty(),
},
ast::PathSegment {
identifier: str_to_ident("b"),
lifetimes: Vec::new(),
types: opt_vec::Empty,
types: OwnedSlice::empty(),
}
)
}),
@ -545,7 +545,7 @@ mod test {
ast::PathSegment {
identifier: str_to_ident("d"),
lifetimes: Vec::new(),
types: opt_vec::Empty,
types: OwnedSlice::empty(),
}
),
}),
@ -567,7 +567,7 @@ mod test {
ast::PathSegment {
identifier: str_to_ident("b"),
lifetimes: Vec::new(),
types: opt_vec::Empty,
types: OwnedSlice::empty(),
}
),
}),
@ -595,7 +595,7 @@ mod test {
ast::PathSegment {
identifier: str_to_ident("b"),
lifetimes: Vec::new(),
types: opt_vec::Empty,
types: OwnedSlice::empty(),
}
),
},
@ -623,7 +623,7 @@ mod test {
identifier:
str_to_ident("int"),
lifetimes: Vec::new(),
types: opt_vec::Empty,
types: OwnedSlice::empty(),
}
),
}, None, ast::DUMMY_NODE_ID),
@ -641,7 +641,7 @@ mod test {
identifier:
str_to_ident("b"),
lifetimes: Vec::new(),
types: opt_vec::Empty,
types: OwnedSlice::empty(),
}
),
},
@ -661,7 +661,7 @@ mod test {
abi::AbiSet::Rust(),
ast::Generics{ // no idea on either of these:
lifetimes: Vec::new(),
ty_params: opt_vec::Empty,
ty_params: OwnedSlice::empty(),
},
ast::P(ast::Block {
view_items: Vec::new(),
@ -680,7 +680,7 @@ mod test {
lifetimes:
Vec::new(),
types:
opt_vec::Empty
OwnedSlice::empty()
}
),
}),

33
src/libsyntax/parse/parser.rs
View file

@ -75,8 +75,7 @@ use parse::token::{is_ident, is_ident_or_path, is_plain_ident};
use parse::token::{keywords, special_idents, token_to_binop};
use parse::token;
use parse::{new_sub_parser_from_file, ParseSess};
use opt_vec;
use opt_vec::OptVec;
use owned_slice::OwnedSlice;
use std::cell::Cell;
use collections::HashSet;
@ -117,13 +116,13 @@ pub enum PathParsingMode {
/// for the definition of a path segment.)
struct PathSegmentAndBoundSet {
segment: ast::PathSegment,
bound_set: Option<OptVec<TyParamBound>>,
bound_set: Option<OwnedSlice<TyParamBound>>,
}
/// A path paired with optional type bounds.
pub struct PathAndBounds {
path: ast::Path,
bounds: Option<OptVec<TyParamBound>>,
bounds: Option<OwnedSlice<TyParamBound>>,
}
enum ItemOrViewItem {
@ -630,7 +629,7 @@ impl<'a> Parser<'a> {
&mut self,
sep: Option<token::Token>,
f: |&mut Parser| -> T)
-> OptVec<T> {
-> OwnedSlice<T> {
let mut first = true;
let mut v = Vec::new();
while self.token != token::GT
@ -644,14 +643,14 @@ impl<'a> Parser<'a> {
}
v.push(f(self));
}
return opt_vec::from(v);
return OwnedSlice::from_vec(v);
}
pub fn parse_seq_to_gt<T>(
&mut self,
sep: Option<token::Token>,
f: |&mut Parser| -> T)
-> OptVec<T> {
-> OwnedSlice<T> {
let v = self.parse_seq_to_before_gt(sep, f);
self.expect_gt();
return v;
@ -1531,7 +1530,7 @@ impl<'a> Parser<'a> {
segment: ast::PathSegment {
identifier: identifier,
lifetimes: Vec::new(),
types: opt_vec::Empty,
types: OwnedSlice::empty(),
},
bound_set: bound_set
});
@ -1543,9 +1542,9 @@ impl<'a> Parser<'a> {
if mode != NoTypesAllowed && self.eat(&token::LT) {
let (lifetimes, types) =
self.parse_generic_values_after_lt();
(true, lifetimes, opt_vec::from(types))
(true, lifetimes, OwnedSlice::from_vec(types))
} else {
(false, Vec::new(), opt_vec::Empty)
(false, Vec::new(), OwnedSlice::empty())
}
};
@ -3432,7 +3431,7 @@ impl<'a> Parser<'a> {
// Returns "Some(Empty)" if there's a colon but nothing after (e.g. "T:")
// Returns "Some(stuff)" otherwise (e.g. "T:stuff").
// NB: The None/Some distinction is important for issue #7264.
fn parse_optional_ty_param_bounds(&mut self) -> Option<OptVec<TyParamBound>> {
fn parse_optional_ty_param_bounds(&mut self) -> Option<OwnedSlice<TyParamBound>> {
if !self.eat(&token::COLON) {
return None;
}
@ -3462,7 +3461,7 @@ impl<'a> Parser<'a> {
}
}
return Some(opt_vec::from(result));
return Some(OwnedSlice::from_vec(result));
}
// matches typaram = IDENT optbounds ( EQ ty )?
@ -3515,7 +3514,7 @@ impl<'a> Parser<'a> {
let result = self.parse_seq_to_gt(
Some(token::COMMA),
|p| p.parse_ty(false));
(lifetimes, opt_vec::take_vec(result))
(lifetimes, result.into_vec())
}
fn parse_fn_args(&mut self, named_args: bool, allow_variadic: bool)
@ -4882,7 +4881,7 @@ impl<'a> Parser<'a> {
ast::PathSegment {
identifier: identifier,
lifetimes: Vec::new(),
types: opt_vec::Empty,
types: OwnedSlice::empty(),
}
}).collect()
};
@ -4917,7 +4916,7 @@ impl<'a> Parser<'a> {
ast::PathSegment {
identifier: identifier,
lifetimes: Vec::new(),
types: opt_vec::Empty,
types: OwnedSlice::empty(),
}
}).collect()
};
@ -4935,7 +4934,7 @@ impl<'a> Parser<'a> {
ast::PathSegment {
identifier: identifier,
lifetimes: Vec::new(),
types: opt_vec::Empty,
types: OwnedSlice::empty(),
}
}).collect()
};
@ -4957,7 +4956,7 @@ impl<'a> Parser<'a> {
ast::PathSegment {
identifier: identifier,
lifetimes: Vec::new(),
types: opt_vec::Empty,
types: OwnedSlice::empty(),
}
}).collect()
};

17
src/libsyntax/print/pprust.rs
View file

@ -12,8 +12,7 @@ use abi::AbiSet;
use ast::{P, RegionTyParamBound, TraitTyParamBound, Required, Provided};
use ast;
use ast_util;
use opt_vec::OptVec;
use opt_vec;
use owned_slice::OwnedSlice;
use attr::{AttrMetaMethods, AttributeMethods};
use codemap::{CodeMap, BytePos};
use codemap;
@ -478,7 +477,7 @@ impl<'a> State<'a> {
ast::TyBareFn(f) => {
let generics = ast::Generics {
lifetimes: f.lifetimes.clone(),
ty_params: opt_vec::Empty
ty_params: OwnedSlice::empty()
};
try!(self.print_ty_fn(Some(f.abis), None, &None,
f.purity, ast::Many, f.decl, None, &None,
@ -487,7 +486,7 @@ impl<'a> State<'a> {
ast::TyClosure(f) => {
let generics = ast::Generics {
lifetimes: f.lifetimes.clone(),
ty_params: opt_vec::Empty
ty_params: OwnedSlice::empty()
};
try!(self.print_ty_fn(None, Some(f.sigil), &f.region,
f.purity, f.onceness, f.decl, None, &f.bounds,
@ -1518,7 +1517,7 @@ impl<'a> State<'a> {
fn print_path_(&mut self,
path: &ast::Path,
colons_before_params: bool,
opt_bounds: &Option<OptVec<ast::TyParamBound>>)
opt_bounds: &Option<OwnedSlice<ast::TyParamBound>>)
-> IoResult<()> {
try!(self.maybe_print_comment(path.span.lo));
if path.global {
@ -1564,7 +1563,7 @@ impl<'a> State<'a> {
}
try!(self.commasep(
Inconsistent,
segment.types.map_to_vec(|&t| t).as_slice(),
segment.types.as_slice(),
|s, ty| s.print_type_ref(ty)));
}
@ -1580,7 +1579,7 @@ impl<'a> State<'a> {
}
fn print_bounded_path(&mut self, path: &ast::Path,
bounds: &Option<OptVec<ast::TyParamBound>>)
bounds: &Option<OwnedSlice<ast::TyParamBound>>)
-> IoResult<()> {
self.print_path_(path, false, bounds)
}
@ -1826,7 +1825,7 @@ impl<'a> State<'a> {
self.maybe_print_comment(decl.output.span.lo)
}
pub fn print_bounds(&mut self, bounds: &OptVec<ast::TyParamBound>,
pub fn print_bounds(&mut self, bounds: &OwnedSlice<ast::TyParamBound>,
print_colon_anyway: bool) -> IoResult<()> {
if !bounds.is_empty() {
try!(word(&mut self.s, ":"));
@ -2028,7 +2027,7 @@ impl<'a> State<'a> {
onceness: ast::Onceness,
decl: &ast::FnDecl,
id: Option<ast::Ident>,
opt_bounds: &Option<OptVec<ast::TyParamBound>>,
opt_bounds: &Option<OwnedSlice<ast::TyParamBound>>,
generics: Option<&ast::Generics>,
opt_explicit_self: Option<ast::ExplicitSelf_>)
-> IoResult<()> {

7
src/libsyntax/visit.rs
View file

@ -13,8 +13,7 @@ use ast::*;
use ast;
use codemap::Span;
use parse;
use opt_vec;
use opt_vec::OptVec;
use owned_slice::OwnedSlice;
// Context-passing AST walker. Each overridden visit method has full control
// over what happens with its node, it can do its own traversal of the node's
@ -56,7 +55,7 @@ pub fn generics_of_fn(fk: &FnKind) -> Generics {
FkFnBlock(..) => {
Generics {
lifetimes: Vec::new(),
ty_params: opt_vec::Empty,
ty_params: OwnedSlice::empty(),
}
}
}
@ -457,7 +456,7 @@ pub fn walk_foreign_item<E: Clone, V: Visitor<E>>(visitor: &mut V,
}
pub fn walk_ty_param_bounds<E: Clone, V: Visitor<E>>(visitor: &mut V,
bounds: &OptVec<TyParamBound>,
bounds: &OwnedSlice<TyParamBound>,
env: E) {
for bound in bounds.iter() {
match *bound {