bjoernager/rust
bjoernager/rust
1
Fork 0
Code Activity

libsyntax: Mechanically change ~[T] to Vec<T>

Browse source
This commit is contained in:
Patrick Walton 2014-02-28 13:09:09 -08:00
parent df40aeccdb
commit 58fd6ab90d
48 changed files with 934 additions and 979 deletions
Download patch file Download diff file Expand all files Collapse all files

5
src/libsyntax/abi.rs
View file

@ -9,6 +9,7 @@
// except according to those terms.
use std::fmt;
use std::vec_ng::Vec;
use std::fmt::Show;
#[deriving(Eq)]
@ -117,7 +118,7 @@ pub fn lookup(name: &str) -> Option<Abi> {
res
}
pub fn all_names() -> ~[&'static str] {
pub fn all_names() -> Vec<&'static str> {
AbiDatas.map(|d| d.name)
}
@ -232,7 +233,7 @@ impl AbiSet {
}
pub fn check_valid(&self) -> Option<(Abi, Abi)> {
let mut abis = ~[];
let mut abis = Vec::new();
self.each(|abi| { abis.push(abi); true });
for (i, abi) in abis.iter().enumerate() {

98
src/libsyntax/ast.rs
View file

@ -98,7 +98,7 @@ pub type SyntaxContext = u32;
// it should cut down on memory use *a lot*; applying a mark
// to a tree containing 50 identifiers would otherwise generate
pub struct SCTable {
table: RefCell<~[SyntaxContext_]>,
table: RefCell<Vec<SyntaxContext_> >,
mark_memo: RefCell<HashMap<(SyntaxContext,Mrk),SyntaxContext>>,
rename_memo: RefCell<HashMap<(SyntaxContext,Ident,Name),SyntaxContext>>,
}
@ -164,7 +164,7 @@ pub struct Path {
/// module (like paths in an import).
global: bool,
/// The segments in the path: the things separated by `::`.
segments: ~[PathSegment],
segments: Vec<PathSegment> ,
}
/// A segment of a path: an identifier, an optional lifetime, and a set of
@ -288,12 +288,12 @@ pub enum DefRegion {
// The set of MetaItems that define the compilation environment of the crate,
// used to drive conditional compilation
pub type CrateConfig = ~[@MetaItem];
pub type CrateConfig = Vec<@MetaItem> ;
#[deriving(Clone, Eq, Encodable, Decodable, Hash)]
pub struct Crate {
module: Mod,
attrs: ~[Attribute],
attrs: Vec<Attribute> ,
config: CrateConfig,
span: Span,
}
@ -303,7 +303,7 @@ pub type MetaItem = Spanned<MetaItem_>;
#[deriving(Clone, Encodable, Decodable, Hash)]
pub enum MetaItem_ {
MetaWord(InternedString),
MetaList(InternedString, ~[@MetaItem]),
MetaList(InternedString, Vec<@MetaItem> ),
MetaNameValue(InternedString, Lit),
}
@ -334,8 +334,8 @@ impl Eq for MetaItem_ {
#[deriving(Clone, Eq, Encodable, Decodable, Hash)]
pub struct Block {
view_items: ~[ViewItem],
stmts: ~[@Stmt],
view_items: Vec<ViewItem> ,
stmts: Vec<@Stmt> ,
expr: Option<@Expr>,
id: NodeId,
rules: BlockCheckMode,
@ -373,17 +373,17 @@ pub enum Pat_ {
// records this pattern's NodeId in an auxiliary
// set (of "pat_idents that refer to nullary enums")
PatIdent(BindingMode, Path, Option<@Pat>),
PatEnum(Path, Option<~[@Pat]>), /* "none" means a * pattern where
PatEnum(Path, Option<Vec<@Pat> >), /* "none" means a * pattern where
* we don't bind the fields to names */
PatStruct(Path, ~[FieldPat], bool),
PatTup(~[@Pat]),
PatStruct(Path, Vec<FieldPat> , bool),
PatTup(Vec<@Pat> ),
PatUniq(@Pat),
PatRegion(@Pat), // reference pattern
PatLit(@Expr),
PatRange(@Expr, @Expr),
// [a, b, ..i, y, z] is represented as
// PatVec(~[a, b], Some(i), ~[y, z])
PatVec(~[@Pat], Option<@Pat>, ~[@Pat])
PatVec(Vec<@Pat> , Option<@Pat>, Vec<@Pat> )
}
#[deriving(Clone, Eq, Encodable, Decodable, Hash)]
@ -488,7 +488,7 @@ pub enum Decl_ {
#[deriving(Clone, Eq, Encodable, Decodable, Hash)]
pub struct Arm {
pats: ~[@Pat],
pats: Vec<@Pat> ,
guard: Option<@Expr>,
body: P<Block>,
}
@ -526,10 +526,10 @@ pub enum Expr_ {
ExprVstore(@Expr, ExprVstore),
// First expr is the place; second expr is the value.
ExprBox(@Expr, @Expr),
ExprVec(~[@Expr], Mutability),
ExprCall(@Expr, ~[@Expr]),
ExprMethodCall(Ident, ~[P<Ty>], ~[@Expr]),
ExprTup(~[@Expr]),
ExprVec(Vec<@Expr> , Mutability),
ExprCall(@Expr, Vec<@Expr> ),
ExprMethodCall(Ident, Vec<P<Ty>> , Vec<@Expr> ),
ExprTup(Vec<@Expr> ),
ExprBinary(BinOp, @Expr, @Expr),
ExprUnary(UnOp, @Expr),
ExprLit(@Lit),
@ -541,14 +541,14 @@ pub enum Expr_ {
// Conditionless loop (can be exited with break, cont, or ret)
// FIXME #6993: change to Option<Name>
ExprLoop(P<Block>, Option<Ident>),
ExprMatch(@Expr, ~[Arm]),
ExprMatch(@Expr, Vec<Arm> ),
ExprFnBlock(P<FnDecl>, P<Block>),
ExprProc(P<FnDecl>, P<Block>),
ExprBlock(P<Block>),
ExprAssign(@Expr, @Expr),
ExprAssignOp(BinOp, @Expr, @Expr),
ExprField(@Expr, Ident, ~[P<Ty>]),
ExprField(@Expr, Ident, Vec<P<Ty>> ),
ExprIndex(@Expr, @Expr),
/// Expression that looks like a "name". For example,
@ -569,7 +569,7 @@ pub enum Expr_ {
ExprMac(Mac),
// A struct literal expression.
ExprStruct(Path, ~[Field], Option<@Expr> /* base */),
ExprStruct(Path, Vec<Field> , Option<@Expr> /* base */),
// A vector literal constructed from one repeated element.
ExprRepeat(@Expr /* element */, @Expr /* count */, Mutability),
@ -600,14 +600,14 @@ pub enum TokenTree {
TTTok(Span, ::parse::token::Token),
// a delimited sequence (the delimiters appear as the first
// and last elements of the vector)
TTDelim(@~[TokenTree]),
TTDelim(@Vec<TokenTree> ),
// These only make sense for right-hand-sides of MBE macros:
// a kleene-style repetition sequence with a span, a TTForest,
// an optional separator, and a boolean where true indicates
// zero or more (..), and false indicates one or more (+).
TTSeq(Span, @~[TokenTree], Option<::parse::token::Token>, bool),
TTSeq(Span, @Vec<TokenTree> , Option<::parse::token::Token>, bool),
// a syntactic variable that will be filled in by macro expansion.
TTNonterminal(Span, Ident)
@ -673,7 +673,7 @@ pub enum Matcher_ {
MatchTok(::parse::token::Token),
// match repetitions of a sequence: body, separator, zero ok?,
// lo, hi position-in-match-array used:
MatchSeq(~[Matcher], Option<::parse::token::Token>, bool, uint, uint),
MatchSeq(Vec<Matcher> , Option<::parse::token::Token>, bool, uint, uint),
// parse a Rust NT: name to bind, name of NT, position in match array:
MatchNonterminal(Ident, Ident, uint)
}
@ -686,7 +686,7 @@ pub type Mac = Spanned<Mac_>;
// There's only one flavor, now, so this could presumably be simplified.
#[deriving(Clone, Eq, Encodable, Decodable, Hash)]
pub enum Mac_ {
MacInvocTT(Path, ~[TokenTree], SyntaxContext), // new macro-invocation
MacInvocTT(Path, Vec<TokenTree> , SyntaxContext), // new macro-invocation
}
#[deriving(Clone, Eq, Encodable, Decodable, Hash)]
@ -700,7 +700,7 @@ pub type Lit = Spanned<Lit_>;
#[deriving(Clone, Eq, Encodable, Decodable, Hash)]
pub enum Lit_ {
LitStr(InternedString, StrStyle),
LitBinary(Rc<~[u8]>),
LitBinary(Rc<Vec<u8> >),
LitChar(u32),
LitInt(i64, IntTy),
LitUint(u64, UintTy),
@ -729,7 +729,7 @@ pub struct TypeField {
#[deriving(Clone, Eq, Encodable, Decodable, Hash)]
pub struct TypeMethod {
ident: Ident,
attrs: ~[Attribute],
attrs: Vec<Attribute> ,
purity: Purity,
decl: P<FnDecl>,
generics: Generics,
@ -858,7 +858,7 @@ pub enum Ty_ {
TyRptr(Option<Lifetime>, MutTy),
TyClosure(@ClosureTy),
TyBareFn(@BareFnTy),
TyTup(~[P<Ty>]),
TyTup(Vec<P<Ty>> ),
TyPath(Path, Option<OptVec<TyParamBound>>, NodeId), // for #7264; see above
TyTypeof(@Expr),
// TyInfer means the type should be inferred instead of it having been
@ -878,8 +878,8 @@ pub struct InlineAsm {
asm: InternedString,
asm_str_style: StrStyle,
clobbers: InternedString,
inputs: ~[(InternedString, @Expr)],
outputs: ~[(InternedString, @Expr)],
inputs: Vec<(InternedString, @Expr)> ,
outputs: Vec<(InternedString, @Expr)> ,
volatile: bool,
alignstack: bool,
dialect: AsmDialect
@ -914,7 +914,7 @@ impl Arg {
#[deriving(Clone, Eq, Encodable, Decodable, Hash)]
pub struct FnDecl {
inputs: ~[Arg],
inputs: Vec<Arg> ,
output: P<Ty>,
cf: RetStyle,
variadic: bool
@ -957,7 +957,7 @@ pub type ExplicitSelf = Spanned<ExplicitSelf_>;
#[deriving(Eq, Encodable, Decodable, Hash)]
pub struct Method {
ident: Ident,
attrs: ~[Attribute],
attrs: Vec<Attribute> ,
generics: Generics,
explicit_self: ExplicitSelf,
purity: Purity,
@ -970,15 +970,15 @@ pub struct Method {
#[deriving(Clone, Eq, Encodable, Decodable, Hash)]
pub struct Mod {
view_items: ~[ViewItem],
items: ~[@Item],
view_items: Vec<ViewItem> ,
items: Vec<@Item> ,
}
#[deriving(Clone, Eq, Encodable, Decodable, Hash)]
pub struct ForeignMod {
abis: AbiSet,
view_items: ~[ViewItem],
items: ~[@ForeignItem],
view_items: Vec<ViewItem> ,
items: Vec<@ForeignItem> ,
}
#[deriving(Clone, Eq, Encodable, Decodable, Hash)]
@ -989,19 +989,19 @@ pub struct VariantArg {
#[deriving(Clone, Eq, Encodable, Decodable, Hash)]
pub enum VariantKind {
TupleVariantKind(~[VariantArg]),
TupleVariantKind(Vec<VariantArg> ),
StructVariantKind(@StructDef),
}
#[deriving(Clone, Eq, Encodable, Decodable, Hash)]
pub struct EnumDef {
variants: ~[P<Variant>],
variants: Vec<P<Variant>> ,
}
#[deriving(Clone, Eq, Encodable, Decodable, Hash)]
pub struct Variant_ {
name: Ident,
attrs: ~[Attribute],
attrs: Vec<Attribute> ,
kind: VariantKind,
id: NodeId,
disr_expr: Option<@Expr>,
@ -1034,13 +1034,13 @@ pub enum ViewPath_ {
ViewPathGlob(Path, NodeId),
// foo::bar::{a,b,c}
ViewPathList(Path, ~[PathListIdent], NodeId)
ViewPathList(Path, Vec<PathListIdent> , NodeId)
}
#[deriving(Clone, Eq, Encodable, Decodable, Hash)]
pub struct ViewItem {
node: ViewItem_,
attrs: ~[Attribute],
attrs: Vec<Attribute> ,
vis: Visibility,
span: Span,
}
@ -1052,7 +1052,7 @@ pub enum ViewItem_ {
// (containing arbitrary characters) from which to fetch the crate sources
// For example, extern crate whatever = "github.com/mozilla/rust"
ViewItemExternMod(Ident, Option<(InternedString,StrStyle)>, NodeId),
ViewItemUse(~[@ViewPath]),
ViewItemUse(Vec<@ViewPath> ),
}
// Meta-data associated with an item
@ -1109,7 +1109,7 @@ pub struct StructField_ {
kind: StructFieldKind,
id: NodeId,
ty: P<Ty>,
attrs: ~[Attribute],
attrs: Vec<Attribute> ,
}
pub type StructField = Spanned<StructField_>;
@ -1122,7 +1122,7 @@ pub enum StructFieldKind {
#[deriving(Eq, Encodable, Decodable, Hash)]
pub struct StructDef {
fields: ~[StructField], /* fields, not including ctor */
fields: Vec<StructField> , /* fields, not including ctor */
/* ID of the constructor. This is only used for tuple- or enum-like
* structs. */
ctor_id: Option<NodeId>
@ -1135,7 +1135,7 @@ pub struct StructDef {
#[deriving(Clone, Eq, Encodable, Decodable, Hash)]
pub struct Item {
ident: Ident,
attrs: ~[Attribute],
attrs: Vec<Attribute> ,
id: NodeId,
node: Item_,
vis: Visibility,
@ -1151,11 +1151,11 @@ pub enum Item_ {
ItemTy(P<Ty>, Generics),
ItemEnum(EnumDef, Generics),
ItemStruct(@StructDef, Generics),
ItemTrait(Generics, ~[TraitRef], ~[TraitMethod]),
ItemTrait(Generics, Vec<TraitRef> , Vec<TraitMethod> ),
ItemImpl(Generics,
Option<TraitRef>, // (optional) trait this impl implements
P<Ty>, // self
~[@Method]),
Vec<@Method> ),
// a macro invocation (which includes macro definition)
ItemMac(Mac),
}
@ -1163,7 +1163,7 @@ pub enum Item_ {
#[deriving(Eq, Encodable, Decodable, Hash)]
pub struct ForeignItem {
ident: Ident,
attrs: ~[Attribute],
attrs: Vec<Attribute> ,
node: ForeignItem_,
id: NodeId,
span: Span,
@ -1205,9 +1205,9 @@ mod test {
#[test]
fn check_asts_encodable() {
let e = Crate {
module: Mod {view_items: ~[], items: ~[]},
attrs: ~[],
config: ~[],
module: Mod {view_items: Vec::new(), items: Vec::new()},
attrs: Vec::new(),
config: Vec::new(),
span: Span {
lo: BytePos(10),
hi: BytePos(20),

8
src/libsyntax/ast_map.rs
View file

@ -134,7 +134,7 @@ enum MapEntry {
}
struct InlinedParent {
path: ~[PathElem],
path: Vec<PathElem> ,
// Required by NodeTraitMethod and NodeMethod.
def_id: DefId
}
@ -185,7 +185,7 @@ pub struct Map {
///
/// Also, indexing is pretty quick when you've got a vector and
/// plain old integers.
priv map: RefCell<~[MapEntry]>
priv map: RefCell<Vec<MapEntry> >
}
impl Map {
@ -522,7 +522,7 @@ impl<'a, F: FoldOps> Folder for Ctx<'a, F> {
}
pub fn map_crate<F: FoldOps>(krate: Crate, fold_ops: F) -> (Crate, Map) {
let map = Map { map: RefCell::new(~[]) };
let map = Map { map: RefCell::new(Vec::new()) };
let krate = {
let mut cx = Ctx {
map: &map,
@ -557,7 +557,7 @@ pub fn map_crate<F: FoldOps>(krate: Crate, fold_ops: F) -> (Crate, Map) {
// crate. The `path` should be the path to the item but should not include
// the item itself.
pub fn map_decoded_item<F: FoldOps>(map: &Map,
path: ~[PathElem],
path: Vec<PathElem> ,
fold_ops: F,
fold: |&mut Ctx<F>| -> InlinedItem)
-> InlinedItem {

110
src/libsyntax/ast_util.rs
View file

@ -180,8 +180,8 @@ pub fn is_call_expr(e: @Expr) -> bool {
pub fn block_from_expr(e: @Expr) -> P<Block> {
P(Block {
view_items: ~[],
stmts: ~[],
view_items: Vec::new(),
stmts: Vec::new(),
expr: Some(e),
id: e.id,
rules: DefaultBlock,
@ -193,13 +193,13 @@ pub fn ident_to_path(s: Span, identifier: Ident) -> Path {
ast::Path {
span: s,
global: false,
segments: ~[
segments: vec!(
ast::PathSegment {
identifier: identifier,
lifetimes: opt_vec::Empty,
types: opt_vec::Empty,
}
],
),
}
}
@ -216,7 +216,7 @@ pub fn is_unguarded(a: &Arm) -> bool {
}
}
pub fn unguarded_pat(a: &Arm) -> Option<~[@Pat]> {
pub fn unguarded_pat(a: &Arm) -> Option<Vec<@Pat> > {
if is_unguarded(a) {
Some(/* FIXME (#2543) */ a.pats.clone())
} else {
@ -241,7 +241,7 @@ pub fn impl_pretty_name(trait_ref: &Option<TraitRef>, ty: &Ty) -> Ident {
token::gensym_ident(pretty)
}
pub fn public_methods(ms: ~[@Method]) -> ~[@Method] {
pub fn public_methods(ms: Vec<@Method> ) -> Vec<@Method> {
ms.move_iter().filter(|m| {
match m.vis {
Public => true,
@ -271,9 +271,9 @@ pub fn trait_method_to_ty_method(method: &TraitMethod) -> TypeMethod {
}
pub fn split_trait_methods(trait_methods: &[TraitMethod])
-> (~[TypeMethod], ~[@Method]) {
let mut reqd = ~[];
let mut provd = ~[];
-> (Vec<TypeMethod> , Vec<@Method> ) {
let mut reqd = Vec::new();
let mut provd = Vec::new();
for trt_method in trait_methods.iter() {
match *trt_method {
Required(ref tm) => reqd.push((*tm).clone()),
@ -724,7 +724,7 @@ pub fn new_rename_internal(id: Ident,
// FIXME #8215 : currently pub to allow testing
pub fn new_sctable_internal() -> SCTable {
SCTable {
table: RefCell::new(~[EmptyCtxt,IllegalCtxt]),
table: RefCell::new(vec!(EmptyCtxt,IllegalCtxt)),
mark_memo: RefCell::new(HashMap::new()),
rename_memo: RefCell::new(HashMap::new()),
}
@ -754,7 +754,7 @@ pub fn display_sctable(table : &SCTable) {
/// Add a value to the end of a vec, return its index
fn idx_push<T>(vec: &mut ~[T], val: T) -> u32 {
fn idx_push<T>(vec: &mut Vec<T> , val: T) -> u32 {
vec.push(val);
(vec.len() - 1) as u32
}
@ -831,15 +831,15 @@ pub fn resolve_internal(id : Ident,
}
/// Compute the marks associated with a syntax context.
pub fn mtwt_marksof(ctxt: SyntaxContext, stopname: Name) -> ~[Mrk] {
pub fn mtwt_marksof(ctxt: SyntaxContext, stopname: Name) -> Vec<Mrk> {
marksof(ctxt, stopname, get_sctable())
}
// the internal function for computing marks
// it's not clear to me whether it's better to use a [] mutable
// vector or a cons-list for this.
pub fn marksof(ctxt: SyntaxContext, stopname: Name, table: &SCTable) -> ~[Mrk] {
let mut result = ~[];
pub fn marksof(ctxt: SyntaxContext, stopname: Name, table: &SCTable) -> Vec<Mrk> {
let mut result = Vec::new();
let mut loopvar = ctxt;
loop {
let table_entry = {
@ -881,7 +881,7 @@ pub fn mtwt_outer_mark(ctxt: SyntaxContext) -> Mrk {
/// Push a name... unless it matches the one on top, in which
/// case pop and discard (so two of the same marks cancel)
pub fn xorPush(marks: &mut ~[Mrk], mark: Mrk) {
pub fn xorPush(marks: &mut Vec<Mrk> , mark: Mrk) {
if (marks.len() > 0) && (getLast(marks) == mark) {
marks.pop().unwrap();
} else {
@ -891,7 +891,7 @@ pub fn xorPush(marks: &mut ~[Mrk], mark: Mrk) {
// get the last element of a mutable array.
// FIXME #4903: , must be a separate procedure for now.
pub fn getLast(arr: &~[Mrk]) -> Mrk {
pub fn getLast(arr: &Vec<Mrk> ) -> Mrk {
*arr.last().unwrap()
}
@ -956,21 +956,21 @@ mod test {
}
#[test] fn xorpush_test () {
let mut s = ~[];
let mut s = Vec::new();
xorPush(&mut s, 14);
assert_eq!(s.clone(), ~[14]);
assert_eq!(s.clone(), vec!(14));
xorPush(&mut s, 14);
assert_eq!(s.clone(), ~[]);
assert_eq!(s.clone(), Vec::new());
xorPush(&mut s, 14);
assert_eq!(s.clone(), ~[14]);
assert_eq!(s.clone(), vec!(14));
xorPush(&mut s, 15);
assert_eq!(s.clone(), ~[14, 15]);
assert_eq!(s.clone(), vec!(14, 15));
xorPush(&mut s, 16);
assert_eq!(s.clone(), ~[14, 15, 16]);
assert_eq!(s.clone(), vec!(14, 15, 16));
xorPush(&mut s, 16);
assert_eq!(s.clone(), ~[14, 15]);
assert_eq!(s.clone(), vec!(14, 15));
xorPush(&mut s, 15);
assert_eq!(s.clone(), ~[14]);
assert_eq!(s.clone(), vec!(14));
}
fn id(n: Name, s: SyntaxContext) -> Ident {
@ -987,7 +987,7 @@ mod test {
// unfold a vector of TestSC values into a SCTable,
// returning the resulting index
fn unfold_test_sc(tscs : ~[TestSC], tail: SyntaxContext, table: &SCTable)
fn unfold_test_sc(tscs : Vec<TestSC> , tail: SyntaxContext, table: &SCTable)
-> SyntaxContext {
tscs.rev_iter().fold(tail, |tail : SyntaxContext, tsc : &TestSC|
{match *tsc {
@ -996,8 +996,8 @@ mod test {
}
// gather a SyntaxContext back into a vector of TestSCs
fn refold_test_sc(mut sc: SyntaxContext, table : &SCTable) -> ~[TestSC] {
let mut result = ~[];
fn refold_test_sc(mut sc: SyntaxContext, table : &SCTable) -> Vec<TestSC> {
let mut result = Vec::new();
loop {
let table = table.table.borrow();
match table.get()[sc] {
@ -1020,7 +1020,7 @@ mod test {
#[test] fn test_unfold_refold(){
let mut t = new_sctable_internal();
let test_sc = ~[M(3),R(id(101,0),14),M(9)];
let test_sc = vec!(M(3),R(id(101,0),14),M(9));
assert_eq!(unfold_test_sc(test_sc.clone(),EMPTY_CTXT,&mut t),4);
{
let table = t.table.borrow();
@ -1033,7 +1033,7 @@ mod test {
// extend a syntax context with a sequence of marks given
// in a vector. v[0] will be the outermost mark.
fn unfold_marks(mrks: ~[Mrk], tail: SyntaxContext, table: &SCTable)
fn unfold_marks(mrks: Vec<Mrk> , tail: SyntaxContext, table: &SCTable)
-> SyntaxContext {
mrks.rev_iter().fold(tail, |tail:SyntaxContext, mrk:&Mrk|
{new_mark_internal(*mrk,tail,table)})
@ -1042,7 +1042,7 @@ mod test {
#[test] fn unfold_marks_test() {
let mut t = new_sctable_internal();
assert_eq!(unfold_marks(~[3,7],EMPTY_CTXT,&mut t),3);
assert_eq!(unfold_marks(vec!(3,7),EMPTY_CTXT,&mut t),3);
{
let table = t.table.borrow();
assert!(table.get()[2] == Mark(7,0));
@ -1054,32 +1054,32 @@ mod test {
let stopname = 242;
let name1 = 243;
let mut t = new_sctable_internal();
assert_eq!(marksof (EMPTY_CTXT,stopname,&t),~[]);
assert_eq!(marksof (EMPTY_CTXT,stopname,&t),Vec::new());
// FIXME #5074: ANF'd to dodge nested calls
{ let ans = unfold_marks(~[4,98],EMPTY_CTXT,&mut t);
assert_eq! (marksof (ans,stopname,&t),~[4,98]);}
{ let ans = unfold_marks(vec!(4,98),EMPTY_CTXT,&mut t);
assert_eq! (marksof (ans,stopname,&t),vec!(4,98));}
// does xoring work?
{ let ans = unfold_marks(~[5,5,16],EMPTY_CTXT,&mut t);
assert_eq! (marksof (ans,stopname,&t), ~[16]);}
{ let ans = unfold_marks(vec!(5,5,16),EMPTY_CTXT,&mut t);
assert_eq! (marksof (ans,stopname,&t), vec!(16));}
// does nested xoring work?
{ let ans = unfold_marks(~[5,10,10,5,16],EMPTY_CTXT,&mut t);
assert_eq! (marksof (ans, stopname,&t), ~[16]);}
{ let ans = unfold_marks(vec!(5,10,10,5,16),EMPTY_CTXT,&mut t);
assert_eq! (marksof (ans, stopname,&t), vec!(16));}
// rename where stop doesn't match:
{ let chain = ~[M(9),
{ let chain = vec!(M(9),
R(id(name1,
new_mark_internal (4, EMPTY_CTXT,&mut t)),
100101102),
M(14)];
M(14));
let ans = unfold_test_sc(chain,EMPTY_CTXT,&mut t);
assert_eq! (marksof (ans, stopname, &t), ~[9,14]);}
assert_eq! (marksof (ans, stopname, &t), vec!(9,14));}
// rename where stop does match
{ let name1sc = new_mark_internal(4, EMPTY_CTXT, &mut t);
let chain = ~[M(9),
let chain = vec!(M(9),
R(id(name1, name1sc),
stopname),
M(14)];
M(14));
let ans = unfold_test_sc(chain,EMPTY_CTXT,&mut t);
assert_eq! (marksof (ans, stopname, &t), ~[9]); }
assert_eq! (marksof (ans, stopname, &t), vec!(9)); }
}
@ -1090,32 +1090,32 @@ mod test {
// - ctxt is MT
assert_eq!(resolve_internal(id(a,EMPTY_CTXT),&mut t, &mut rt),a);
// - simple ignored marks
{ let sc = unfold_marks(~[1,2,3],EMPTY_CTXT,&mut t);
{ let sc = unfold_marks(vec!(1,2,3),EMPTY_CTXT,&mut t);
assert_eq!(resolve_internal(id(a,sc),&mut t, &mut rt),a);}
// - orthogonal rename where names don't match
{ let sc = unfold_test_sc(~[R(id(50,EMPTY_CTXT),51),M(12)],EMPTY_CTXT,&mut t);
{ let sc = unfold_test_sc(vec!(R(id(50,EMPTY_CTXT),51),M(12)),EMPTY_CTXT,&mut t);
assert_eq!(resolve_internal(id(a,sc),&mut t, &mut rt),a);}
// - rename where names do match, but marks don't
{ let sc1 = new_mark_internal(1,EMPTY_CTXT,&mut t);
let sc = unfold_test_sc(~[R(id(a,sc1),50),
let sc = unfold_test_sc(vec!(R(id(a,sc1),50),
M(1),
M(2)],
M(2)),
EMPTY_CTXT,&mut t);
assert_eq!(resolve_internal(id(a,sc),&mut t, &mut rt), a);}
// - rename where names and marks match
{ let sc1 = unfold_test_sc(~[M(1),M(2)],EMPTY_CTXT,&mut t);
let sc = unfold_test_sc(~[R(id(a,sc1),50),M(1),M(2)],EMPTY_CTXT,&mut t);
{ let sc1 = unfold_test_sc(vec!(M(1),M(2)),EMPTY_CTXT,&mut t);
let sc = unfold_test_sc(vec!(R(id(a,sc1),50),M(1),M(2)),EMPTY_CTXT,&mut t);
assert_eq!(resolve_internal(id(a,sc),&mut t, &mut rt), 50); }
// - rename where names and marks match by literal sharing
{ let sc1 = unfold_test_sc(~[M(1),M(2)],EMPTY_CTXT,&mut t);
let sc = unfold_test_sc(~[R(id(a,sc1),50)],sc1,&mut t);
{ let sc1 = unfold_test_sc(vec!(M(1),M(2)),EMPTY_CTXT,&mut t);
let sc = unfold_test_sc(vec!(R(id(a,sc1),50)),sc1,&mut t);
assert_eq!(resolve_internal(id(a,sc),&mut t, &mut rt), 50); }
// - two renames of the same var.. can only happen if you use
// local-expand to prevent the inner binding from being renamed
// during the rename-pass caused by the first:
println!("about to run bad test");
{ let sc = unfold_test_sc(~[R(id(a,EMPTY_CTXT),50),
R(id(a,EMPTY_CTXT),51)],
{ let sc = unfold_test_sc(vec!(R(id(a,EMPTY_CTXT),50),
R(id(a,EMPTY_CTXT),51)),
EMPTY_CTXT,&mut t);
assert_eq!(resolve_internal(id(a,sc),&mut t, &mut rt), 51); }
// the simplest double-rename:
@ -1126,8 +1126,8 @@ mod test {
let sc = new_mark_internal(9,a50_to_a51,&mut t);
assert_eq!(resolve_internal(id(a,sc),&mut t, &mut rt),51);
// but mark on the inside does:
let a50_to_a51_b = unfold_test_sc(~[R(id(a,a_to_a50),51),
M(9)],
let a50_to_a51_b = unfold_test_sc(vec!(R(id(a,a_to_a50),51),
M(9)),
a_to_a50,
&mut t);
assert_eq!(resolve_internal(id(a,a50_to_a51_b),&mut t, &mut rt),50);}

10
src/libsyntax/attr.rs
View file

@ -146,7 +146,7 @@ pub fn mk_name_value_item(name: InternedString, value: ast::Lit)
@dummy_spanned(MetaNameValue(name, value))
}
pub fn mk_list_item(name: InternedString, items: ~[@MetaItem]) -> @MetaItem {
pub fn mk_list_item(name: InternedString, items: Vec<@MetaItem> ) -> @MetaItem {
@dummy_spanned(MetaList(name, items))
}
@ -212,12 +212,12 @@ pub fn last_meta_item_value_str_by_name(items: &[@MetaItem], name: &str)
/* Higher-level applications */
pub fn sort_meta_items(items: &[@MetaItem]) -> ~[@MetaItem] {
pub fn sort_meta_items(items: &[@MetaItem]) -> Vec<@MetaItem> {
// This is sort of stupid here, but we need to sort by
// human-readable strings.
let mut v = items.iter()
.map(|&mi| (mi.name(), mi))
.collect::<~[(InternedString, @MetaItem)]>();
.collect::<Vec<(InternedString, @MetaItem)> >();
v.sort_by(|&(ref a, _), &(ref b, _)| a.cmp(b));
@ -239,8 +239,8 @@ pub fn sort_meta_items(items: &[@MetaItem]) -> ~[@MetaItem] {
* From a list of crate attributes get only the meta_items that affect crate
* linkage
*/
pub fn find_linkage_metas(attrs: &[Attribute]) -> ~[@MetaItem] {
let mut result = ~[];
pub fn find_linkage_metas(attrs: &[Attribute]) -> Vec<@MetaItem> {
let mut result = Vec::new();
for attr in attrs.iter().filter(|at| at.name().equiv(&("link"))) {
match attr.meta().node {
MetaList(_, ref items) => result.push_all(*items),

17
src/libsyntax/codemap.rs
View file

@ -188,8 +188,7 @@ pub type FileName = ~str;
pub struct FileLines
{
file: @FileMap,
lines: ~[uint]
}
lines: Vec<uint> }
/// Identifies an offset of a multi-byte character in a FileMap
pub struct MultiByteChar {
@ -210,9 +209,9 @@ pub struct FileMap {
/// The start position of this source in the CodeMap
start_pos: BytePos,
/// Locations of lines beginnings in the source code
lines: RefCell<~[BytePos]>,
lines: RefCell<Vec<BytePos> >,
/// Locations of multi-byte characters in the source code
multibyte_chars: RefCell<~[MultiByteChar]>,
multibyte_chars: RefCell<Vec<MultiByteChar> >,
}
impl FileMap {
@ -257,13 +256,13 @@ impl FileMap {
}
pub struct CodeMap {
files: RefCell<~[@FileMap]>
files: RefCell<Vec<@FileMap> >
}
impl CodeMap {
pub fn new() -> CodeMap {
CodeMap {
files: RefCell::new(~[]),
files: RefCell::new(Vec::new()),
}
}
@ -278,8 +277,8 @@ impl CodeMap {
name: filename,
src: src,
start_pos: Pos::from_uint(start_pos),
lines: RefCell::new(~[]),
multibyte_chars: RefCell::new(~[]),
lines: RefCell::new(Vec::new()),
multibyte_chars: RefCell::new(Vec::new()),
};
files.get().push(filemap);
@ -330,7 +329,7 @@ impl CodeMap {
pub fn span_to_lines(&self, sp: Span) -> @FileLines {
let lo = self.lookup_char_pos(sp.lo);
let hi = self.lookup_char_pos(sp.hi);
let mut lines = ~[];
let mut lines = Vec::new();
for i in range(lo.line - 1u, hi.line as uint) {
lines.push(i);
};

6
src/libsyntax/crateid.rs
View file

@ -48,7 +48,7 @@ impl fmt::Show for CrateId {
impl FromStr for CrateId {
fn from_str(s: &str) -> Option<CrateId> {
let pieces: ~[&str] = s.splitn('#', 1).collect();
let pieces: Vec<&str> = s.splitn('#', 1).collect();
let path = pieces[0].to_owned();
if path.starts_with("/") || path.ends_with("/") ||
@ -56,13 +56,13 @@ impl FromStr for CrateId {
return None;
}
let path_pieces: ~[&str] = path.rsplitn('/', 1).collect();
let path_pieces: Vec<&str> = path.rsplitn('/', 1).collect();
let inferred_name = path_pieces[0];
let (name, version) = if pieces.len() == 1 {
(inferred_name.to_owned(), None)
} else {
let hash_pieces: ~[&str] = pieces[1].splitn(':', 1).collect();
let hash_pieces: Vec<&str> = pieces[1].splitn(':', 1).collect();
let (hash_name, hash_version) = if hash_pieces.len() == 1 {
("", hash_pieces[0])
} else {

6
src/libsyntax/ext/asm.rs
View file

@ -46,8 +46,8 @@ pub fn expand_asm(cx: &mut ExtCtxt, sp: Span, tts: &[ast::TokenTree])
let mut asm = InternedString::new("");
let mut asm_str_style = None;
let mut outputs = ~[];
let mut inputs = ~[];
let mut outputs = Vec::new();
let mut inputs = Vec::new();
let mut cons = ~"";
let mut volatile = false;
let mut alignstack = false;
@ -119,7 +119,7 @@ pub fn expand_asm(cx: &mut ExtCtxt, sp: Span, tts: &[ast::TokenTree])
}
}
Clobbers => {
let mut clobs = ~[];
let mut clobs = Vec::new();
while p.token != token::EOF &&
p.token != token::COLON &&
p.token != token::MOD_SEP {

26
src/libsyntax/ext/base.rs
View file

@ -74,7 +74,7 @@ pub trait IdentMacroExpander {
cx: &mut ExtCtxt,
sp: Span,
ident: ast::Ident,
token_tree: ~[ast::TokenTree])
token_tree: Vec<ast::TokenTree> )
-> MacResult;
}
@ -83,14 +83,14 @@ impl IdentMacroExpander for BasicIdentMacroExpander {
cx: &mut ExtCtxt,
sp: Span,
ident: ast::Ident,
token_tree: ~[ast::TokenTree])
token_tree: Vec<ast::TokenTree> )
-> MacResult {
(self.expander)(cx, sp, ident, token_tree)
}
}
pub type IdentMacroExpanderFn =
fn(&mut ExtCtxt, Span, ast::Ident, ~[ast::TokenTree]) -> MacResult;
fn(&mut ExtCtxt, Span, ast::Ident, Vec<ast::TokenTree> ) -> MacResult;
pub type MacroCrateRegistrationFun =
fn(|ast::Name, SyntaxExtension|);
@ -154,13 +154,13 @@ impl BlockInfo {
pub fn new() -> BlockInfo {
BlockInfo {
macros_escape: false,
pending_renames: ~[],
pending_renames: Vec::new(),
}
}
}
// a list of ident->name renamings
pub type RenameList = ~[(ast::Ident,Name)];
pub type RenameList = Vec<(ast::Ident,Name)> ;
// The base map of methods for expanding syntax extension
// AST nodes into full ASTs
@ -271,7 +271,7 @@ pub struct MacroCrate {
pub trait CrateLoader {
fn load_crate(&mut self, krate: &ast::ViewItem) -> MacroCrate;
fn get_exported_macros(&mut self, crate_num: ast::CrateNum) -> ~[~str];
fn get_exported_macros(&mut self, crate_num: ast::CrateNum) -> Vec<~str> ;
fn get_registrar_symbol(&mut self, crate_num: ast::CrateNum) -> Option<~str>;
}
@ -284,7 +284,7 @@ pub struct ExtCtxt<'a> {
backtrace: Option<@ExpnInfo>,
loader: &'a mut CrateLoader,
mod_path: ~[ast::Ident],
mod_path: Vec<ast::Ident> ,
trace_mac: bool
}
@ -296,7 +296,7 @@ impl<'a> ExtCtxt<'a> {
cfg: cfg,
backtrace: None,
loader: loader,
mod_path: ~[],
mod_path: Vec::new(),
trace_mac: false
}
}
@ -329,7 +329,7 @@ impl<'a> ExtCtxt<'a> {
pub fn backtrace(&self) -> Option<@ExpnInfo> { self.backtrace }
pub fn mod_push(&mut self, i: ast::Ident) { self.mod_path.push(i); }
pub fn mod_pop(&mut self) { self.mod_path.pop().unwrap(); }
pub fn mod_path(&self) -> ~[ast::Ident] { self.mod_path.clone() }
pub fn mod_path(&self) -> Vec<ast::Ident> { self.mod_path.clone() }
pub fn bt_push(&mut self, ei: codemap::ExpnInfo) {
match ei {
ExpnInfo {call_site: cs, callee: ref callee} => {
@ -458,11 +458,11 @@ pub fn get_single_str_from_tts(cx: &ExtCtxt,
/// parsing error, emit a non-fatal error and return None.
pub fn get_exprs_from_tts(cx: &ExtCtxt,
sp: Span,
tts: &[ast::TokenTree]) -> Option<~[@ast::Expr]> {
tts: &[ast::TokenTree]) -> Option<Vec<@ast::Expr> > {
let mut p = parse::new_parser_from_tts(cx.parse_sess(),
cx.cfg(),
tts.to_owned());
let mut es = ~[];
let mut es = Vec::new();
while p.token != token::EOF {
if es.len() != 0 && !p.eat(&token::COMMA) {
cx.span_err(sp, "expected token: `,`");
@ -507,12 +507,12 @@ impl Drop for MapChainFrame {
// Only generic to make it easy to test
pub struct SyntaxEnv {
priv chain: ~[MapChainFrame],
priv chain: Vec<MapChainFrame> ,
}
impl SyntaxEnv {
pub fn new() -> SyntaxEnv {
let mut map = SyntaxEnv { chain: ~[] };
let mut map = SyntaxEnv { chain: Vec::new() };
map.push_frame();
map
}

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

@ -34,14 +34,14 @@ mod syntax {
pub trait AstBuilder {
// paths
fn path(&self, span: Span, strs: ~[ast::Ident]) -> ast::Path;
fn path(&self, span: Span, strs: Vec<ast::Ident> ) -> ast::Path;
fn path_ident(&self, span: Span, id: ast::Ident) -> ast::Path;
fn path_global(&self, span: Span, strs: ~[ast::Ident]) -> ast::Path;
fn path_global(&self, span: Span, strs: Vec<ast::Ident> ) -> ast::Path;
fn path_all(&self, sp: Span,
global: bool,
idents: ~[ast::Ident],
idents: Vec<ast::Ident> ,
lifetimes: OptVec<ast::Lifetime>,
types: ~[P<ast::Ty>])
types: Vec<P<ast::Ty>> )
-> ast::Path;
// types
@ -61,8 +61,8 @@ 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>) -> ~[P<ast::Ty>];
fn ty_vars_global(&self, ty_params: &OptVec<ast::TyParam>) -> ~[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_field_imm(&self, span: Span, name: Ident, ty: P<ast::Ty>) -> ast::TypeField;
fn strip_bounds(&self, bounds: &Generics) -> Generics;
@ -87,11 +87,11 @@ pub trait AstBuilder {
-> @ast::Stmt;
// blocks
fn block(&self, span: Span, stmts: ~[@ast::Stmt], expr: Option<@ast::Expr>) -> P<ast::Block>;
fn block(&self, span: Span, stmts: Vec<@ast::Stmt> , expr: Option<@ast::Expr>) -> P<ast::Block>;
fn block_expr(&self, expr: @ast::Expr) -> P<ast::Block>;
fn block_all(&self, span: Span,
view_items: ~[ast::ViewItem],
stmts: ~[@ast::Stmt],
view_items: Vec<ast::ViewItem> ,
stmts: Vec<@ast::Stmt> ,
expr: Option<@ast::Expr>) -> P<ast::Block>;
// expressions
@ -109,19 +109,19 @@ pub trait AstBuilder {
fn expr_addr_of(&self, sp: Span, e: @ast::Expr) -> @ast::Expr;
fn expr_mut_addr_of(&self, sp: Span, e: @ast::Expr) -> @ast::Expr;
fn expr_field_access(&self, span: Span, expr: @ast::Expr, ident: ast::Ident) -> @ast::Expr;
fn expr_call(&self, span: Span, expr: @ast::Expr, args: ~[@ast::Expr]) -> @ast::Expr;
fn expr_call_ident(&self, span: Span, id: ast::Ident, args: ~[@ast::Expr]) -> @ast::Expr;
fn expr_call_global(&self, sp: Span, fn_path: ~[ast::Ident],
args: ~[@ast::Expr]) -> @ast::Expr;
fn expr_call(&self, span: Span, expr: @ast::Expr, args: Vec<@ast::Expr> ) -> @ast::Expr;
fn expr_call_ident(&self, span: Span, id: ast::Ident, args: Vec<@ast::Expr> ) -> @ast::Expr;
fn expr_call_global(&self, sp: Span, fn_path: Vec<ast::Ident> ,
args: Vec<@ast::Expr> ) -> @ast::Expr;
fn expr_method_call(&self, span: Span,
expr: @ast::Expr, ident: ast::Ident,
args: ~[@ast::Expr]) -> @ast::Expr;
args: Vec<@ast::Expr> ) -> @ast::Expr;
fn expr_block(&self, b: P<ast::Block>) -> @ast::Expr;
fn expr_cast(&self, sp: Span, expr: @ast::Expr, ty: P<ast::Ty>) -> @ast::Expr;
fn field_imm(&self, span: Span, name: Ident, e: @ast::Expr) -> ast::Field;
fn expr_struct(&self, span: Span, path: ast::Path, fields: ~[ast::Field]) -> @ast::Expr;
fn expr_struct_ident(&self, span: Span, id: ast::Ident, fields: ~[ast::Field]) -> @ast::Expr;
fn expr_struct(&self, span: Span, path: ast::Path, fields: Vec<ast::Field> ) -> @ast::Expr;
fn expr_struct_ident(&self, span: Span, id: ast::Ident, fields: Vec<ast::Field> ) -> @ast::Expr;
fn expr_lit(&self, sp: Span, lit: ast::Lit_) -> @ast::Expr;
@ -131,9 +131,9 @@ pub trait AstBuilder {
fn expr_bool(&self, sp: Span, value: bool) -> @ast::Expr;
fn expr_vstore(&self, sp: Span, expr: @ast::Expr, vst: ast::ExprVstore) -> @ast::Expr;
fn expr_vec(&self, sp: Span, exprs: ~[@ast::Expr]) -> @ast::Expr;
fn expr_vec_uniq(&self, sp: Span, exprs: ~[@ast::Expr]) -> @ast::Expr;
fn expr_vec_slice(&self, sp: Span, exprs: ~[@ast::Expr]) -> @ast::Expr;
fn expr_vec(&self, sp: Span, exprs: Vec<@ast::Expr> ) -> @ast::Expr;
fn expr_vec_uniq(&self, sp: Span, exprs: Vec<@ast::Expr> ) -> @ast::Expr;
fn expr_vec_slice(&self, sp: Span, exprs: Vec<@ast::Expr> ) -> @ast::Expr;
fn expr_str(&self, sp: Span, s: InternedString) -> @ast::Expr;
fn expr_str_uniq(&self, sp: Span, s: InternedString) -> @ast::Expr;
@ -152,55 +152,55 @@ pub trait AstBuilder {
span: Span,
ident: ast::Ident,
bm: ast::BindingMode) -> @ast::Pat;
fn pat_enum(&self, span: Span, path: ast::Path, subpats: ~[@ast::Pat]) -> @ast::Pat;
fn pat_enum(&self, span: Span, path: ast::Path, subpats: Vec<@ast::Pat> ) -> @ast::Pat;
fn pat_struct(&self, span: Span,
path: ast::Path, field_pats: ~[ast::FieldPat]) -> @ast::Pat;
path: ast::Path, field_pats: Vec<ast::FieldPat> ) -> @ast::Pat;
fn arm(&self, span: Span, pats: ~[@ast::Pat], expr: @ast::Expr) -> ast::Arm;
fn arm(&self, span: Span, pats: Vec<@ast::Pat> , expr: @ast::Expr) -> ast::Arm;
fn arm_unreachable(&self, span: Span) -> ast::Arm;
fn expr_match(&self, span: Span, arg: @ast::Expr, arms: ~[ast::Arm]) -> @ast::Expr;
fn expr_match(&self, span: Span, arg: @ast::Expr, arms: Vec<ast::Arm> ) -> @ast::Expr;
fn expr_if(&self, span: Span,
cond: @ast::Expr, then: @ast::Expr, els: Option<@ast::Expr>) -> @ast::Expr;
fn lambda_fn_decl(&self, span: Span,
fn_decl: P<ast::FnDecl>, blk: P<ast::Block>) -> @ast::Expr;
fn lambda(&self, span: Span, ids: ~[ast::Ident], blk: P<ast::Block>) -> @ast::Expr;
fn lambda(&self, span: Span, ids: Vec<ast::Ident> , blk: P<ast::Block>) -> @ast::Expr;
fn lambda0(&self, span: Span, blk: P<ast::Block>) -> @ast::Expr;
fn lambda1(&self, span: Span, blk: P<ast::Block>, ident: ast::Ident) -> @ast::Expr;
fn lambda_expr(&self, span: Span, ids: ~[ast::Ident], blk: @ast::Expr) -> @ast::Expr;
fn lambda_expr(&self, span: Span, ids: Vec<ast::Ident> , blk: @ast::Expr) -> @ast::Expr;
fn lambda_expr_0(&self, span: Span, expr: @ast::Expr) -> @ast::Expr;
fn lambda_expr_1(&self, span: Span, expr: @ast::Expr, ident: ast::Ident) -> @ast::Expr;
fn lambda_stmts(&self, span: Span, ids: ~[ast::Ident], blk: ~[@ast::Stmt]) -> @ast::Expr;
fn lambda_stmts_0(&self, span: Span, stmts: ~[@ast::Stmt]) -> @ast::Expr;
fn lambda_stmts_1(&self, span: Span, stmts: ~[@ast::Stmt], ident: ast::Ident) -> @ast::Expr;
fn lambda_stmts(&self, span: Span, ids: Vec<ast::Ident> , blk: Vec<@ast::Stmt> ) -> @ast::Expr;
fn lambda_stmts_0(&self, span: Span, stmts: Vec<@ast::Stmt> ) -> @ast::Expr;
fn lambda_stmts_1(&self, span: Span, stmts: Vec<@ast::Stmt> , ident: ast::Ident) -> @ast::Expr;
// items
fn item(&self, span: Span,
name: Ident, attrs: ~[ast::Attribute], node: ast::Item_) -> @ast::Item;
name: Ident, attrs: Vec<ast::Attribute> , node: ast::Item_) -> @ast::Item;
fn arg(&self, span: Span, name: Ident, ty: P<ast::Ty>) -> ast::Arg;
// FIXME unused self
fn fn_decl(&self, inputs: ~[ast::Arg], output: P<ast::Ty>) -> P<ast::FnDecl>;
fn fn_decl(&self, inputs: Vec<ast::Arg> , output: P<ast::Ty>) -> P<ast::FnDecl>;
fn item_fn_poly(&self,
span: Span,
name: Ident,
inputs: ~[ast::Arg],
inputs: Vec<ast::Arg> ,
output: P<ast::Ty>,
generics: Generics,
body: P<ast::Block>) -> @ast::Item;
fn item_fn(&self,
span: Span,
name: Ident,
inputs: ~[ast::Arg],
inputs: Vec<ast::Arg> ,
output: P<ast::Ty>,
body: P<ast::Block>) -> @ast::Item;
fn variant(&self, span: Span, name: Ident, tys: ~[P<ast::Ty>]) -> ast::Variant;
fn variant(&self, span: Span, name: Ident, tys: Vec<P<ast::Ty>> ) -> ast::Variant;
fn item_enum_poly(&self,
span: Span,
name: Ident,
@ -216,8 +216,8 @@ pub trait AstBuilder {
fn item_struct(&self, span: Span, name: Ident, struct_def: ast::StructDef) -> @ast::Item;
fn item_mod(&self, span: Span,
name: Ident, attrs: ~[ast::Attribute],
vi: ~[ast::ViewItem], items: ~[@ast::Item]) -> @ast::Item;
name: Ident, attrs: Vec<ast::Attribute> ,
vi: Vec<ast::ViewItem> , items: Vec<@ast::Item> ) -> @ast::Item;
fn item_ty_poly(&self,
span: Span,
@ -232,7 +232,7 @@ pub trait AstBuilder {
fn meta_list(&self,
sp: Span,
name: InternedString,
mis: ~[@ast::MetaItem])
mis: Vec<@ast::MetaItem> )
-> @ast::MetaItem;
fn meta_name_value(&self,
sp: Span,
@ -241,35 +241,35 @@ pub trait AstBuilder {
-> @ast::MetaItem;
fn view_use(&self, sp: Span,
vis: ast::Visibility, vp: ~[@ast::ViewPath]) -> ast::ViewItem;
vis: ast::Visibility, vp: Vec<@ast::ViewPath> ) -> ast::ViewItem;
fn view_use_simple(&self, sp: Span, vis: ast::Visibility, path: ast::Path) -> ast::ViewItem;
fn view_use_simple_(&self, sp: Span, vis: ast::Visibility,
ident: ast::Ident, path: ast::Path) -> ast::ViewItem;
fn view_use_list(&self, sp: Span, vis: ast::Visibility,
path: ~[ast::Ident], imports: &[ast::Ident]) -> ast::ViewItem;
path: Vec<ast::Ident> , imports: &[ast::Ident]) -> ast::ViewItem;
fn view_use_glob(&self, sp: Span,
vis: ast::Visibility, path: ~[ast::Ident]) -> ast::ViewItem;
vis: ast::Visibility, path: Vec<ast::Ident> ) -> ast::ViewItem;
}
impl<'a> AstBuilder for ExtCtxt<'a> {
fn path(&self, span: Span, strs: ~[ast::Ident]) -> ast::Path {
self.path_all(span, false, strs, opt_vec::Empty, ~[])
fn path(&self, span: Span, strs: Vec<ast::Ident> ) -> ast::Path {
self.path_all(span, false, strs, opt_vec::Empty, Vec::new())
}
fn path_ident(&self, span: Span, id: ast::Ident) -> ast::Path {
self.path(span, ~[id])
self.path(span, vec!(id))
}
fn path_global(&self, span: Span, strs: ~[ast::Ident]) -> ast::Path {
self.path_all(span, true, strs, opt_vec::Empty, ~[])
fn path_global(&self, span: Span, strs: Vec<ast::Ident> ) -> ast::Path {
self.path_all(span, true, strs, opt_vec::Empty, Vec::new())
}
fn path_all(&self,
sp: Span,
global: bool,
mut idents: ~[ast::Ident],
mut idents: Vec<ast::Ident> ,
lifetimes: OptVec<ast::Lifetime>,
types: ~[P<ast::Ty>])
types: Vec<P<ast::Ty>> )
-> ast::Path {
let last_identifier = idents.pop().unwrap();
let mut segments: ~[ast::PathSegment] = idents.move_iter()
let mut segments: Vec<ast::PathSegment> = idents.move_iter()
.map(|ident| {
ast::PathSegment {
identifier: ident,
@ -335,13 +335,13 @@ impl<'a> AstBuilder for ExtCtxt<'a> {
self.ty_path(
self.path_all(DUMMY_SP,
true,
~[
vec!(
self.ident_of("std"),
self.ident_of("option"),
self.ident_of("Option")
],
),
opt_vec::Empty,
~[ ty ]), None)
vec!( ty )), None)
}
fn ty_field_imm(&self, span: Span, name: Ident, ty: P<ast::Ty>) -> ast::TypeField {
@ -379,15 +379,15 @@ 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>) -> ~[P<ast::Ty>] {
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_global(&self, ty_params: &OptVec<ast::TyParam>) -> ~[P<ast::Ty>] {
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, ~[p.ident]), None)))
self.path_global(DUMMY_SP, vec!(p.ident)), None)))
}
fn strip_bounds(&self, generics: &Generics) -> Generics {
@ -459,17 +459,17 @@ impl<'a> AstBuilder for ExtCtxt<'a> {
@respan(sp, ast::StmtDecl(@decl, ast::DUMMY_NODE_ID))
}
fn block(&self, span: Span, stmts: ~[@ast::Stmt], expr: Option<@Expr>) -> P<ast::Block> {
self.block_all(span, ~[], stmts, expr)
fn block(&self, span: Span, stmts: Vec<@ast::Stmt> , expr: Option<@Expr>) -> P<ast::Block> {
self.block_all(span, Vec::new(), stmts, expr)
}
fn block_expr(&self, expr: @ast::Expr) -> P<ast::Block> {
self.block_all(expr.span, ~[], ~[], Some(expr))
self.block_all(expr.span, Vec::new(), Vec::new(), Some(expr))
}
fn block_all(&self,
span: Span,
view_items: ~[ast::ViewItem],
stmts: ~[@ast::Stmt],
view_items: Vec<ast::ViewItem> ,
stmts: Vec<@ast::Stmt> ,
expr: Option<@ast::Expr>) -> P<ast::Block> {
P(ast::Block {
view_items: view_items,
@ -517,7 +517,7 @@ impl<'a> AstBuilder for ExtCtxt<'a> {
}
fn expr_field_access(&self, sp: Span, expr: @ast::Expr, ident: ast::Ident) -> @ast::Expr {
self.expr(sp, ast::ExprField(expr, ident, ~[]))
self.expr(sp, ast::ExprField(expr, ident, Vec::new()))
}
fn expr_addr_of(&self, sp: Span, e: @ast::Expr) -> @ast::Expr {
self.expr(sp, ast::ExprAddrOf(ast::MutImmutable, e))
@ -526,23 +526,23 @@ impl<'a> AstBuilder for ExtCtxt<'a> {
self.expr(sp, ast::ExprAddrOf(ast::MutMutable, e))
}
fn expr_call(&self, span: Span, expr: @ast::Expr, args: ~[@ast::Expr]) -> @ast::Expr {
fn expr_call(&self, span: Span, expr: @ast::Expr, args: Vec<@ast::Expr> ) -> @ast::Expr {
self.expr(span, ast::ExprCall(expr, args))
}
fn expr_call_ident(&self, span: Span, id: ast::Ident, args: ~[@ast::Expr]) -> @ast::Expr {
fn expr_call_ident(&self, span: Span, id: ast::Ident, args: Vec<@ast::Expr> ) -> @ast::Expr {
self.expr(span, ast::ExprCall(self.expr_ident(span, id), args))
}
fn expr_call_global(&self, sp: Span, fn_path: ~[ast::Ident],
args: ~[@ast::Expr]) -> @ast::Expr {
fn expr_call_global(&self, sp: Span, fn_path: Vec<ast::Ident> ,
args: Vec<@ast::Expr> ) -> @ast::Expr {
let pathexpr = self.expr_path(self.path_global(sp, fn_path));
self.expr_call(sp, pathexpr, args)
}
fn expr_method_call(&self, span: Span,
expr: @ast::Expr,
ident: ast::Ident,
mut args: ~[@ast::Expr]) -> @ast::Expr {
mut args: Vec<@ast::Expr> ) -> @ast::Expr {
args.unshift(expr);
self.expr(span, ast::ExprMethodCall(ident, ~[], args))
self.expr(span, ast::ExprMethodCall(ident, Vec::new(), args))
}
fn expr_block(&self, b: P<ast::Block>) -> @ast::Expr {
self.expr(b.span, ast::ExprBlock(b))
@ -550,11 +550,11 @@ impl<'a> AstBuilder for ExtCtxt<'a> {
fn field_imm(&self, span: Span, name: Ident, e: @ast::Expr) -> ast::Field {
ast::Field { ident: respan(span, name), expr: e, span: span }
}
fn expr_struct(&self, span: Span, path: ast::Path, fields: ~[ast::Field]) -> @ast::Expr {
fn expr_struct(&self, span: Span, path: ast::Path, fields: Vec<ast::Field> ) -> @ast::Expr {
self.expr(span, ast::ExprStruct(path, fields, None))
}
fn expr_struct_ident(&self, span: Span,
id: ast::Ident, fields: ~[ast::Field]) -> @ast::Expr {
id: ast::Ident, fields: Vec<ast::Field> ) -> @ast::Expr {
self.expr_struct(span, self.path_ident(span, id), fields)
}
@ -577,13 +577,13 @@ impl<'a> AstBuilder for ExtCtxt<'a> {
fn expr_vstore(&self, sp: Span, expr: @ast::Expr, vst: ast::ExprVstore) -> @ast::Expr {
self.expr(sp, ast::ExprVstore(expr, vst))
}
fn expr_vec(&self, sp: Span, exprs: ~[@ast::Expr]) -> @ast::Expr {
fn expr_vec(&self, sp: Span, exprs: Vec<@ast::Expr> ) -> @ast::Expr {
self.expr(sp, ast::ExprVec(exprs, ast::MutImmutable))
}
fn expr_vec_uniq(&self, sp: Span, exprs: ~[@ast::Expr]) -> @ast::Expr {
fn expr_vec_uniq(&self, sp: Span, exprs: Vec<@ast::Expr> ) -> @ast::Expr {
self.expr_vstore(sp, self.expr_vec(sp, exprs), ast::ExprVstoreUniq)
}
fn expr_vec_slice(&self, sp: Span, exprs: ~[@ast::Expr]) -> @ast::Expr {
fn expr_vec_slice(&self, sp: Span, exprs: Vec<@ast::Expr> ) -> @ast::Expr {
self.expr_vstore(sp, self.expr_vec(sp, exprs), ast::ExprVstoreSlice)
}
fn expr_str(&self, sp: Span, s: InternedString) -> @ast::Expr {
@ -600,20 +600,18 @@ impl<'a> AstBuilder for ExtCtxt<'a> {
fn expr_some(&self, sp: Span, expr: @ast::Expr) -> @ast::Expr {
let some = ~[
let some = vec!(
self.ident_of("std"),
self.ident_of("option"),
self.ident_of("Some"),
];
self.expr_call_global(sp, some, ~[expr])
self.ident_of("Some"));
self.expr_call_global(sp, some, vec!(expr))
}
fn expr_none(&self, sp: Span) -> @ast::Expr {
let none = self.path_global(sp, ~[
let none = self.path_global(sp, vec!(
self.ident_of("std"),
self.ident_of("option"),
self.ident_of("None"),
]);
self.ident_of("None")));
self.expr_path(none)
}
@ -621,17 +619,15 @@ impl<'a> AstBuilder for ExtCtxt<'a> {
let loc = self.codemap().lookup_char_pos(span.lo);
self.expr_call_global(
span,
~[
vec!(
self.ident_of("std"),
self.ident_of("rt"),
self.ident_of("begin_unwind"),
],
~[
self.ident_of("begin_unwind")),
vec!(
self.expr_str(span, msg),
self.expr_str(span,
token::intern_and_get_ident(loc.file.name)),
self.expr_uint(span, loc.line),
])
self.expr_uint(span, loc.line)))
}
fn expr_unreachable(&self, span: Span) -> @ast::Expr {
@ -662,17 +658,17 @@ impl<'a> AstBuilder for ExtCtxt<'a> {
let pat = ast::PatIdent(bm, path, None);
self.pat(span, pat)
}
fn pat_enum(&self, span: Span, path: ast::Path, subpats: ~[@ast::Pat]) -> @ast::Pat {
fn pat_enum(&self, span: Span, path: ast::Path, subpats: Vec<@ast::Pat> ) -> @ast::Pat {
let pat = ast::PatEnum(path, Some(subpats));
self.pat(span, pat)
}
fn pat_struct(&self, span: Span,
path: ast::Path, field_pats: ~[ast::FieldPat]) -> @ast::Pat {
path: ast::Path, field_pats: Vec<ast::FieldPat> ) -> @ast::Pat {
let pat = ast::PatStruct(path, field_pats, false);
self.pat(span, pat)
}
fn arm(&self, _span: Span, pats: ~[@ast::Pat], expr: @ast::Expr) -> ast::Arm {
fn arm(&self, _span: Span, pats: Vec<@ast::Pat> , expr: @ast::Expr) -> ast::Arm {
ast::Arm {
pats: pats,
guard: None,
@ -681,10 +677,10 @@ impl<'a> AstBuilder for ExtCtxt<'a> {
}
fn arm_unreachable(&self, span: Span) -> ast::Arm {
self.arm(span, ~[self.pat_wild(span)], self.expr_unreachable(span))
self.arm(span, vec!(self.pat_wild(span)), self.expr_unreachable(span))
}
fn expr_match(&self, span: Span, arg: @ast::Expr, arms: ~[ast::Arm]) -> @Expr {
fn expr_match(&self, span: Span, arg: @ast::Expr, arms: Vec<ast::Arm> ) -> @Expr {
self.expr(span, ast::ExprMatch(arg, arms))
}
@ -698,7 +694,7 @@ impl<'a> AstBuilder for ExtCtxt<'a> {
fn_decl: P<ast::FnDecl>, blk: P<ast::Block>) -> @ast::Expr {
self.expr(span, ast::ExprFnBlock(fn_decl, blk))
}
fn lambda(&self, span: Span, ids: ~[ast::Ident], blk: P<ast::Block>) -> @ast::Expr {
fn lambda(&self, span: Span, ids: Vec<ast::Ident> , blk: P<ast::Block>) -> @ast::Expr {
let fn_decl = self.fn_decl(
ids.map(|id| self.arg(span, *id, self.ty_infer(span))),
self.ty_infer(span));
@ -715,7 +711,7 @@ impl<'a> AstBuilder for ExtCtxt<'a> {
quote_expr!(self, |$ident| $blk_e )
}
fn lambda_expr(&self, span: Span, ids: ~[ast::Ident], expr: @ast::Expr) -> @ast::Expr {
fn lambda_expr(&self, span: Span, ids: Vec<ast::Ident> , expr: @ast::Expr) -> @ast::Expr {
self.lambda(span, ids, self.block_expr(expr))
}
fn lambda_expr_0(&self, span: Span, expr: @ast::Expr) -> @ast::Expr {
@ -725,13 +721,13 @@ impl<'a> AstBuilder for ExtCtxt<'a> {
self.lambda1(span, self.block_expr(expr), ident)
}
fn lambda_stmts(&self, span: Span, ids: ~[ast::Ident], stmts: ~[@ast::Stmt]) -> @ast::Expr {
fn lambda_stmts(&self, span: Span, ids: Vec<ast::Ident> , stmts: Vec<@ast::Stmt> ) -> @ast::Expr {
self.lambda(span, ids, self.block(span, stmts, None))
}
fn lambda_stmts_0(&self, span: Span, stmts: ~[@ast::Stmt]) -> @ast::Expr {
fn lambda_stmts_0(&self, span: Span, stmts: Vec<@ast::Stmt> ) -> @ast::Expr {
self.lambda0(span, self.block(span, stmts, None))
}
fn lambda_stmts_1(&self, span: Span, stmts: ~[@ast::Stmt], ident: ast::Ident) -> @ast::Expr {
fn lambda_stmts_1(&self, span: Span, stmts: Vec<@ast::Stmt> , ident: ast::Ident) -> @ast::Expr {
self.lambda1(span, self.block(span, stmts, None), ident)
}
@ -745,7 +741,7 @@ impl<'a> AstBuilder for ExtCtxt<'a> {
}
// FIXME unused self
fn fn_decl(&self, inputs: ~[ast::Arg], output: P<ast::Ty>) -> P<ast::FnDecl> {
fn fn_decl(&self, inputs: Vec<ast::Arg> , output: P<ast::Ty>) -> P<ast::FnDecl> {
P(ast::FnDecl {
inputs: inputs,
output: output,
@ -755,7 +751,7 @@ impl<'a> AstBuilder for ExtCtxt<'a> {
}
fn item(&self, span: Span,
name: Ident, attrs: ~[ast::Attribute], node: ast::Item_) -> @ast::Item {
name: Ident, attrs: Vec<ast::Attribute> , node: ast::Item_) -> @ast::Item {
// FIXME: Would be nice if our generated code didn't violate
// Rust coding conventions
@ast::Item { ident: name,
@ -769,13 +765,13 @@ impl<'a> AstBuilder for ExtCtxt<'a> {
fn item_fn_poly(&self,
span: Span,
name: Ident,
inputs: ~[ast::Arg],
inputs: Vec<ast::Arg> ,
output: P<ast::Ty>,
generics: Generics,
body: P<ast::Block>) -> @ast::Item {
self.item(span,
name,
~[],
Vec::new(),
ast::ItemFn(self.fn_decl(inputs, output),
ast::ImpureFn,
AbiSet::Rust(),
@ -786,7 +782,7 @@ impl<'a> AstBuilder for ExtCtxt<'a> {
fn item_fn(&self,
span: Span,
name: Ident,
inputs: ~[ast::Arg],
inputs: Vec<ast::Arg> ,
output: P<ast::Ty>,
body: P<ast::Block>
) -> @ast::Item {
@ -799,7 +795,7 @@ impl<'a> AstBuilder for ExtCtxt<'a> {
body)
}
fn variant(&self, span: Span, name: Ident, tys: ~[P<ast::Ty>]) -> ast::Variant {
fn variant(&self, span: Span, name: Ident, tys: Vec<P<ast::Ty>> ) -> ast::Variant {
let args = tys.move_iter().map(|ty| {
ast::VariantArg { ty: ty, id: ast::DUMMY_NODE_ID }
}).collect();
@ -807,7 +803,7 @@ impl<'a> AstBuilder for ExtCtxt<'a> {
respan(span,
ast::Variant_ {
name: name,
attrs: ~[],
attrs: Vec::new(),
kind: ast::TupleVariantKind(args),
id: ast::DUMMY_NODE_ID,
disr_expr: None,
@ -818,7 +814,7 @@ impl<'a> AstBuilder for ExtCtxt<'a> {
fn item_enum_poly(&self, span: Span, name: Ident,
enum_definition: ast::EnumDef,
generics: Generics) -> @ast::Item {
self.item(span, name, ~[], ast::ItemEnum(enum_definition, generics))
self.item(span, name, Vec::new(), ast::ItemEnum(enum_definition, generics))
}
fn item_enum(&self, span: Span, name: Ident,
@ -839,13 +835,13 @@ impl<'a> AstBuilder for ExtCtxt<'a> {
fn item_struct_poly(&self, span: Span, name: Ident,
struct_def: ast::StructDef, generics: Generics) -> @ast::Item {
self.item(span, name, ~[], ast::ItemStruct(@struct_def, generics))
self.item(span, name, Vec::new(), ast::ItemStruct(@struct_def, generics))
}
fn item_mod(&self, span: Span, name: Ident,
attrs: ~[ast::Attribute],
vi: ~[ast::ViewItem],
items: ~[@ast::Item]) -> @ast::Item {
attrs: Vec<ast::Attribute> ,
vi: Vec<ast::ViewItem> ,
items: Vec<@ast::Item> ) -> @ast::Item {
self.item(
span,
name,
@ -859,7 +855,7 @@ impl<'a> AstBuilder for ExtCtxt<'a> {
fn item_ty_poly(&self, span: Span, name: Ident, ty: P<ast::Ty>,
generics: Generics) -> @ast::Item {
self.item(span, name, ~[], ast::ItemTy(ty, generics))
self.item(span, name, Vec::new(), ast::ItemTy(ty, generics))
}
fn item_ty(&self, span: Span, name: Ident, ty: P<ast::Ty>) -> @ast::Item {
@ -880,7 +876,7 @@ impl<'a> AstBuilder for ExtCtxt<'a> {
fn meta_list(&self,
sp: Span,
name: InternedString,
mis: ~[@ast::MetaItem])
mis: Vec<@ast::MetaItem> )
-> @ast::MetaItem {
@respan(sp, ast::MetaList(name, mis))
}
@ -893,10 +889,10 @@ impl<'a> AstBuilder for ExtCtxt<'a> {
}
fn view_use(&self, sp: Span,
vis: ast::Visibility, vp: ~[@ast::ViewPath]) -> ast::ViewItem {
vis: ast::Visibility, vp: Vec<@ast::ViewPath> ) -> ast::ViewItem {
ast::ViewItem {
node: ast::ViewItemUse(vp),
attrs: ~[],
attrs: Vec::new(),
vis: vis,
span: sp
}
@ -910,30 +906,30 @@ impl<'a> AstBuilder for ExtCtxt<'a> {
fn view_use_simple_(&self, sp: Span, vis: ast::Visibility,
ident: ast::Ident, path: ast::Path) -> ast::ViewItem {
self.view_use(sp, vis,
~[@respan(sp,
vec!(@respan(sp,
ast::ViewPathSimple(ident,
path,
ast::DUMMY_NODE_ID))])
ast::DUMMY_NODE_ID))))
}
fn view_use_list(&self, sp: Span, vis: ast::Visibility,
path: ~[ast::Ident], imports: &[ast::Ident]) -> ast::ViewItem {
path: Vec<ast::Ident> , imports: &[ast::Ident]) -> ast::ViewItem {
let imports = imports.map(|id| {
respan(sp, ast::PathListIdent_ { name: *id, id: ast::DUMMY_NODE_ID })
});
self.view_use(sp, vis,
~[@respan(sp,
vec!(@respan(sp,
ast::ViewPathList(self.path(sp, path),
imports,
ast::DUMMY_NODE_ID))])
ast::DUMMY_NODE_ID))))
}
fn view_use_glob(&self, sp: Span,
vis: ast::Visibility, path: ~[ast::Ident]) -> ast::ViewItem {
vis: ast::Visibility, path: Vec<ast::Ident> ) -> ast::ViewItem {
self.view_use(sp, vis,
~[@respan(sp,
ast::ViewPathGlob(self.path(sp, path), ast::DUMMY_NODE_ID))])
vec!(@respan(sp,
ast::ViewPathGlob(self.path(sp, path), ast::DUMMY_NODE_ID))))
}
}

2
src/libsyntax/ext/bytes.rs
View file

@ -24,7 +24,7 @@ pub fn expand_syntax_ext(cx: &mut ExtCtxt, sp: Span, tts: &[ast::TokenTree]) ->
None => return MacResult::dummy_expr(sp),
Some(e) => e,
};
let mut bytes = ~[];
let mut bytes = Vec::new();
for expr in exprs.iter() {
match expr.node {

2
src/libsyntax/ext/cfg.rs
View file

@ -31,7 +31,7 @@ pub fn expand_cfg(cx: &mut ExtCtxt, sp: Span, tts: &[ast::TokenTree]) -> base::M
cx.cfg(),
tts.to_owned());
let mut cfgs = ~[];
let mut cfgs = Vec::new();
// parse `cfg!(meta_item, meta_item(x,y), meta_item="foo", ...)`
while p.token != token::EOF {
cfgs.push(p.parse_meta_item());

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

@ -48,13 +48,13 @@ pub fn expand_syntax_ext(cx: &mut ExtCtxt, sp: Span, tts: &[ast::TokenTree])
ast::Path {
span: sp,
global: false,
segments: ~[
segments: vec!(
ast::PathSegment {
identifier: res,
lifetimes: opt_vec::Empty,
types: opt_vec::Empty,
}
]
)
}
),
span: sp,

26
src/libsyntax/ext/deriving/clone.rs
View file

@ -21,22 +21,22 @@ pub fn expand_deriving_clone(cx: &mut ExtCtxt,
push: |@Item|) {
let trait_def = TraitDef {
span: span,
attributes: ~[],
path: Path::new(~["std", "clone", "Clone"]),
additional_bounds: ~[],
attributes: Vec::new(),
path: Path::new(vec!("std", "clone", "Clone")),
additional_bounds: Vec::new(),
generics: LifetimeBounds::empty(),
methods: ~[
methods: vec!(
MethodDef {
name: "clone",
generics: LifetimeBounds::empty(),
explicit_self: borrowed_explicit_self(),
args: ~[],
args: Vec::new(),
ret_ty: Self,
inline: true,
const_nonmatching: false,
combine_substructure: |c, s, sub| cs_clone("Clone", c, s, sub)
}
]
)
};
trait_def.expand(cx, mitem, item, push)
@ -49,16 +49,16 @@ pub fn expand_deriving_deep_clone(cx: &mut ExtCtxt,
push: |@Item|) {
let trait_def = TraitDef {
span: span,
attributes: ~[],
path: Path::new(~["std", "clone", "DeepClone"]),
additional_bounds: ~[],
attributes: Vec::new(),
path: Path::new(vec!("std", "clone", "DeepClone")),
additional_bounds: Vec::new(),
generics: LifetimeBounds::empty(),
methods: ~[
methods: vec!(
MethodDef {
name: "deep_clone",
generics: LifetimeBounds::empty(),
explicit_self: borrowed_explicit_self(),
args: ~[],
args: Vec::new(),
ret_ty: Self,
inline: true,
const_nonmatching: false,
@ -66,7 +66,7 @@ pub fn expand_deriving_deep_clone(cx: &mut ExtCtxt,
// call deep_clone (not clone) here.
combine_substructure: |c, s, sub| cs_clone("DeepClone", c, s, sub)
}
]
)
};
trait_def.expand(cx, mitem, item, push)
@ -80,7 +80,7 @@ fn cs_clone(
let ctor_ident;
let all_fields;
let subcall = |field: &FieldInfo|
cx.expr_method_call(field.span, field.self_, clone_ident, ~[]);
cx.expr_method_call(field.span, field.self_, clone_ident, Vec::new());
match *substr.fields {
Struct(ref af) => {

14
src/libsyntax/ext/deriving/cmp/eq.rs
View file

@ -36,8 +36,8 @@ pub fn expand_deriving_eq(cx: &mut ExtCtxt,
name: $name,
generics: LifetimeBounds::empty(),
explicit_self: borrowed_explicit_self(),
args: ~[borrowed_self()],
ret_ty: Literal(Path::new(~["bool"])),
args: vec!(borrowed_self()),
ret_ty: Literal(Path::new(vec!("bool"))),
inline: true,
const_nonmatching: true,
combine_substructure: $f
@ -47,14 +47,14 @@ pub fn expand_deriving_eq(cx: &mut ExtCtxt,
let trait_def = TraitDef {
span: span,
attributes: ~[],
path: Path::new(~["std", "cmp", "Eq"]),
additional_bounds: ~[],
attributes: Vec::new(),
path: Path::new(vec!("std", "cmp", "Eq")),
additional_bounds: Vec::new(),
generics: LifetimeBounds::empty(),
methods: ~[
methods: vec!(
md!("eq", cs_eq),
md!("ne", cs_ne)
]
)
};
trait_def.expand(cx, mitem, item, push)
}

14
src/libsyntax/ext/deriving/cmp/ord.rs
View file

@ -26,8 +26,8 @@ pub fn expand_deriving_ord(cx: &mut ExtCtxt,
name: $name,
generics: LifetimeBounds::empty(),
explicit_self: borrowed_explicit_self(),
args: ~[borrowed_self()],
ret_ty: Literal(Path::new(~["bool"])),
args: vec!(borrowed_self()),
ret_ty: Literal(Path::new(vec!("bool"))),
inline: true,
const_nonmatching: false,
combine_substructure: |cx, span, substr| cs_op($op, $equal, cx, span, substr)
@ -37,16 +37,16 @@ pub fn expand_deriving_ord(cx: &mut ExtCtxt,
let trait_def = TraitDef {
span: span,
attributes: ~[],
path: Path::new(~["std", "cmp", "Ord"]),
additional_bounds: ~[],
attributes: Vec::new(),
path: Path::new(vec!("std", "cmp", "Ord")),
additional_bounds: Vec::new(),
generics: LifetimeBounds::empty(),
methods: ~[
methods: vec!(
md!("lt", true, false),
md!("le", true, true),
md!("gt", false, false),
md!("ge", false, true)
]
)
};
trait_def.expand(cx, mitem, item, push)
}

14
src/libsyntax/ext/deriving/cmp/totaleq.rs
View file

@ -26,22 +26,22 @@ pub fn expand_deriving_totaleq(cx: &mut ExtCtxt,
let trait_def = TraitDef {
span: span,
attributes: ~[],
path: Path::new(~["std", "cmp", "TotalEq"]),
additional_bounds: ~[],
attributes: Vec::new(),
path: Path::new(vec!("std", "cmp", "TotalEq")),
additional_bounds: Vec::new(),
generics: LifetimeBounds::empty(),
methods: ~[
methods: vec!(
MethodDef {
name: "equals",
generics: LifetimeBounds::empty(),
explicit_self: borrowed_explicit_self(),
args: ~[borrowed_self()],
ret_ty: Literal(Path::new(~["bool"])),
args: vec!(borrowed_self()),
ret_ty: Literal(Path::new(vec!("bool"))),
inline: true,
const_nonmatching: true,
combine_substructure: cs_equals
}
]
)
};
trait_def.expand(cx, mitem, item, push)
}

20
src/libsyntax/ext/deriving/cmp/totalord.rs
View file

@ -23,22 +23,22 @@ pub fn expand_deriving_totalord(cx: &mut ExtCtxt,
push: |@Item|) {
let trait_def = TraitDef {
span: span,
attributes: ~[],
path: Path::new(~["std", "cmp", "TotalOrd"]),
additional_bounds: ~[],
attributes: Vec::new(),
path: Path::new(vec!("std", "cmp", "TotalOrd")),
additional_bounds: Vec::new(),
generics: LifetimeBounds::empty(),
methods: ~[
methods: vec!(
MethodDef {
name: "cmp",
generics: LifetimeBounds::empty(),
explicit_self: borrowed_explicit_self(),
args: ~[borrowed_self()],
ret_ty: Literal(Path::new(~["std", "cmp", "Ordering"])),
args: vec!(borrowed_self()),
ret_ty: Literal(Path::new(vec!("std", "cmp", "Ordering"))),
inline: true,
const_nonmatching: false,
combine_substructure: cs_cmp
}
]
)
};
trait_def.expand(cx, mitem, item, push)
@ -52,9 +52,9 @@ pub fn ordering_const(cx: &mut ExtCtxt, span: Span, cnst: Ordering) -> ast::Path
Greater => "Greater"
};
cx.path_global(span,
~[cx.ident_of("std"),
vec!(cx.ident_of("std"),
cx.ident_of("cmp"),
cx.ident_of(cnst)])
cx.ident_of(cnst)))
}
pub fn cs_cmp(cx: &mut ExtCtxt, span: Span,
@ -99,7 +99,7 @@ pub fn cs_cmp(cx: &mut ExtCtxt, span: Span,
let if_ = cx.expr_if(span,
cond,
old, Some(cx.expr_ident(span, test_id)));
cx.expr_block(cx.block(span, ~[assign], Some(if_)))
cx.expr_block(cx.block(span, vec!(assign), Some(if_)))
},
cx.expr_path(equals_path.clone()),
|cx, span, list, _| {

51
src/libsyntax/ext/deriving/decodable.rs
View file

@ -28,27 +28,26 @@ pub fn expand_deriving_decodable(cx: &mut ExtCtxt,
push: |@Item|) {
let trait_def = TraitDef {
span: span,
attributes: ~[],
path: Path::new_(~["serialize", "Decodable"], None,
~[~Literal(Path::new_local("__D"))], true),
additional_bounds: ~[],
attributes: Vec::new(),
path: Path::new_(vec!("serialize", "Decodable"), None,
vec!(~Literal(Path::new_local("__D"))), true),
additional_bounds: Vec::new(),
generics: LifetimeBounds {
lifetimes: ~[],
bounds: ~[("__D", ~[Path::new(~["serialize", "Decoder"])])],
lifetimes: Vec::new(),
bounds: vec!(("__D", vec!(Path::new(vec!("serialize", "Decoder"))))),
},
methods: ~[
methods: vec!(
MethodDef {
name: "decode",
generics: LifetimeBounds::empty(),
explicit_self: None,
args: ~[Ptr(~Literal(Path::new_local("__D")),
Borrowed(None, MutMutable))],
args: vec!(Ptr(~Literal(Path::new_local("__D")),
Borrowed(None, MutMutable))),
ret_ty: Self,
inline: false,
const_nonmatching: true,
combine_substructure: decodable_substructure,
},
]
})
};
trait_def.expand(cx, mitem, item, push)
@ -57,13 +56,13 @@ pub fn expand_deriving_decodable(cx: &mut ExtCtxt,
fn decodable_substructure(cx: &mut ExtCtxt, trait_span: Span,
substr: &Substructure) -> @Expr {
let decoder = substr.nonself_args[0];
let recurse = ~[cx.ident_of("serialize"),
let recurse = vec!(cx.ident_of("serialize"),
cx.ident_of("Decodable"),
cx.ident_of("decode")];
cx.ident_of("decode"));
// throw an underscore in front to suppress unused variable warnings
let blkarg = cx.ident_of("_d");
let blkdecoder = cx.expr_ident(trait_span, blkarg);
let calldecode = cx.expr_call_global(trait_span, recurse, ~[blkdecoder]);
let calldecode = cx.expr_call_global(trait_span, recurse, vec!(blkdecoder));
let lambdadecode = cx.lambda_expr_1(trait_span, calldecode, blkarg);
return match *substr.fields {
@ -80,24 +79,24 @@ fn decodable_substructure(cx: &mut ExtCtxt, trait_span: Span,
summary,
|cx, span, name, field| {
cx.expr_method_call(span, blkdecoder, read_struct_field,
~[cx.expr_str(span, name),
vec!(cx.expr_str(span, name),
cx.expr_uint(span, field),
lambdadecode])
lambdadecode))
});
cx.expr_method_call(trait_span,
decoder,
cx.ident_of("read_struct"),
~[
vec!(
cx.expr_str(trait_span, token::get_ident(substr.type_ident)),
cx.expr_uint(trait_span, nfields),
cx.lambda_expr_1(trait_span, result, blkarg)
])
))
}
StaticEnum(_, ref fields) => {
let variant = cx.ident_of("i");
let mut arms = ~[];
let mut variants = ~[];
let mut arms = Vec::new();
let mut variants = Vec::new();
let rvariant_arg = cx.ident_of("read_enum_variant_arg");
for (i, &(name, v_span, ref parts)) in fields.iter().enumerate() {
@ -110,29 +109,29 @@ fn decodable_substructure(cx: &mut ExtCtxt, trait_span: Span,
|cx, span, _, field| {
let idx = cx.expr_uint(span, field);
cx.expr_method_call(span, blkdecoder, rvariant_arg,
~[idx, lambdadecode])
vec!(idx, lambdadecode))
});
arms.push(cx.arm(v_span,
~[cx.pat_lit(v_span, cx.expr_uint(v_span, i))],
vec!(cx.pat_lit(v_span, cx.expr_uint(v_span, i))),
decoded));
}
arms.push(cx.arm_unreachable(trait_span));
let result = cx.expr_match(trait_span, cx.expr_ident(trait_span, variant), arms);
let lambda = cx.lambda_expr(trait_span, ~[blkarg, variant], result);
let lambda = cx.lambda_expr(trait_span, vec!(blkarg, variant), result);
let variant_vec = cx.expr_vec(trait_span, variants);
let result = cx.expr_method_call(trait_span, blkdecoder,
cx.ident_of("read_enum_variant"),
~[variant_vec, lambda]);
vec!(variant_vec, lambda));
cx.expr_method_call(trait_span,
decoder,
cx.ident_of("read_enum"),
~[
vec!(
cx.expr_str(trait_span, token::get_ident(substr.type_ident)),
cx.lambda_expr_1(trait_span, result, blkarg)
])
))
}
_ => cx.bug("expected StaticEnum or StaticStruct in deriving(Decodable)")
};

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

@ -21,34 +21,33 @@ pub fn expand_deriving_default(cx: &mut ExtCtxt,
push: |@Item|) {
let trait_def = TraitDef {
span: span,
attributes: ~[],
path: Path::new(~["std", "default", "Default"]),
additional_bounds: ~[],
attributes: Vec::new(),
path: Path::new(vec!("std", "default", "Default")),
additional_bounds: Vec::new(),
generics: LifetimeBounds::empty(),
methods: ~[
methods: vec!(
MethodDef {
name: "default",
generics: LifetimeBounds::empty(),
explicit_self: None,
args: ~[],
args: Vec::new(),
ret_ty: Self,
inline: true,
const_nonmatching: false,
combine_substructure: default_substructure
},
]
})
};
trait_def.expand(cx, mitem, item, push)
}
fn default_substructure(cx: &mut ExtCtxt, trait_span: Span, substr: &Substructure) -> @Expr {
let default_ident = ~[
let default_ident = vec!(
cx.ident_of("std"),
cx.ident_of("default"),
cx.ident_of("Default"),
cx.ident_of("default")
];
let default_call = |span| cx.expr_call_global(span, default_ident.clone(), ~[]);
);
let default_call = |span| cx.expr_call_global(span, default_ident.clone(), Vec::new());
return match *substr.fields {
StaticStruct(_, ref summary) => {

51
src/libsyntax/ext/deriving/encodable.rs
View file

@ -96,27 +96,26 @@ pub fn expand_deriving_encodable(cx: &mut ExtCtxt,
push: |@Item|) {
let trait_def = TraitDef {
span: span,
attributes: ~[],
path: Path::new_(~["serialize", "Encodable"], None,
~[~Literal(Path::new_local("__E"))], true),
additional_bounds: ~[],
attributes: Vec::new(),
path: Path::new_(vec!("serialize", "Encodable"), None,
vec!(~Literal(Path::new_local("__E"))), true),
additional_bounds: Vec::new(),
generics: LifetimeBounds {
lifetimes: ~[],
bounds: ~[("__E", ~[Path::new(~["serialize", "Encoder"])])],
lifetimes: Vec::new(),
bounds: vec!(("__E", vec!(Path::new(vec!("serialize", "Encoder"))))),
},
methods: ~[
methods: vec!(
MethodDef {
name: "encode",
generics: LifetimeBounds::empty(),
explicit_self: borrowed_explicit_self(),
args: ~[Ptr(~Literal(Path::new_local("__E")),
Borrowed(None, MutMutable))],
args: vec!(Ptr(~Literal(Path::new_local("__E")),
Borrowed(None, MutMutable))),
ret_ty: nil_ty(),
inline: false,
const_nonmatching: true,
combine_substructure: encodable_substructure,
},
]
})
};
trait_def.expand(cx, mitem, item, push)
@ -133,7 +132,7 @@ fn encodable_substructure(cx: &mut ExtCtxt, trait_span: Span,
return match *substr.fields {
Struct(ref fields) => {
let emit_struct_field = cx.ident_of("emit_struct_field");
let mut stmts = ~[];
let mut stmts = Vec::new();
for (i, &FieldInfo {
name,
self_,
@ -146,13 +145,13 @@ fn encodable_substructure(cx: &mut ExtCtxt, trait_span: Span,
token::intern_and_get_ident(format!("_field{}", i))
}
};
let enc = cx.expr_method_call(span, self_, encode, ~[blkencoder]);
let enc = cx.expr_method_call(span, self_, encode, vec!(blkencoder));
let lambda = cx.lambda_expr_1(span, enc, blkarg);
let call = cx.expr_method_call(span, blkencoder,
emit_struct_field,
~[cx.expr_str(span, name),
vec!(cx.expr_str(span, name),
cx.expr_uint(span, i),
lambda]);
lambda));
stmts.push(cx.stmt_expr(call));
}
@ -160,11 +159,11 @@ fn encodable_substructure(cx: &mut ExtCtxt, trait_span: Span,
cx.expr_method_call(trait_span,
encoder,
cx.ident_of("emit_struct"),
~[
vec!(
cx.expr_str(trait_span, token::get_ident(substr.type_ident)),
cx.expr_uint(trait_span, fields.len()),
blk
])
))
}
EnumMatching(idx, variant, ref fields) => {
@ -175,14 +174,14 @@ fn encodable_substructure(cx: &mut ExtCtxt, trait_span: Span,
let me = cx.stmt_let(trait_span, false, blkarg, encoder);
let encoder = cx.expr_ident(trait_span, blkarg);
let emit_variant_arg = cx.ident_of("emit_enum_variant_arg");
let mut stmts = ~[];
let mut stmts = Vec::new();
for (i, &FieldInfo { self_, span, .. }) in fields.iter().enumerate() {
let enc = cx.expr_method_call(span, self_, encode, ~[blkencoder]);
let enc = cx.expr_method_call(span, self_, encode, vec!(blkencoder));
let lambda = cx.lambda_expr_1(span, enc, blkarg);
let call = cx.expr_method_call(span, blkencoder,
emit_variant_arg,
~[cx.expr_uint(span, i),
lambda]);
vec!(cx.expr_uint(span, i),
lambda));
stmts.push(cx.stmt_expr(call));
}
@ -190,19 +189,19 @@ fn encodable_substructure(cx: &mut ExtCtxt, trait_span: Span,
let name = cx.expr_str(trait_span, token::get_ident(variant.node.name));
let call = cx.expr_method_call(trait_span, blkencoder,
cx.ident_of("emit_enum_variant"),
~[name,
vec!(name,
cx.expr_uint(trait_span, idx),
cx.expr_uint(trait_span, fields.len()),
blk]);
blk));
let blk = cx.lambda_expr_1(trait_span, call, blkarg);
let ret = cx.expr_method_call(trait_span,
encoder,
cx.ident_of("emit_enum"),
~[
vec!(
cx.expr_str(trait_span, token::get_ident(substr.type_ident)),
blk
]);
cx.expr_block(cx.block(trait_span, ~[me], Some(ret)))
));
cx.expr_block(cx.block(trait_span, vec!(me), Some(ret)))
}
_ => cx.bug("expected Struct or EnumMatching in deriving(Encodable)")

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

@ -197,20 +197,19 @@ pub struct TraitDef<'a> {
/// The span for the current #[deriving(Foo)] header.
span: Span,
attributes: ~[ast::Attribute],
attributes: Vec<ast::Attribute> ,
/// Path of the trait, including any type parameters
path: Path<'a>,
/// Additional bounds required of any type parameters of the type,
/// other than the current trait
additional_bounds: ~[Ty<'a>],
additional_bounds: Vec<Ty<'a>> ,
/// Any extra lifetimes and/or bounds, e.g. `D: serialize::Decoder`
generics: LifetimeBounds<'a>,
methods: ~[MethodDef<'a>]
}
methods: Vec<MethodDef<'a>> }
pub struct MethodDef<'a> {
@ -225,7 +224,7 @@ pub struct MethodDef<'a> {
explicit_self: Option<Option<PtrTy<'a>>>,
/// Arguments other than the self argument
args: ~[Ty<'a>],
args: Vec<Ty<'a>> ,
/// Return type
ret_ty: Ty<'a>,
@ -264,39 +263,38 @@ pub struct FieldInfo {
self_: @Expr,
/// The expressions corresponding to references to this field in
/// the other Self arguments.
other: ~[@Expr]
}
other: Vec<@Expr> }
/// Fields for a static method
pub enum StaticFields {
/// Tuple structs/enum variants like this
Unnamed(~[Span]),
Unnamed(Vec<Span> ),
/// Normal structs/struct variants.
Named(~[(Ident, Span)])
Named(Vec<(Ident, Span)> )
}
/// A summary of the possible sets of fields. See above for details
/// and examples
pub enum SubstructureFields<'a> {
Struct(~[FieldInfo]),
Struct(Vec<FieldInfo> ),
/**
Matching variants of the enum: variant index, ast::Variant,
fields: the field name is only non-`None` in the case of a struct
variant.
*/
EnumMatching(uint, &'a ast::Variant, ~[FieldInfo]),
EnumMatching(uint, &'a ast::Variant, Vec<FieldInfo> ),
/**
non-matching variants of the enum, [(variant index, ast::Variant,
[field span, field ident, fields])] (i.e. all fields for self are in the
first tuple, for other1 are in the second tuple, etc.)
*/
EnumNonMatching(&'a [(uint, P<ast::Variant>, ~[(Span, Option<Ident>, @Expr)])]),
EnumNonMatching(&'a [(uint, P<ast::Variant>, Vec<(Span, Option<Ident>, @Expr)> )]),
/// A static method where Self is a struct.
StaticStruct(&'a ast::StructDef, StaticFields),
/// A static method where Self is an enum.
StaticEnum(&'a ast::EnumDef, ~[(Ident, Span, StaticFields)])
StaticEnum(&'a ast::EnumDef, Vec<(Ident, Span, StaticFields)> )
}
@ -316,7 +314,7 @@ representing each variant: (variant index, ast::Variant instance,
pub type EnumNonMatchFunc<'a> =
'a |&mut ExtCtxt,
Span,
&[(uint, P<ast::Variant>, ~[(Span, Option<Ident>, @Expr)])],
&[(uint, P<ast::Variant>, Vec<(Span, Option<Ident>, @Expr)> )],
&[@Expr]|
-> @Expr;
@ -360,7 +358,7 @@ impl<'a> TraitDef<'a> {
cx: &mut ExtCtxt,
type_ident: Ident,
generics: &Generics,
methods: ~[@ast::Method]) -> @ast::Item {
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,
@ -397,7 +395,7 @@ impl<'a> TraitDef<'a> {
// Create the type of `self`.
let self_type = cx.ty_path(
cx.path_all(self.span, false, ~[ type_ident ], self_lifetimes,
cx.path_all(self.span, false, vec!( type_ident ), self_lifetimes,
opt_vec::take_vec(self_ty_params)), None);
let doc_attr = cx.attribute(
@ -412,7 +410,7 @@ impl<'a> TraitDef<'a> {
cx.item(
self.span,
ident,
vec::append(~[doc_attr], self.attributes),
vec_ng::append(vec!(doc_attr), self.attributes),
ast::ItemImpl(trait_generics, opt_trait_ref,
self_type, methods.map(|x| *x)))
}
@ -524,11 +522,11 @@ impl<'a> MethodDef<'a> {
trait_: &TraitDef,
type_ident: Ident,
generics: &Generics)
-> (ast::ExplicitSelf, ~[@Expr], ~[@Expr], ~[(Ident, P<ast::Ty>)]) {
-> (ast::ExplicitSelf, Vec<@Expr> , Vec<@Expr> , Vec<(Ident, P<ast::Ty>)> ) {
let mut self_args = ~[];
let mut nonself_args = ~[];
let mut arg_tys = ~[];
let mut self_args = Vec::new();
let mut nonself_args = Vec::new();
let mut arg_tys = Vec::new();
let mut nonstatic = false;
let ast_explicit_self = match self.explicit_self {
@ -575,7 +573,7 @@ impl<'a> MethodDef<'a> {
type_ident: Ident,
generics: &Generics,
explicit_self: ast::ExplicitSelf,
arg_types: ~[(Ident, P<ast::Ty>)],
arg_types: Vec<(Ident, P<ast::Ty>)> ,
body: @Expr) -> @ast::Method {
// create the generics that aren't for Self
let fn_generics = self.generics.to_generics(cx, trait_.span, type_ident, generics);
@ -598,16 +596,16 @@ impl<'a> MethodDef<'a> {
let body_block = cx.block_expr(body);
let attrs = if self.inline {
~[
vec!(
cx
.attribute(trait_.span,
cx
.meta_word(trait_.span,
InternedString::new(
"inline")))
]
)
} else {
~[]
Vec::new()
};
// Create the method.
@ -655,9 +653,9 @@ impl<'a> MethodDef<'a> {
nonself_args: &[@Expr])
-> @Expr {
let mut raw_fields = ~[]; // ~[[fields of self],
let mut raw_fields = Vec::new(); // ~[[fields of self],
// [fields of next Self arg], [etc]]
let mut patterns = ~[];
let mut patterns = Vec::new();
for i in range(0u, self_args.len()) {
let (pat, ident_expr) = trait_.create_struct_pattern(cx, type_ident, struct_def,
format!("__self_{}", i),
@ -703,7 +701,7 @@ impl<'a> MethodDef<'a> {
// matter.
for (&arg_expr, &pat) in self_args.iter().zip(patterns.iter()) {
body = cx.expr_match(trait_.span, arg_expr,
~[ cx.arm(trait_.span, ~[pat], body) ])
vec!( cx.arm(trait_.span, vec!(pat), body) ))
}
body
}
@ -759,7 +757,7 @@ impl<'a> MethodDef<'a> {
self_args: &[@Expr],
nonself_args: &[@Expr])
-> @Expr {
let mut matches = ~[];
let mut matches = Vec::new();
self.build_enum_match(cx, trait_, enum_def, type_ident,
self_args, nonself_args,
None, &mut matches, 0)
@ -795,8 +793,8 @@ impl<'a> MethodDef<'a> {
self_args: &[@Expr],
nonself_args: &[@Expr],
matching: Option<uint>,
matches_so_far: &mut ~[(uint, P<ast::Variant>,
~[(Span, Option<Ident>, @Expr)])],
matches_so_far: &mut Vec<(uint, P<ast::Variant>,
Vec<(Span, Option<Ident>, @Expr)> )> ,
match_count: uint) -> @Expr {
if match_count == self_args.len() {
// we've matched against all arguments, so make the final
@ -826,7 +824,7 @@ impl<'a> MethodDef<'a> {
(_, v, ref s) => (v, s)
};
let mut enum_matching_fields = vec::from_elem(self_vec.len(), ~[]);
let mut enum_matching_fields = vec::from_elem(self_vec.len(), Vec::new());
for triple in matches_so_far.tail().iter() {
match triple {
@ -865,7 +863,7 @@ impl<'a> MethodDef<'a> {
format!("__arg_{}", match_count)
};
let mut arms = ~[];
let mut arms = Vec::new();
// the code for nonmatching variants only matters when
// we've seen at least one other variant already
@ -895,7 +893,7 @@ impl<'a> MethodDef<'a> {
matches_so_far,
match_count + 1);
matches_so_far.pop().unwrap();
arms.push(cx.arm(trait_.span, ~[ pattern ], arm_expr));
arms.push(cx.arm(trait_.span, vec!( pattern ), arm_expr));
if enum_def.variants.len() > 1 {
let e = &EnumNonMatching(&[]);
@ -904,7 +902,7 @@ impl<'a> MethodDef<'a> {
e);
let wild_arm = cx.arm(
trait_.span,
~[ cx.pat_wild(trait_.span) ],
vec!( cx.pat_wild(trait_.span) ),
wild_expr);
arms.push(wild_arm);
}
@ -933,7 +931,7 @@ impl<'a> MethodDef<'a> {
match_count + 1);
matches_so_far.pop().unwrap();
let arm = cx.arm(trait_.span, ~[ pattern ], arm_expr);
let arm = cx.arm(trait_.span, vec!( pattern ), arm_expr);
arms.push(arm);
}
}
@ -997,8 +995,8 @@ impl<'a> TraitDef<'a> {
fn summarise_struct(&self,
cx: &mut ExtCtxt,
struct_def: &StructDef) -> StaticFields {
let mut named_idents = ~[];
let mut just_spans = ~[];
let mut named_idents = Vec::new();
let mut just_spans = Vec::new();
for field in struct_def.fields.iter(){
let sp = self.set_expn_info(cx, field.span);
match field.node.kind {
@ -1020,9 +1018,9 @@ impl<'a> TraitDef<'a> {
fn create_subpatterns(&self,
cx: &mut ExtCtxt,
field_paths: ~[ast::Path],
field_paths: Vec<ast::Path> ,
mutbl: ast::Mutability)
-> ~[@ast::Pat] {
-> Vec<@ast::Pat> {
field_paths.map(|path| {
cx.pat(path.span,
ast::PatIdent(ast::BindByRef(mutbl), (*path).clone(), None))
@ -1035,18 +1033,18 @@ impl<'a> TraitDef<'a> {
struct_def: &StructDef,
prefix: &str,
mutbl: ast::Mutability)
-> (@ast::Pat, ~[(Span, Option<Ident>, @Expr)]) {
-> (@ast::Pat, Vec<(Span, Option<Ident>, @Expr)> ) {
if struct_def.fields.is_empty() {
return (
cx.pat_ident_binding_mode(
self.span, struct_ident, ast::BindByValue(ast::MutImmutable)),
~[]);
Vec::new());
}
let matching_path = cx.path(self.span, ~[ struct_ident ]);
let matching_path = cx.path(self.span, vec!( struct_ident ));
let mut paths = ~[];
let mut ident_expr = ~[];
let mut paths = Vec::new();
let mut ident_expr = Vec::new();
let mut struct_type = Unknown;
for (i, struct_field) in struct_def.fields.iter().enumerate() {
@ -1096,20 +1094,20 @@ impl<'a> TraitDef<'a> {
variant: &ast::Variant,
prefix: &str,
mutbl: ast::Mutability)
-> (@ast::Pat, ~[(Span, Option<Ident>, @Expr)]) {
-> (@ast::Pat, Vec<(Span, Option<Ident>, @Expr)> ) {
let variant_ident = variant.node.name;
match variant.node.kind {
ast::TupleVariantKind(ref variant_args) => {
if variant_args.is_empty() {
return (cx.pat_ident_binding_mode(variant.span, variant_ident,
ast::BindByValue(ast::MutImmutable)),
~[]);
Vec::new());
}
let matching_path = cx.path_ident(variant.span, variant_ident);
let mut paths = ~[];
let mut ident_expr = ~[];
let mut paths = Vec::new();
let mut ident_expr = Vec::new();
for (i, va) in variant_args.iter().enumerate() {
let sp = self.set_expn_info(cx, va.ty.span);
let path = cx.path_ident(sp, cx.ident_of(format!("{}_{}", prefix, i)));
@ -1179,7 +1177,7 @@ f(cx, span, ~[self_1.method(__arg_1_1, __arg_2_1),
~~~
*/
#[inline]
pub fn cs_same_method(f: |&mut ExtCtxt, Span, ~[@Expr]| -> @Expr,
pub fn cs_same_method(f: |&mut ExtCtxt, Span, Vec<@Expr> | -> @Expr,
enum_nonmatch_f: EnumNonMatchFunc,
cx: &mut ExtCtxt,
trait_span: Span,

18
src/libsyntax/ext/deriving/hash.rs
View file

@ -22,23 +22,23 @@ pub fn expand_deriving_hash(cx: &mut ExtCtxt,
let hash_trait_def = TraitDef {
span: span,
attributes: ~[],
path: Path::new(~["std", "hash", "Hash"]),
additional_bounds: ~[],
attributes: Vec::new(),
path: Path::new(vec!("std", "hash", "Hash")),
additional_bounds: Vec::new(),
generics: LifetimeBounds::empty(),
methods: ~[
methods: vec!(
MethodDef {
name: "hash",
generics: LifetimeBounds::empty(),
explicit_self: borrowed_explicit_self(),
args: ~[Ptr(~Literal(Path::new(~["std", "hash", "sip", "SipState"])),
Borrowed(None, MutMutable))],
args: vec!(Ptr(~Literal(Path::new(vec!("std", "hash", "sip", "SipState"))),
Borrowed(None, MutMutable))),
ret_ty: nil_ty(),
inline: true,
const_nonmatching: false,
combine_substructure: hash_substructure
}
]
)
};
hash_trait_def.expand(cx, mitem, item, push);
@ -51,10 +51,10 @@ fn hash_substructure(cx: &mut ExtCtxt, trait_span: Span, substr: &Substructure)
};
let hash_ident = substr.method_ident;
let call_hash = |span, thing_expr| {
let expr = cx.expr_method_call(span, thing_expr, hash_ident, ~[state_expr]);
let expr = cx.expr_method_call(span, thing_expr, hash_ident, vec!(state_expr));
cx.stmt_expr(expr)
};
let mut stmts = ~[];
let mut stmts = Vec::new();
let fields = match *substr.fields {
Struct(ref fs) => fs,

35
src/libsyntax/ext/deriving/primitive.rs
View file

@ -23,21 +23,20 @@ pub fn expand_deriving_from_primitive(cx: &mut ExtCtxt,
push: |@Item|) {
let trait_def = TraitDef {
span: span,
attributes: ~[],
path: Path::new(~["std", "num", "FromPrimitive"]),
additional_bounds: ~[],
attributes: Vec::new(),
path: Path::new(vec!("std", "num", "FromPrimitive")),
additional_bounds: Vec::new(),
generics: LifetimeBounds::empty(),
methods: ~[
methods: vec!(
MethodDef {
name: "from_i64",
generics: LifetimeBounds::empty(),
explicit_self: None,
args: ~[
Literal(Path::new(~["i64"])),
],
ret_ty: Literal(Path::new_(~["std", "option", "Option"],
args: vec!(
Literal(Path::new(vec!("i64")))),
ret_ty: Literal(Path::new_(vec!("std", "option", "Option"),
None,
~[~Self],
vec!(~Self),
true)),
// liable to cause code-bloat
inline: true,
@ -48,19 +47,17 @@ pub fn expand_deriving_from_primitive(cx: &mut ExtCtxt,
name: "from_u64",
generics: LifetimeBounds::empty(),
explicit_self: None,
args: ~[
Literal(Path::new(~["u64"])),
],
ret_ty: Literal(Path::new_(~["std", "option", "Option"],
args: vec!(
Literal(Path::new(vec!("u64")))),
ret_ty: Literal(Path::new_(vec!("std", "option", "Option"),
None,
~[~Self],
vec!(~Self),
true)),
// liable to cause code-bloat
inline: true,
const_nonmatching: false,
combine_substructure: |c, s, sub| cs_from("u64", c, s, sub),
},
]
})
};
trait_def.expand(cx, mitem, item, push)
@ -84,7 +81,7 @@ fn cs_from(name: &str, cx: &mut ExtCtxt, trait_span: Span, substr: &Substructure
return cx.expr_fail(trait_span, InternedString::new(""));
}
let mut arms = ~[];
let mut arms = Vec::new();
for variant in enum_def.variants.iter() {
match variant.node.kind {
@ -109,7 +106,7 @@ fn cs_from(name: &str, cx: &mut ExtCtxt, trait_span: Span, substr: &Substructure
// arm for `_ if $guard => $body`
let arm = ast::Arm {
pats: ~[cx.pat_wild(span)],
pats: vec!(cx.pat_wild(span)),
guard: Some(guard),
body: cx.block_expr(body),
};
@ -128,7 +125,7 @@ fn cs_from(name: &str, cx: &mut ExtCtxt, trait_span: Span, substr: &Substructure
// arm for `_ => None`
let arm = ast::Arm {
pats: ~[cx.pat_wild(trait_span)],
pats: vec!(cx.pat_wild(trait_span)),
guard: None,
body: cx.block_expr(cx.expr_none(trait_span)),
};

38
src/libsyntax/ext/deriving/rand.rs
View file

@ -23,48 +23,48 @@ pub fn expand_deriving_rand(cx: &mut ExtCtxt,
push: |@Item|) {
let trait_def = TraitDef {
span: span,
attributes: ~[],
path: Path::new(~["std", "rand", "Rand"]),
additional_bounds: ~[],
attributes: Vec::new(),
path: Path::new(vec!("std", "rand", "Rand")),
additional_bounds: Vec::new(),
generics: LifetimeBounds::empty(),
methods: ~[
methods: vec!(
MethodDef {
name: "rand",
generics: LifetimeBounds {
lifetimes: ~[],
bounds: ~[("R",
~[ Path::new(~["std", "rand", "Rng"]) ])]
lifetimes: Vec::new(),
bounds: vec!(("R",
vec!( Path::new(vec!("std", "rand", "Rng")) )))
},
explicit_self: None,
args: ~[
args: vec!(
Ptr(~Literal(Path::new_local("R")),
Borrowed(None, ast::MutMutable))
],
),
ret_ty: Self,
inline: false,
const_nonmatching: false,
combine_substructure: rand_substructure
}
]
)
};
trait_def.expand(cx, mitem, item, push)
}
fn rand_substructure(cx: &mut ExtCtxt, trait_span: Span, substr: &Substructure) -> @Expr {
let rng = match substr.nonself_args {
[rng] => ~[ rng ],
[rng] => vec!( rng ),
_ => cx.bug("Incorrect number of arguments to `rand` in `deriving(Rand)`")
};
let rand_ident = ~[
let rand_ident = vec!(
cx.ident_of("std"),
cx.ident_of("rand"),
cx.ident_of("Rand"),
cx.ident_of("rand")
];
);
let rand_call = |cx: &mut ExtCtxt, span| {
cx.expr_call_global(span,
rand_ident.clone(),
~[ rng[0] ])
vec!( rng[0] ))
};
return match *substr.fields {
@ -84,13 +84,13 @@ fn rand_substructure(cx: &mut ExtCtxt, trait_span: Span, substr: &Substructure)
true,
rand_ident.clone(),
opt_vec::Empty,
~[]);
Vec::new());
let rand_name = cx.expr_path(rand_name);
// ::std::rand::Rand::rand(rng)
let rv_call = cx.expr_call(trait_span,
rand_name,
~[ rng[0] ]);
vec!( rng[0] ));
// need to specify the uint-ness of the random number
let uint_ty = cx.ty_ident(trait_span, cx.ident_of("uint"));
@ -113,15 +113,15 @@ fn rand_substructure(cx: &mut ExtCtxt, trait_span: Span, substr: &Substructure)
let pat = cx.pat_lit(v_span, i_expr);
let thing = rand_thing(cx, v_span, ident, summary, |cx, sp| rand_call(cx, sp));
cx.arm(v_span, ~[ pat ], thing)
}).collect::<~[ast::Arm]>();
cx.arm(v_span, vec!( pat ), thing)
}).collect::<Vec<ast::Arm> >();
// _ => {} at the end. Should never occur
arms.push(cx.arm_unreachable(trait_span));
let match_expr = cx.expr_match(trait_span, rand_variant, arms);
let block = cx.block(trait_span, ~[ let_statement ], Some(match_expr));
let block = cx.block(trait_span, vec!( let_statement ), Some(match_expr));
cx.expr_block(block)
}
_ => cx.bug("Non-static method in `deriving(Rand)`")

24
src/libsyntax/ext/deriving/show.rs
View file

@ -26,27 +26,27 @@ pub fn expand_deriving_show(cx: &mut ExtCtxt,
item: @Item,
push: |@Item|) {
// &mut ::std::fmt::Formatter
let fmtr = Ptr(~Literal(Path::new(~["std", "fmt", "Formatter"])),
let fmtr = Ptr(~Literal(Path::new(vec!("std", "fmt", "Formatter"))),
Borrowed(None, ast::MutMutable));
let trait_def = TraitDef {
span: span,
attributes: ~[],
path: Path::new(~["std", "fmt", "Show"]),
additional_bounds: ~[],
attributes: Vec::new(),
path: Path::new(vec!("std", "fmt", "Show")),
additional_bounds: Vec::new(),
generics: LifetimeBounds::empty(),
methods: ~[
methods: vec!(
MethodDef {
name: "fmt",
generics: LifetimeBounds::empty(),
explicit_self: borrowed_explicit_self(),
args: ~[fmtr],
ret_ty: Literal(Path::new(~["std", "fmt", "Result"])),
args: vec!(fmtr),
ret_ty: Literal(Path::new(vec!("std", "fmt", "Result"))),
inline: false,
const_nonmatching: false,
combine_substructure: show_substructure
}
]
)
};
trait_def.expand(cx, mitem, item, push)
}
@ -70,7 +70,7 @@ fn show_substructure(cx: &mut ExtCtxt, span: Span,
let mut format_string = token::get_ident(name).get().to_owned();
// the internal fields we're actually formatting
let mut exprs = ~[];
let mut exprs = Vec::new();
// Getting harder... making the format string:
match *substr.fields {
@ -124,10 +124,10 @@ fn show_substructure(cx: &mut ExtCtxt, span: Span,
let formatter = substr.nonself_args[0];
let buf = cx.expr_field_access(span, formatter, cx.ident_of("buf"));
let std_write = ~[cx.ident_of("std"), cx.ident_of("fmt"), cx.ident_of("write")];
let std_write = vec!(cx.ident_of("std"), cx.ident_of("fmt"), cx.ident_of("write"));
let args = cx.ident_of("__args");
let write_call = cx.expr_call_global(span, std_write, ~[buf, cx.expr_ident(span, args)]);
let format_closure = cx.lambda_expr(span, ~[args], write_call);
let write_call = cx.expr_call_global(span, std_write, vec!(buf, cx.expr_ident(span, args)));
let format_closure = cx.lambda_expr(span, vec!(args), write_call);
let s = token::intern_and_get_ident(format_string);
let format_string = cx.expr_str(span, s);

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

@ -30,22 +30,22 @@ pub enum PtrTy<'a> {
/// A path, e.g. `::std::option::Option::<int>` (global). Has support
/// for type parameters and a lifetime.
pub struct Path<'a> {
path: ~[&'a str],
path: Vec<&'a str> ,
lifetime: Option<&'a str>,
params: ~[~Ty<'a>],
params: Vec<~Ty<'a>> ,
global: bool
}
impl<'a> Path<'a> {
pub fn new<'r>(path: ~[&'r str]) -> Path<'r> {
Path::new_(path, None, ~[], true)
pub fn new<'r>(path: Vec<&'r str> ) -> Path<'r> {
Path::new_(path, None, Vec::new(), true)
}
pub fn new_local<'r>(path: &'r str) -> Path<'r> {
Path::new_(~[ path ], None, ~[], false)
Path::new_(vec!( path ), None, Vec::new(), false)
}
pub fn new_<'r>(path: ~[&'r str],
pub fn new_<'r>(path: Vec<&'r str> ,
lifetime: Option<&'r str>,
params: ~[~Ty<'r>],
params: Vec<~Ty<'r>> ,
global: bool)
-> Path<'r> {
Path {
@ -87,7 +87,7 @@ pub enum Ty<'a> {
// parameter, and things like `int`
Literal(Path<'a>),
// includes nil
Tuple(~[Ty<'a>])
Tuple(Vec<Ty<'a>> )
}
pub fn borrowed_ptrty<'r>() -> PtrTy<'r> {
@ -106,7 +106,7 @@ pub fn borrowed_self<'r>() -> Ty<'r> {
}
pub fn nil_ty() -> Ty<'static> {
Tuple(~[])
Tuple(Vec::new())
}
fn mk_lifetime(cx: &ExtCtxt, span: Span, lt: &Option<&str>) -> Option<ast::Lifetime> {
@ -172,7 +172,7 @@ impl<'a> Ty<'a> {
});
let lifetimes = self_generics.lifetimes.clone();
cx.path_all(span, false, ~[self_ty], lifetimes,
cx.path_all(span, false, vec!(self_ty), lifetimes,
opt_vec::take_vec(self_params))
}
Literal(ref p) => {
@ -195,7 +195,7 @@ fn mk_ty_param(cx: &ExtCtxt, span: Span, name: &str, bounds: &[Path],
cx.typaram(cx.ident_of(name), bounds, None)
}
fn mk_generics(lifetimes: ~[ast::Lifetime], ty_params: ~[ast::TyParam]) -> Generics {
fn mk_generics(lifetimes: Vec<ast::Lifetime> , ty_params: Vec<ast::TyParam> ) -> Generics {
Generics {
lifetimes: opt_vec::from(lifetimes),
ty_params: opt_vec::from(ty_params)
@ -204,14 +204,14 @@ fn mk_generics(lifetimes: ~[ast::Lifetime], ty_params: ~[ast::TyParam]) -> Gene
/// Lifetimes and bounds on type parameters
pub struct LifetimeBounds<'a> {
lifetimes: ~[&'a str],
bounds: ~[(&'a str, ~[Path<'a>])]
lifetimes: Vec<&'a str> ,
bounds: vec!((&'a str, Vec<Path<'a>> ))
}
impl<'a> LifetimeBounds<'a> {
pub fn empty() -> LifetimeBounds<'static> {
LifetimeBounds {
lifetimes: ~[], bounds: ~[]
lifetimes: Vec::new(), bounds: Vec::new()
}
}
pub fn to_generics(&self,

22
src/libsyntax/ext/deriving/zero.rs
View file

@ -21,16 +21,16 @@ pub fn expand_deriving_zero(cx: &mut ExtCtxt,
push: |@Item|) {
let trait_def = TraitDef {
span: span,
attributes: ~[],
path: Path::new(~["std", "num", "Zero"]),
additional_bounds: ~[],
attributes: Vec::new(),
path: Path::new(vec!("std", "num", "Zero")),
additional_bounds: Vec::new(),
generics: LifetimeBounds::empty(),
methods: ~[
methods: vec!(
MethodDef {
name: "zero",
generics: LifetimeBounds::empty(),
explicit_self: None,
args: ~[],
args: Vec::new(),
ret_ty: Self,
inline: true,
const_nonmatching: false,
@ -40,8 +40,8 @@ pub fn expand_deriving_zero(cx: &mut ExtCtxt,
name: "is_zero",
generics: LifetimeBounds::empty(),
explicit_self: borrowed_explicit_self(),
args: ~[],
ret_ty: Literal(Path::new(~["bool"])),
args: Vec::new(),
ret_ty: Literal(Path::new(vec!("bool"))),
inline: true,
const_nonmatching: false,
combine_substructure: |cx, span, substr| {
@ -52,19 +52,19 @@ pub fn expand_deriving_zero(cx: &mut ExtCtxt,
cx, span, substr)
}
}
]
)
};
trait_def.expand(cx, mitem, item, push)
}
fn zero_substructure(cx: &mut ExtCtxt, trait_span: Span, substr: &Substructure) -> @Expr {
let zero_ident = ~[
let zero_ident = vec!(
cx.ident_of("std"),
cx.ident_of("num"),
cx.ident_of("Zero"),
cx.ident_of("zero")
];
let zero_call = |span| cx.expr_call_global(span, zero_ident.clone(), ~[]);
);
let zero_call = |span| cx.expr_call_global(span, zero_ident.clone(), Vec::new());
return match *substr.fields {
StaticStruct(_, ref summary) => {

88
src/libsyntax/ext/expand.rs
View file

@ -169,21 +169,21 @@ pub fn expand_expr(e: @ast::Expr, fld: &mut MacroExpander) -> @ast::Expr {
let none_arm = {
let break_expr = fld.cx.expr(span, ast::ExprBreak(opt_ident));
let none_pat = fld.cx.pat_ident(span, none_ident);
fld.cx.arm(span, ~[none_pat], break_expr)
fld.cx.arm(span, vec!(none_pat), break_expr)
};
// `Some(<src_pat>) => <src_loop_block>`
let some_arm =
fld.cx.arm(span,
~[fld.cx.pat_enum(span, some_path, ~[src_pat])],
vec!(fld.cx.pat_enum(span, some_path, vec!(src_pat))),
fld.cx.expr_block(src_loop_block));
// `match i.next() { ... }`
let match_expr = {
let next_call_expr =
fld.cx.expr_method_call(span, fld.cx.expr_path(local_path), next_ident, ~[]);
fld.cx.expr_method_call(span, fld.cx.expr_path(local_path), next_ident, Vec::new());
fld.cx.expr_match(span, next_call_expr, ~[none_arm, some_arm])
fld.cx.expr_match(span, next_call_expr, vec!(none_arm, some_arm))
};
// ['ident:] loop { ... }
@ -196,8 +196,8 @@ pub fn expand_expr(e: @ast::Expr, fld: &mut MacroExpander) -> @ast::Expr {
// `match &mut <src_expr> { i => loop { ... } }`
let discrim = fld.cx.expr_mut_addr_of(span, src_expr);
let i_pattern = fld.cx.pat_ident(span, local_ident);
let arm = fld.cx.arm(span, ~[i_pattern], loop_expr);
fld.cx.expr_match(span, discrim, ~[arm])
let arm = fld.cx.arm(span, vec!(i_pattern), loop_expr);
fld.cx.expr_match(span, discrim, vec!(arm))
}
ast::ExprLoop(loop_block, opt_ident) => {
@ -221,7 +221,7 @@ fn rename_loop_label(opt_ident: Option<Ident>,
let new_label = fresh_name(&label);
let rename = (label, new_label);
fld.extsbox.info().pending_renames.push(rename);
let mut pending_renames = ~[rename];
let mut pending_renames = vec!(rename);
let mut rename_fld = renames_to_fold(&mut pending_renames);
(Some(rename_fld.fold_ident(label)),
rename_fld.fold_block(loop_block))
@ -607,10 +607,10 @@ fn expand_non_macro_stmt(s: &Stmt, fld: &mut MacroExpander)
// oh dear heaven... this is going to include the enum
// names, as well... but that should be okay, as long as
// the new names are gensyms for the old ones.
let mut name_finder = new_name_finder(~[]);
let mut name_finder = new_name_finder(Vec::new());
name_finder.visit_pat(expanded_pat,());
// generate fresh names, push them to a new pending list
let mut new_pending_renames = ~[];
let mut new_pending_renames = Vec::new();
for ident in name_finder.ident_accumulator.iter() {
let new_name = fresh_name(ident);
new_pending_renames.push((*ident,new_name));
@ -657,7 +657,7 @@ fn expand_non_macro_stmt(s: &Stmt, fld: &mut MacroExpander)
// array (passed in to the traversal)
#[deriving(Clone)]
struct NewNameFinderContext {
ident_accumulator: ~[ast::Ident],
ident_accumulator: Vec<ast::Ident> ,
}
impl Visitor<()> for NewNameFinderContext {
@ -700,7 +700,7 @@ impl Visitor<()> for NewNameFinderContext {
// return a visitor that extracts the pat_ident paths
// from a given thingy and puts them in a mutable
// array (passed in to the traversal)
pub fn new_name_finder(idents: ~[ast::Ident]) -> NewNameFinderContext {
pub fn new_name_finder(idents: Vec<ast::Ident> ) -> NewNameFinderContext {
NewNameFinderContext {
ident_accumulator: idents,
}
@ -860,7 +860,7 @@ fn new_mark_folder(m: Mrk) -> Marker {
}
// apply a given mark to the given token trees. Used prior to expansion of a macro.
fn mark_tts(tts: &[TokenTree], m: Mrk) -> ~[TokenTree] {
fn mark_tts(tts: &[TokenTree], m: Mrk) -> Vec<TokenTree> {
fold_tts(tts, &mut new_mark_folder(m))
}
@ -917,7 +917,7 @@ mod test {
// array (passed in to the traversal)
#[deriving(Clone)]
struct NewPathExprFinderContext {
path_accumulator: ~[ast::Path],
path_accumulator: Vec<ast::Path> ,
}
impl Visitor<()> for NewPathExprFinderContext {
@ -941,7 +941,7 @@ mod test {
// return a visitor that extracts the paths
// from a given pattern and puts them in a mutable
// array (passed in to the traversal)
pub fn new_path_finder(paths: ~[ast::Path]) -> NewPathExprFinderContext {
pub fn new_path_finder(paths: Vec<ast::Path> ) -> NewPathExprFinderContext {
NewPathExprFinderContext {
path_accumulator: paths
}
@ -954,7 +954,7 @@ mod test {
fail!("lolwut")
}
fn get_exported_macros(&mut self, _: ast::CrateNum) -> ~[~str] {
fn get_exported_macros(&mut self, _: ast::CrateNum) -> Vec<~str> {
fail!("lolwut")
}
@ -975,7 +975,7 @@ mod test {
let crate_ast = parse::parse_crate_from_source_str(
~"<test>",
src,
~[],sess);
Vec::new(),sess);
// should fail:
let mut loader = ErrLoader;
expand_crate(sess,&mut loader,crate_ast);
@ -990,7 +990,7 @@ mod test {
let crate_ast = parse::parse_crate_from_source_str(
~"<test>",
src,
~[],sess);
Vec::new(),sess);
// should fail:
let mut loader = ErrLoader;
expand_crate(sess,&mut loader,crate_ast);
@ -1004,7 +1004,7 @@ mod test {
let crate_ast = parse::parse_crate_from_source_str(
~"<test>",
src,
~[], sess);
Vec::new(), sess);
// should fail:
let mut loader = ErrLoader;
expand_crate(sess, &mut loader, crate_ast);
@ -1014,9 +1014,9 @@ mod test {
let attr1 = make_dummy_attr ("foo");
let attr2 = make_dummy_attr ("bar");
let escape_attr = make_dummy_attr ("macro_escape");
let attrs1 = ~[attr1, escape_attr, attr2];
let attrs1 = vec!(attr1, escape_attr, attr2);
assert_eq!(contains_macro_escape (attrs1),true);
let attrs2 = ~[attr1,attr2];
let attrs2 = vec!(attr1,attr2);
assert_eq!(contains_macro_escape (attrs2),false);
}
@ -1082,48 +1082,30 @@ mod test {
// in principle, you might want to control this boolean on a per-varref basis,
// but that would make things even harder to understand, and might not be
// necessary for thorough testing.
type RenamingTest = (&'static str, ~[~[uint]], bool);
type RenamingTest = (&'static str, vec!(Vec<uint> ), bool);
#[test]
fn automatic_renaming () {
let tests: ~[RenamingTest] =
~[// b & c should get new names throughout, in the expr too:
let tests: Vec<RenamingTest> =
vec!(// b & c should get new names throughout, in the expr too:
("fn a() -> int { let b = 13; let c = b; b+c }",
~[~[0,1],~[2]], false),
vec!(vec!(0,1),vec!(2)), false),
// both x's should be renamed (how is this causing a bug?)
("fn main () {let x: int = 13;x;}",
~[~[0]], false),
vec!(vec!(0)), false),
// the use of b after the + should be renamed, the other one not:
("macro_rules! f (($x:ident) => (b + $x)) fn a() -> int { let b = 13; f!(b)}",
~[~[1]], false),
vec!(vec!(1)), false),
// the b before the plus should not be renamed (requires marks)
("macro_rules! f (($x:ident) => ({let b=9; ($x + b)})) fn a() -> int { f!(b)}",
~[~[1]], false),
vec!(vec!(1)), false),
// the marks going in and out of letty should cancel, allowing that $x to
// capture the one following the semicolon.
// this was an awesome test case, and caught a *lot* of bugs.
("macro_rules! letty(($x:ident) => (let $x = 15;))
macro_rules! user(($x:ident) => ({letty!($x); $x}))
fn main() -> int {user!(z)}",
~[~[0]], false),
// no longer a fixme #8062: this test exposes a *potential* bug; our system does
// not behave exactly like MTWT, but a conversation with Matthew Flatt
// suggests that this can only occur in the presence of local-expand, which
// we have no plans to support.
// ("fn main() {let hrcoo = 19; macro_rules! getx(()=>(hrcoo)); getx!();}",
// ~[~[0]], true)
// FIXME #6994: the next string exposes the bug referred to in issue 6994, so I'm
// commenting it out.
// the z flows into and out of two macros (g & f) along one path, and one
// (just g) along the other, so the result of the whole thing should
// be "let z_123 = 3; z_123"
//"macro_rules! g (($x:ident) =>
// ({macro_rules! f(($y:ident)=>({let $y=3;$x}));f!($x)}))
// fn a(){g!(z)}"
// create a really evil test case where a $x appears inside a binding of $x
// but *shouldnt* bind because it was inserted by a different macro....
// can't write this test case until we have macro-generating macros.
];
vec!(vec!(0)), false));
for (idx,s) in tests.iter().enumerate() {
run_renaming_test(s,idx);
}
@ -1137,12 +1119,12 @@ mod test {
};
let cr = expand_crate_str(teststr.to_owned());
// find the bindings:
let mut name_finder = new_name_finder(~[]);
let mut name_finder = new_name_finder(Vec::new());
visit::walk_crate(&mut name_finder,&cr,());
let bindings = name_finder.ident_accumulator;
// find the varrefs:
let mut path_finder = new_path_finder(~[]);
let mut path_finder = new_path_finder(Vec::new());
visit::walk_crate(&mut path_finder,&cr,());
let varrefs = path_finder.path_accumulator;
@ -1205,11 +1187,11 @@ foo_module!()
";
let cr = expand_crate_str(crate_str);
// find the xx binding
let mut name_finder = new_name_finder(~[]);
let mut name_finder = new_name_finder(Vec::new());
visit::walk_crate(&mut name_finder, &cr, ());
let bindings = name_finder.ident_accumulator;
let cxbinds: ~[&ast::Ident] =
let cxbinds: Vec<&ast::Ident> =
bindings.iter().filter(|b| {
let ident = token::get_ident(**b);
let string = ident.get();
@ -1222,7 +1204,7 @@ foo_module!()
};
let resolved_binding = mtwt_resolve(*cxbind);
// find all the xx varrefs:
let mut path_finder = new_path_finder(~[]);
let mut path_finder = new_path_finder(Vec::new());
visit::walk_crate(&mut path_finder, &cr, ());
let varrefs = path_finder.path_accumulator;
@ -1256,10 +1238,10 @@ foo_module!()
#[test]
fn pat_idents(){
let pat = string_to_pat(~"(a,Foo{x:c @ (b,9),y:Bar(4,d)})");
let mut pat_idents = new_name_finder(~[]);
let mut pat_idents = new_name_finder(Vec::new());
pat_idents.visit_pat(pat, ());
assert_eq!(pat_idents.ident_accumulator,
strs_to_idents(~["a","c","b","d"]));
strs_to_idents(vec!("a","c","b","d")));
}
}

161
src/libsyntax/ext/format.rs
View file

@ -41,8 +41,8 @@ struct Context<'a> {
// Parsed argument expressions and the types that we've found so far for
// them.
args: ~[@ast::Expr],
arg_types: ~[Option<ArgumentType>],
args: Vec<@ast::Expr>,
arg_types: Vec<Option<ArgumentType>>,
// Parsed named expressions and the types that we've found for them so far.
// Note that we keep a side-array of the ordering of the named arguments
// found to be sure that we can translate them in the same order that they
@ -52,9 +52,9 @@ struct Context<'a> {
name_ordering: ~[~str],
// Collection of the compiled `rt::Piece` structures
pieces: ~[@ast::Expr],
pieces: Vec<@ast::Expr> ,
name_positions: HashMap<~str, uint>,
method_statics: ~[@ast::Item],
method_statics: Vec<@ast::Item> ,
// Updated as arguments are consumed or methods are entered
nest_level: uint,
@ -70,10 +70,9 @@ struct Context<'a> {
/// Some((fmtstr, unnamed arguments, ordering of named arguments,
/// named arguments))
fn parse_args(ecx: &mut ExtCtxt, sp: Span, tts: &[ast::TokenTree])
-> (@ast::Expr, Option<(@ast::Expr, ~[@ast::Expr], ~[~str],
HashMap<~str, @ast::Expr>)>)
{
let mut args = ~[];
-> (@ast::Expr, Option<(@ast::Expr, Vec<@ast::Expr>, ~[~str],
HashMap<~str, @ast::Expr>)>) {
let mut args = Vec::new();
let mut names = HashMap::<~str, @ast::Expr>::new();
let mut order = ~[];
@ -357,7 +356,7 @@ impl<'a> Context<'a> {
/// These attributes are applied to all statics that this syntax extension
/// will generate.
fn static_attrs(&self) -> ~[ast::Attribute] {
fn static_attrs(&self) -> Vec<ast::Attribute> {
// Flag statics as `address_insignificant` so LLVM can merge duplicate
// globals as much as possible (which we're generating a whole lot of).
let unnamed = self.ecx
@ -371,41 +370,41 @@ impl<'a> Context<'a> {
InternedString::new("dead_code"));
let allow_dead_code = self.ecx.meta_list(self.fmtsp,
InternedString::new("allow"),
~[dead_code]);
vec!(dead_code));
let allow_dead_code = self.ecx.attribute(self.fmtsp, allow_dead_code);
return ~[unnamed, allow_dead_code];
return vec!(unnamed, allow_dead_code);
}
fn parsepath(&self, s: &str) -> ~[ast::Ident] {
~[self.ecx.ident_of("std"), self.ecx.ident_of("fmt"),
self.ecx.ident_of("parse"), self.ecx.ident_of(s)]
fn parsepath(&self, s: &str) -> Vec<ast::Ident> {
vec!(self.ecx.ident_of("std"), self.ecx.ident_of("fmt"),
self.ecx.ident_of("parse"), self.ecx.ident_of(s))
}
fn rtpath(&self, s: &str) -> ~[ast::Ident] {
~[self.ecx.ident_of("std"), self.ecx.ident_of("fmt"),
self.ecx.ident_of("rt"), self.ecx.ident_of(s)]
fn rtpath(&self, s: &str) -> Vec<ast::Ident> {
vec!(self.ecx.ident_of("std"), self.ecx.ident_of("fmt"),
self.ecx.ident_of("rt"), self.ecx.ident_of(s))
}
fn ctpath(&self, s: &str) -> ~[ast::Ident] {
~[self.ecx.ident_of("std"), self.ecx.ident_of("fmt"),
self.ecx.ident_of("parse"), self.ecx.ident_of(s)]
fn ctpath(&self, s: &str) -> Vec<ast::Ident> {
vec!(self.ecx.ident_of("std"), self.ecx.ident_of("fmt"),
self.ecx.ident_of("parse"), self.ecx.ident_of(s))
}
fn none(&self) -> @ast::Expr {
let none = self.ecx.path_global(self.fmtsp, ~[
let none = self.ecx.path_global(self.fmtsp, vec!(
self.ecx.ident_of("std"),
self.ecx.ident_of("option"),
self.ecx.ident_of("None")]);
self.ecx.ident_of("None")));
self.ecx.expr_path(none)
}
fn some(&self, e: @ast::Expr) -> @ast::Expr {
let p = self.ecx.path_global(self.fmtsp, ~[
let p = self.ecx.path_global(self.fmtsp, vec!(
self.ecx.ident_of("std"),
self.ecx.ident_of("option"),
self.ecx.ident_of("Some")]);
self.ecx.ident_of("Some")));
let p = self.ecx.expr_path(p);
self.ecx.expr_call(self.fmtsp, p, ~[e])
self.ecx.expr_call(self.fmtsp, p, vec!(e))
}
fn trans_count(&self, c: parse::Count) -> @ast::Expr {
@ -413,11 +412,11 @@ impl<'a> Context<'a> {
match c {
parse::CountIs(i) => {
self.ecx.expr_call_global(sp, self.rtpath("CountIs"),
~[self.ecx.expr_uint(sp, i)])
vec!(self.ecx.expr_uint(sp, i)))
}
parse::CountIsParam(i) => {
self.ecx.expr_call_global(sp, self.rtpath("CountIsParam"),
~[self.ecx.expr_uint(sp, i)])
vec!(self.ecx.expr_uint(sp, i)))
}
parse::CountImplied => {
let path = self.ecx.path_global(sp, self.rtpath("CountImplied"));
@ -434,7 +433,7 @@ impl<'a> Context<'a> {
};
let i = i + self.args.len();
self.ecx.expr_call_global(sp, self.rtpath("CountIsParam"),
~[self.ecx.expr_uint(sp, i)])
vec!(self.ecx.expr_uint(sp, i)))
}
}
}
@ -450,21 +449,19 @@ impl<'a> Context<'a> {
}).collect();
let s = token::intern_and_get_ident(arm.selector);
let selector = self.ecx.expr_str(sp, s);
self.ecx.expr_struct(sp, p, ~[
self.ecx.expr_struct(sp, p, vec!(
self.ecx.field_imm(sp,
self.ecx.ident_of("selector"),
selector),
self.ecx.field_imm(sp, self.ecx.ident_of("result"),
self.ecx.expr_vec_slice(sp, result)),
])
self.ecx.expr_vec_slice(sp, result))))
}).collect();
let default = default.iter().map(|p| {
self.trans_piece(p)
}).collect();
self.ecx.expr_call_global(sp, self.rtpath("Select"), ~[
self.ecx.expr_call_global(sp, self.rtpath("Select"), vec!(
self.ecx.expr_vec_slice(sp, arms),
self.ecx.expr_vec_slice(sp, default),
])
self.ecx.expr_vec_slice(sp, default)))
}
parse::Plural(offset, ref arms, ref default) => {
let offset = match offset {
@ -487,23 +484,21 @@ impl<'a> Context<'a> {
}
};
let selector = self.ecx.expr_call_global(sp,
lr, ~[selarg]);
self.ecx.expr_struct(sp, p, ~[
lr, vec!(selarg));
self.ecx.expr_struct(sp, p, vec!(
self.ecx.field_imm(sp,
self.ecx.ident_of("selector"),
selector),
self.ecx.field_imm(sp, self.ecx.ident_of("result"),
self.ecx.expr_vec_slice(sp, result)),
])
self.ecx.expr_vec_slice(sp, result))))
}).collect();
let default = default.iter().map(|p| {
self.trans_piece(p)
}).collect();
self.ecx.expr_call_global(sp, self.rtpath("Plural"), ~[
self.ecx.expr_call_global(sp, self.rtpath("Plural"), vec!(
offset,
self.ecx.expr_vec_slice(sp, arms),
self.ecx.expr_vec_slice(sp, default),
])
self.ecx.expr_vec_slice(sp, default)))
}
};
let life = self.ecx.lifetime(sp, self.ecx.ident_of("static").name);
@ -512,7 +507,7 @@ impl<'a> Context<'a> {
true,
self.rtpath("Method"),
opt_vec::with(life),
~[]
Vec::new()
), None);
let st = ast::ItemStatic(ty, ast::MutImmutable, method);
let static_name = self.ecx.ident_of(format!("__STATIC_METHOD_{}",
@ -530,13 +525,13 @@ impl<'a> Context<'a> {
let s = token::intern_and_get_ident(s);
self.ecx.expr_call_global(sp,
self.rtpath("String"),
~[
vec!(
self.ecx.expr_str(sp, s)
])
))
}
parse::CurrentArgument => {
let nil = self.ecx.expr_lit(sp, ast::LitNil);
self.ecx.expr_call_global(sp, self.rtpath("CurrentArgument"), ~[nil])
self.ecx.expr_call_global(sp, self.rtpath("CurrentArgument"), vec!(nil))
}
parse::Argument(ref arg) => {
// Translate the position
@ -549,7 +544,7 @@ impl<'a> Context<'a> {
}
parse::ArgumentIs(i) => {
self.ecx.expr_call_global(sp, self.rtpath("ArgumentIs"),
~[self.ecx.expr_uint(sp, i)])
vec!(self.ecx.expr_uint(sp, i)))
}
// Named arguments are converted to positional arguments at
// the end of the list of arguments
@ -560,7 +555,7 @@ impl<'a> Context<'a> {
};
let i = i + self.args.len();
self.ecx.expr_call_global(sp, self.rtpath("ArgumentIs"),
~[self.ecx.expr_uint(sp, i)])
vec!(self.ecx.expr_uint(sp, i)))
}
};
@ -583,13 +578,12 @@ impl<'a> Context<'a> {
let prec = self.trans_count(arg.format.precision);
let width = self.trans_count(arg.format.width);
let path = self.ecx.path_global(sp, self.rtpath("FormatSpec"));
let fmt = self.ecx.expr_struct(sp, path, ~[
let fmt = self.ecx.expr_struct(sp, path, vec!(
self.ecx.field_imm(sp, self.ecx.ident_of("fill"), fill),
self.ecx.field_imm(sp, self.ecx.ident_of("align"), align),
self.ecx.field_imm(sp, self.ecx.ident_of("flags"), flags),
self.ecx.field_imm(sp, self.ecx.ident_of("precision"), prec),
self.ecx.field_imm(sp, self.ecx.ident_of("width"), width),
]);
self.ecx.field_imm(sp, self.ecx.ident_of("width"), width)));
// Translate the method (if any)
let method = match arg.method {
@ -600,12 +594,11 @@ impl<'a> Context<'a> {
}
};
let path = self.ecx.path_global(sp, self.rtpath("Argument"));
let s = self.ecx.expr_struct(sp, path, ~[
let s = self.ecx.expr_struct(sp, path, vec!(
self.ecx.field_imm(sp, self.ecx.ident_of("position"), pos),
self.ecx.field_imm(sp, self.ecx.ident_of("format"), fmt),
self.ecx.field_imm(sp, self.ecx.ident_of("method"), method),
]);
self.ecx.expr_call_global(sp, self.rtpath("Argument"), ~[s])
self.ecx.field_imm(sp, self.ecx.ident_of("method"), method)));
self.ecx.expr_call_global(sp, self.rtpath("Argument"), vec!(s))
}
}
}
@ -613,11 +606,11 @@ impl<'a> Context<'a> {
/// Actually builds the expression which the iformat! block will be expanded
/// to
fn to_expr(&self, extra: @ast::Expr) -> @ast::Expr {
let mut lets = ~[];
let mut locals = ~[];
let mut lets = Vec::new();
let mut locals = Vec::new();
let mut names = vec::from_fn(self.name_positions.len(), |_| None);
let mut pats = ~[];
let mut heads = ~[];
let mut pats = Vec::new();
let mut heads = Vec::new();
// First, declare all of our methods that are statics
for &method in self.method_statics.iter() {
@ -631,15 +624,14 @@ impl<'a> Context<'a> {
let fmt = self.ecx.expr_vec(self.fmtsp, self.pieces.clone());
let piece_ty = self.ecx.ty_path(self.ecx.path_all(
self.fmtsp,
true, ~[
true, vec!(
self.ecx.ident_of("std"),
self.ecx.ident_of("fmt"),
self.ecx.ident_of("rt"),
self.ecx.ident_of("Piece"),
],
self.ecx.ident_of("Piece")),
opt_vec::with(
self.ecx.lifetime(self.fmtsp, self.ecx.ident_of("static").name)),
~[]
Vec::new()
), None);
let ty = ast::TyFixedLengthVec(
piece_ty,
@ -696,18 +688,17 @@ impl<'a> Context<'a> {
// Now create the fmt::Arguments struct with all our locals we created.
let fmt = self.ecx.expr_ident(self.fmtsp, static_name);
let args_slice = self.ecx.expr_ident(self.fmtsp, slicename);
let result = self.ecx.expr_call_global(self.fmtsp, ~[
let result = self.ecx.expr_call_global(self.fmtsp, vec!(
self.ecx.ident_of("std"),
self.ecx.ident_of("fmt"),
self.ecx.ident_of("Arguments"),
self.ecx.ident_of("new"),
], ~[fmt, args_slice]);
self.ecx.ident_of("new")), vec!(fmt, args_slice));
// We did all the work of making sure that the arguments
// structure is safe, so we can safely have an unsafe block.
let result = self.ecx.expr_block(P(ast::Block {
view_items: ~[],
stmts: ~[],
view_items: Vec::new(),
stmts: Vec::new(),
expr: Some(result),
id: ast::DUMMY_NODE_ID,
rules: ast::UnsafeBlock(ast::CompilerGenerated),
@ -716,8 +707,8 @@ impl<'a> Context<'a> {
let resname = self.ecx.ident_of("__args");
lets.push(self.ecx.stmt_let(self.fmtsp, false, resname, result));
let res = self.ecx.expr_ident(self.fmtsp, resname);
let result = self.ecx.expr_call(extra.span, extra, ~[
self.ecx.expr_addr_of(extra.span, res)]);
let result = self.ecx.expr_call(extra.span, extra, vec!(
self.ecx.expr_addr_of(extra.span, res)));
let body = self.ecx.expr_block(self.ecx.block(self.fmtsp, lets,
Some(result)));
@ -749,9 +740,9 @@ impl<'a> Context<'a> {
// But the nested match expression is proved to perform not as well
// as series of let's; the first approach does.
let pat = self.ecx.pat(self.fmtsp, ast::PatTup(pats));
let arm = self.ecx.arm(self.fmtsp, ~[pat], body);
let arm = self.ecx.arm(self.fmtsp, vec!(pat), body);
let head = self.ecx.expr(self.fmtsp, ast::ExprTup(heads));
self.ecx.expr_match(self.fmtsp, head, ~[arm])
self.ecx.expr_match(self.fmtsp, head, vec!(arm))
}
fn format_arg(&self, sp: Span, argno: Position, arg: @ast::Expr)
@ -787,31 +778,27 @@ impl<'a> Context<'a> {
}
}
String => {
return self.ecx.expr_call_global(sp, ~[
return self.ecx.expr_call_global(sp, vec!(
self.ecx.ident_of("std"),
self.ecx.ident_of("fmt"),
self.ecx.ident_of("argumentstr"),
], ~[arg])
self.ecx.ident_of("argumentstr")), vec!(arg))
}
Unsigned => {
return self.ecx.expr_call_global(sp, ~[
return self.ecx.expr_call_global(sp, vec!(
self.ecx.ident_of("std"),
self.ecx.ident_of("fmt"),
self.ecx.ident_of("argumentuint"),
], ~[arg])
self.ecx.ident_of("argumentuint")), vec!(arg))
}
};
let format_fn = self.ecx.path_global(sp, ~[
let format_fn = self.ecx.path_global(sp, vec!(
self.ecx.ident_of("std"),
self.ecx.ident_of("fmt"),
self.ecx.ident_of(fmt_fn),
]);
self.ecx.expr_call_global(sp, ~[
self.ecx.ident_of(fmt_fn)));
self.ecx.expr_call_global(sp, vec!(
self.ecx.ident_of("std"),
self.ecx.ident_of("fmt"),
self.ecx.ident_of("argument"),
], ~[self.ecx.expr_path(format_fn), arg])
self.ecx.ident_of("argument")), vec!(self.ecx.expr_path(format_fn), arg))
}
}
@ -832,8 +819,8 @@ pub fn expand_args(ecx: &mut ExtCtxt, sp: Span,
/// expression.
pub fn expand_preparsed_format_args(ecx: &mut ExtCtxt, sp: Span,
extra: @ast::Expr,
efmt: @ast::Expr, args: ~[@ast::Expr],
name_ordering: ~[~str],
efmt: @ast::Expr, args: Vec<@ast::Expr>,
name_ordering: Vec<~str>,
names: HashMap<~str, @ast::Expr>) -> @ast::Expr {
let arg_types = vec::from_fn(args.len(), |_| None);
let mut cx = Context {
@ -846,8 +833,8 @@ pub fn expand_preparsed_format_args(ecx: &mut ExtCtxt, sp: Span,
name_ordering: name_ordering,
nest_level: 0,
next_arg: 0,
pieces: ~[],
method_statics: ~[],
pieces: Vec::new(),
method_statics: Vec::new(),
fmtsp: sp,
};
cx.fmtsp = efmt.span;

104
src/libsyntax/ext/quote.rs
View file

@ -41,11 +41,11 @@ pub mod rt {
pub use codemap::{BytePos, Span, dummy_spanned};
pub trait ToTokens {
fn to_tokens(&self, _cx: &ExtCtxt) -> ~[TokenTree];
fn to_tokens(&self, _cx: &ExtCtxt) -> Vec<TokenTree> ;
}
impl ToTokens for ~[TokenTree] {
fn to_tokens(&self, _cx: &ExtCtxt) -> ~[TokenTree] {
impl ToTokens for Vec<TokenTree> {
fn to_tokens(&self, _cx: &ExtCtxt) -> Vec<TokenTree> {
(*self).clone()
}
}
@ -201,7 +201,7 @@ pub mod rt {
macro_rules! impl_to_tokens(
($t:ty) => (
impl ToTokens for $t {
fn to_tokens(&self, cx: &ExtCtxt) -> ~[TokenTree] {
fn to_tokens(&self, cx: &ExtCtxt) -> Vec<TokenTree> {
cx.parse_tts(self.to_source())
}
}
@ -211,7 +211,7 @@ pub mod rt {
macro_rules! impl_to_tokens_self(
($t:ty) => (
impl<'a> ToTokens for $t {
fn to_tokens(&self, cx: &ExtCtxt) -> ~[TokenTree] {
fn to_tokens(&self, cx: &ExtCtxt) -> Vec<TokenTree> {
cx.parse_tts(self.to_source())
}
}
@ -242,7 +242,7 @@ pub mod rt {
fn parse_item(&self, s: ~str) -> @ast::Item;
fn parse_expr(&self, s: ~str) -> @ast::Expr;
fn parse_stmt(&self, s: ~str) -> @ast::Stmt;
fn parse_tts(&self, s: ~str) -> ~[ast::TokenTree];
fn parse_tts(&self, s: ~str) -> Vec<ast::TokenTree> ;
}
impl<'a> ExtParseUtils for ExtCtxt<'a> {
@ -266,7 +266,7 @@ pub mod rt {
parse::parse_stmt_from_source_str("<quote expansion>".to_str(),
s,
self.cfg(),
~[],
Vec::new(),
self.parse_sess())
}
@ -277,7 +277,7 @@ pub mod rt {
self.parse_sess())
}
fn parse_tts(&self, s: ~str) -> ~[ast::TokenTree] {
fn parse_tts(&self, s: ~str) -> Vec<ast::TokenTree> {
parse::parse_tts_from_source_str("<quote expansion>".to_str(),
s,
self.cfg(),
@ -298,16 +298,16 @@ pub fn expand_quote_tokens(cx: &mut ExtCtxt,
pub fn expand_quote_expr(cx: &mut ExtCtxt,
sp: Span,
tts: &[ast::TokenTree]) -> base::MacResult {
let expanded = expand_parse_call(cx, sp, "parse_expr", ~[], tts);
let expanded = expand_parse_call(cx, sp, "parse_expr", Vec::new(), tts);
base::MRExpr(expanded)
}
pub fn expand_quote_item(cx: &mut ExtCtxt,
sp: Span,
tts: &[ast::TokenTree]) -> base::MacResult {
let e_attrs = cx.expr_vec_uniq(sp, ~[]);
let e_attrs = cx.expr_vec_uniq(sp, Vec::new());
let expanded = expand_parse_call(cx, sp, "parse_item",
~[e_attrs], tts);
vec!(e_attrs), tts);
base::MRExpr(expanded)
}
@ -316,7 +316,7 @@ pub fn expand_quote_pat(cx: &mut ExtCtxt,
tts: &[ast::TokenTree]) -> base::MacResult {
let e_refutable = cx.expr_lit(sp, ast::LitBool(true));
let expanded = expand_parse_call(cx, sp, "parse_pat",
~[e_refutable], tts);
vec!(e_refutable), tts);
base::MRExpr(expanded)
}
@ -325,20 +325,20 @@ pub fn expand_quote_ty(cx: &mut ExtCtxt,
tts: &[ast::TokenTree]) -> base::MacResult {
let e_param_colons = cx.expr_lit(sp, ast::LitBool(false));
let expanded = expand_parse_call(cx, sp, "parse_ty",
~[e_param_colons], tts);
vec!(e_param_colons), tts);
base::MRExpr(expanded)
}
pub fn expand_quote_stmt(cx: &mut ExtCtxt,
sp: Span,
tts: &[ast::TokenTree]) -> base::MacResult {
let e_attrs = cx.expr_vec_uniq(sp, ~[]);
let e_attrs = cx.expr_vec_uniq(sp, Vec::new());
let expanded = expand_parse_call(cx, sp, "parse_stmt",
~[e_attrs], tts);
vec!(e_attrs), tts);
base::MRExpr(expanded)
}
fn ids_ext(strs: ~[~str]) -> ~[ast::Ident] {
fn ids_ext(strs: Vec<~str> ) -> Vec<ast::Ident> {
strs.map(|str| str_to_ident(*str))
}
@ -352,7 +352,7 @@ fn mk_ident(cx: &ExtCtxt, sp: Span, ident: ast::Ident) -> @ast::Expr {
cx.expr_method_call(sp,
cx.expr_ident(sp, id_ext("ext_cx")),
id_ext("ident_of"),
~[e_str])
vec!(e_str))
}
fn mk_binop(cx: &ExtCtxt, sp: Span, bop: token::BinOp) -> @ast::Expr {
@ -377,18 +377,18 @@ fn mk_token(cx: &ExtCtxt, sp: Span, tok: &token::Token) -> @ast::Expr {
BINOP(binop) => {
return cx.expr_call_ident(sp,
id_ext("BINOP"),
~[mk_binop(cx, sp, binop)]);
vec!(mk_binop(cx, sp, binop)));
}
BINOPEQ(binop) => {
return cx.expr_call_ident(sp,
id_ext("BINOPEQ"),
~[mk_binop(cx, sp, binop)]);
vec!(mk_binop(cx, sp, binop)));
}
LIT_CHAR(i) => {
let e_char = cx.expr_lit(sp, ast::LitChar(i));
return cx.expr_call_ident(sp, id_ext("LIT_CHAR"), ~[e_char]);
return cx.expr_call_ident(sp, id_ext("LIT_CHAR"), vec!(e_char));
}
LIT_INT(i, ity) => {
@ -405,7 +405,7 @@ fn mk_token(cx: &ExtCtxt, sp: Span, tok: &token::Token) -> @ast::Expr {
return cx.expr_call_ident(sp,
id_ext("LIT_INT"),
~[e_i64, e_ity]);
vec!(e_i64, e_ity));
}
LIT_UINT(u, uty) => {
@ -422,7 +422,7 @@ fn mk_token(cx: &ExtCtxt, sp: Span, tok: &token::Token) -> @ast::Expr {
return cx.expr_call_ident(sp,
id_ext("LIT_UINT"),
~[e_u64, e_uty]);
vec!(e_u64, e_uty));
}
LIT_INT_UNSUFFIXED(i) => {
@ -430,7 +430,7 @@ fn mk_token(cx: &ExtCtxt, sp: Span, tok: &token::Token) -> @ast::Expr {
return cx.expr_call_ident(sp,
id_ext("LIT_INT_UNSUFFIXED"),
~[e_i64]);
vec!(e_i64));
}
LIT_FLOAT(fident, fty) => {
@ -444,39 +444,39 @@ fn mk_token(cx: &ExtCtxt, sp: Span, tok: &token::Token) -> @ast::Expr {
return cx.expr_call_ident(sp,
id_ext("LIT_FLOAT"),
~[e_fident, e_fty]);
vec!(e_fident, e_fty));
}
LIT_STR(ident) => {
return cx.expr_call_ident(sp,
id_ext("LIT_STR"),
~[mk_ident(cx, sp, ident)]);
vec!(mk_ident(cx, sp, ident)));
}
LIT_STR_RAW(ident, n) => {
return cx.expr_call_ident(sp,
id_ext("LIT_STR_RAW"),
~[mk_ident(cx, sp, ident),
cx.expr_uint(sp, n)]);
vec!(mk_ident(cx, sp, ident),
cx.expr_uint(sp, n)));
}
IDENT(ident, b) => {
return cx.expr_call_ident(sp,
id_ext("IDENT"),
~[mk_ident(cx, sp, ident),
cx.expr_bool(sp, b)]);
vec!(mk_ident(cx, sp, ident),
cx.expr_bool(sp, b)));
}
LIFETIME(ident) => {
return cx.expr_call_ident(sp,
id_ext("LIFETIME"),
~[mk_ident(cx, sp, ident)]);
vec!(mk_ident(cx, sp, ident)));
}
DOC_COMMENT(ident) => {
return cx.expr_call_ident(sp,
id_ext("DOC_COMMENT"),
~[mk_ident(cx, sp, ident)]);
vec!(mk_ident(cx, sp, ident)));
}
INTERPOLATED(_) => fail!("quote! with interpolated token"),
@ -523,7 +523,7 @@ fn mk_token(cx: &ExtCtxt, sp: Span, tok: &token::Token) -> @ast::Expr {
}
fn mk_tt(cx: &ExtCtxt, sp: Span, tt: &ast::TokenTree) -> ~[@ast::Stmt] {
fn mk_tt(cx: &ExtCtxt, sp: Span, tt: &ast::TokenTree) -> Vec<@ast::Stmt> {
match *tt {
@ -531,13 +531,13 @@ fn mk_tt(cx: &ExtCtxt, sp: Span, tt: &ast::TokenTree) -> ~[@ast::Stmt] {
let e_sp = cx.expr_ident(sp, id_ext("_sp"));
let e_tok = cx.expr_call_ident(sp,
id_ext("TTTok"),
~[e_sp, mk_token(cx, sp, tok)]);
vec!(e_sp, mk_token(cx, sp, tok)));
let e_push =
cx.expr_method_call(sp,
cx.expr_ident(sp, id_ext("tt")),
id_ext("push"),
~[e_tok]);
~[cx.stmt_expr(e_push)]
vec!(e_tok));
vec!(cx.stmt_expr(e_push))
}
ast::TTDelim(ref tts) => mk_tts(cx, sp, **tts),
@ -551,22 +551,22 @@ fn mk_tt(cx: &ExtCtxt, sp: Span, tt: &ast::TokenTree) -> ~[@ast::Stmt] {
cx.expr_method_call(sp,
cx.expr_ident(sp, ident),
id_ext("to_tokens"),
~[cx.expr_ident(sp, id_ext("ext_cx"))]);
vec!(cx.expr_ident(sp, id_ext("ext_cx"))));
let e_push =
cx.expr_method_call(sp,
cx.expr_ident(sp, id_ext("tt")),
id_ext("push_all_move"),
~[e_to_toks]);
vec!(e_to_toks));
~[cx.stmt_expr(e_push)]
vec!(cx.stmt_expr(e_push))
}
}
}
fn mk_tts(cx: &ExtCtxt, sp: Span, tts: &[ast::TokenTree])
-> ~[@ast::Stmt] {
let mut ss = ~[];
-> Vec<@ast::Stmt> {
let mut ss = Vec::new();
for tt in tts.iter() {
ss.push_all_move(mk_tt(cx, sp, tt));
}
@ -623,7 +623,7 @@ fn expand_tts(cx: &ExtCtxt, sp: Span, tts: &[ast::TokenTree])
let e_sp = cx.expr_method_call(sp,
cx.expr_ident(sp, id_ext("ext_cx")),
id_ext("call_site"),
~[]);
Vec::new());
let stmt_let_sp = cx.stmt_let(sp, false,
id_ext("_sp"),
@ -631,12 +631,12 @@ fn expand_tts(cx: &ExtCtxt, sp: Span, tts: &[ast::TokenTree])
let stmt_let_tt = cx.stmt_let(sp, true,
id_ext("tt"),
cx.expr_vec_uniq(sp, ~[]));
cx.expr_vec_uniq(sp, Vec::new()));
let block = cx.expr_block(
cx.block_all(sp,
~[],
~[stmt_let_sp, stmt_let_tt] + mk_tts(cx, sp, tts),
Vec::new(),
vec!(stmt_let_sp, stmt_let_tt) + mk_tts(cx, sp, tts),
Some(cx.expr_ident(sp, id_ext("tt")))));
(cx_expr, block)
@ -646,36 +646,36 @@ fn expand_wrapper(cx: &ExtCtxt,
sp: Span,
cx_expr: @ast::Expr,
expr: @ast::Expr) -> @ast::Expr {
let uses = ~[ cx.view_use_glob(sp, ast::Inherited,
ids_ext(~[~"syntax",
let uses = vec!( cx.view_use_glob(sp, ast::Inherited,
ids_ext(vec!(~"syntax",
~"ext",
~"quote",
~"rt"])) ];
~"rt"))) );
let stmt_let_ext_cx = cx.stmt_let(sp, false, id_ext("ext_cx"), cx_expr);
cx.expr_block(cx.block_all(sp, uses, ~[stmt_let_ext_cx], Some(expr)))
cx.expr_block(cx.block_all(sp, uses, vec!(stmt_let_ext_cx), Some(expr)))
}
fn expand_parse_call(cx: &ExtCtxt,
sp: Span,
parse_method: &str,
arg_exprs: ~[@ast::Expr],
arg_exprs: Vec<@ast::Expr> ,
tts: &[ast::TokenTree]) -> @ast::Expr {
let (cx_expr, tts_expr) = expand_tts(cx, sp, tts);
let cfg_call = || cx.expr_method_call(
sp, cx.expr_ident(sp, id_ext("ext_cx")),
id_ext("cfg"), ~[]);
id_ext("cfg"), Vec::new());
let parse_sess_call = || cx.expr_method_call(
sp, cx.expr_ident(sp, id_ext("ext_cx")),
id_ext("parse_sess"), ~[]);
id_ext("parse_sess"), Vec::new());
let new_parser_call =
cx.expr_call(sp,
cx.expr_ident(sp, id_ext("new_parser_from_tts")),
~[parse_sess_call(), cfg_call(), tts_expr]);
vec!(parse_sess_call(), cfg_call(), tts_expr));
let expr = cx.expr_method_call(sp, new_parser_call, id_ext(parse_method),
arg_exprs);

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

@ -16,7 +16,7 @@ use visit;
use visit::Visitor;
struct MacroRegistrarContext {
registrars: ~[(ast::NodeId, Span)],
registrars: Vec<(ast::NodeId, Span)> ,
}
impl Visitor<()> for MacroRegistrarContext {
@ -36,7 +36,7 @@ impl Visitor<()> for MacroRegistrarContext {
pub fn find_macro_registrar(diagnostic: @diagnostic::SpanHandler,
krate: &ast::Crate) -> Option<ast::DefId> {
let mut ctx = MacroRegistrarContext { registrars: ~[] };
let mut ctx = MacroRegistrarContext { registrars: Vec::new() };
visit::walk_crate(&mut ctx, krate, ());
match ctx.registrars.len() {

30
src/libsyntax/ext/tt/macro_parser.rs
View file

@ -99,11 +99,11 @@ nonempty body. */
#[deriving(Clone)]
pub struct MatcherPos {
elts: ~[ast::Matcher], // maybe should be <'>? Need to understand regions.
elts: Vec<ast::Matcher> , // maybe should be <'>? Need to understand regions.
sep: Option<Token>,
idx: uint,
up: Option<~MatcherPos>,
matches: ~[~[@NamedMatch]],
matches: vec!(Vec<@NamedMatch> ),
match_lo: uint, match_hi: uint,
sp_lo: BytePos,
}
@ -117,7 +117,7 @@ pub fn count_names(ms: &[Matcher]) -> uint {
}})
}
pub fn initial_matcher_pos(ms: ~[Matcher], sep: Option<Token>, lo: BytePos)
pub fn initial_matcher_pos(ms: Vec<Matcher> , sep: Option<Token>, lo: BytePos)
-> ~MatcherPos {
let mut match_idx_hi = 0u;
for elt in ms.iter() {
@ -131,7 +131,7 @@ pub fn initial_matcher_pos(ms: ~[Matcher], sep: Option<Token>, lo: BytePos)
}
}
}
let matches = vec::from_fn(count_names(ms), |_i| ~[]);
let matches = vec::from_fn(count_names(ms), |_i| Vec::new());
~MatcherPos {
elts: ms,
sep: sep,
@ -164,7 +164,7 @@ pub fn initial_matcher_pos(ms: ~[Matcher], sep: Option<Token>, lo: BytePos)
// ast::Matcher it was derived from.
pub enum NamedMatch {
MatchedSeq(~[@NamedMatch], codemap::Span),
MatchedSeq(Vec<@NamedMatch> , codemap::Span),
MatchedNonterminal(Nonterminal)
}
@ -206,7 +206,7 @@ pub enum ParseResult {
pub fn parse_or_else<R: Reader>(sess: @ParseSess,
cfg: ast::CrateConfig,
rdr: R,
ms: ~[Matcher])
ms: Vec<Matcher> )
-> HashMap<Ident, @NamedMatch> {
match parse(sess, cfg, rdr, ms) {
Success(m) => m,
@ -230,13 +230,13 @@ pub fn parse<R: Reader>(sess: @ParseSess,
rdr: R,
ms: &[Matcher])
-> ParseResult {
let mut cur_eis = ~[];
let mut cur_eis = Vec::new();
cur_eis.push(initial_matcher_pos(ms.to_owned(), None, rdr.peek().sp.lo));
loop {
let mut bb_eis = ~[]; // black-box parsed by parser.rs
let mut next_eis = ~[]; // or proceed normally
let mut eof_eis = ~[];
let mut bb_eis = Vec::new(); // black-box parsed by parser.rs
let mut next_eis = Vec::new(); // or proceed normally
let mut eof_eis = Vec::new();
let TokenAndSpan {tok: tok, sp: sp} = rdr.peek();
@ -317,13 +317,13 @@ pub fn parse<R: Reader>(sess: @ParseSess,
new_ei.idx += 1u;
//we specifically matched zero repeats.
for idx in range(match_idx_lo, match_idx_hi) {
new_ei.matches[idx].push(@MatchedSeq(~[], sp));
new_ei.matches[idx].push(@MatchedSeq(Vec::new(), sp));
}
cur_eis.push(new_ei);
}
let matches = vec::from_elem(ei.matches.len(), ~[]);
let matches = vec::from_elem(ei.matches.len(), Vec::new());
let ei_t = ei;
cur_eis.push(~MatcherPos {
elts: (*matchers).clone(),
@ -351,7 +351,7 @@ pub fn parse<R: Reader>(sess: @ParseSess,
/* error messages here could be improved with links to orig. rules */
if token_name_eq(&tok, &EOF) {
if eof_eis.len() == 1u {
let mut v = ~[];
let mut v = Vec::new();
for dv in eof_eis[0u].matches.mut_iter() {
v.push(dv.pop().unwrap());
}
@ -413,12 +413,12 @@ pub fn parse<R: Reader>(sess: @ParseSess,
pub fn parse_nt(p: &mut Parser, name: &str) -> Nonterminal {
match name {
"item" => match p.parse_item(~[]) {
"item" => match p.parse_item(Vec::new()) {
Some(i) => token::NtItem(i),
None => p.fatal("expected an item keyword")
},
"block" => token::NtBlock(p.parse_block()),
"stmt" => token::NtStmt(p.parse_stmt(~[])),
"stmt" => token::NtStmt(p.parse_stmt(Vec::new())),
"pat" => token::NtPat(p.parse_pat()),
"expr" => token::NtExpr(p.parse_expr()),
"ty" => token::NtTy(p.parse_ty(false /* no need to disambiguate*/)),

15
src/libsyntax/ext/tt/macro_rules.rs
View file

@ -90,8 +90,8 @@ impl AnyMacro for ParserAnyMacro {
struct MacroRulesMacroExpander {
name: Ident,
lhses: @~[@NamedMatch],
rhses: @~[@NamedMatch],
lhses: @Vec<@NamedMatch> ,
rhses: @Vec<@NamedMatch> ,
}
impl MacroExpander for MacroRulesMacroExpander {
@ -174,7 +174,7 @@ fn generic_extension(cx: &ExtCtxt,
pub fn add_new_extension(cx: &mut ExtCtxt,
sp: Span,
name: Ident,
arg: ~[ast::TokenTree])
arg: Vec<ast::TokenTree> )
-> base::MacResult {
// these spans won't matter, anyways
fn ms(m: Matcher_) -> Matcher {
@ -191,15 +191,14 @@ pub fn add_new_extension(cx: &mut ExtCtxt,
// The grammar for macro_rules! is:
// $( $lhs:mtcs => $rhs:tt );+
// ...quasiquoting this would be nice.
let argument_gram = ~[
ms(MatchSeq(~[
let argument_gram = vec!(
ms(MatchSeq(vec!(
ms(MatchNonterminal(lhs_nm, special_idents::matchers, 0u)),
ms(MatchTok(FAT_ARROW)),
ms(MatchNonterminal(rhs_nm, special_idents::tt, 1u)),
], Some(SEMI), false, 0u, 2u)),
ms(MatchNonterminal(rhs_nm, special_idents::tt, 1u))), Some(SEMI), false, 0u, 2u)),
//to phase into semicolon-termination instead of
//semicolon-separation
ms(MatchSeq(~[ms(MatchTok(SEMI))], None, true, 2u, 2u))];
ms(MatchSeq(vec!(ms(MatchTok(SEMI))), None, true, 2u, 2u)));
// Parse the macro_rules! invocation (`none` is for no interpolations):

12
src/libsyntax/ext/tt/transcribe.rs
View file

@ -22,7 +22,7 @@ use collections::HashMap;
///an unzipping of `TokenTree`s
struct TtFrame {
forest: @~[ast::TokenTree],
forest: @Vec<ast::TokenTree> ,
idx: Cell<uint>,
dotdotdoted: bool,
sep: Option<Token>,
@ -35,8 +35,8 @@ pub struct TtReader {
priv stack: RefCell<@TtFrame>,
/* for MBE-style macro transcription */
priv interpolations: RefCell<HashMap<Ident, @NamedMatch>>,
priv repeat_idx: RefCell<~[uint]>,
priv repeat_len: RefCell<~[uint]>,
priv repeat_idx: RefCell<Vec<uint> >,
priv repeat_len: RefCell<Vec<uint> >,
/* cached: */
cur_tok: RefCell<Token>,
cur_span: RefCell<Span>,
@ -47,7 +47,7 @@ pub struct TtReader {
* should) be none. */
pub fn new_tt_reader(sp_diag: @SpanHandler,
interp: Option<HashMap<Ident, @NamedMatch>>,
src: ~[ast::TokenTree])
src: Vec<ast::TokenTree> )
-> TtReader {
let r = TtReader {
sp_diag: sp_diag,
@ -62,8 +62,8 @@ pub fn new_tt_reader(sp_diag: @SpanHandler,
None => RefCell::new(HashMap::new()),
Some(x) => RefCell::new(x),
},
repeat_idx: RefCell::new(~[]),
repeat_len: RefCell::new(~[]),
repeat_idx: RefCell::new(Vec::new()),
repeat_len: RefCell::new(Vec::new()),
/* dummy values, never read: */
cur_tok: RefCell::new(EOF),
cur_span: RefCell::new(DUMMY_SP),

8
src/libsyntax/fold.rs
View file

@ -22,11 +22,11 @@ pub trait Folder {
noop_fold_crate(c, self)
}
fn fold_meta_items(&mut self, meta_items: &[@MetaItem]) -> ~[@MetaItem] {
fn fold_meta_items(&mut self, meta_items: &[@MetaItem]) -> Vec<@MetaItem> {
meta_items.map(|x| fold_meta_item_(*x, self))
}
fn fold_view_paths(&mut self, view_paths: &[@ViewPath]) -> ~[@ViewPath] {
fn fold_view_paths(&mut self, view_paths: &[@ViewPath]) -> Vec<@ViewPath> {
view_paths.map(|view_path| {
let inner_view_path = match view_path.node {
ViewPathSimple(ref ident, ref path, node_id) => {
@ -283,7 +283,7 @@ pub trait Folder {
}
}
fn map_exprs(&self, f: |@Expr| -> @Expr, es: &[@Expr]) -> ~[@Expr] {
fn map_exprs(&self, f: |@Expr| -> @Expr, es: &[@Expr]) -> Vec<@Expr> {
es.map(|x| f(*x))
}
@ -370,7 +370,7 @@ fn fold_arg_<T: Folder>(a: &Arg, fld: &mut T) -> Arg {
// since many token::IDENT are not necessary part of let bindings and most
// token::LIFETIME are certainly not loop labels. But we can't tell in their
// token form. So this is less ideal and hacky but it works.
pub fn fold_tts<T: Folder>(tts: &[TokenTree], fld: &mut T) -> ~[TokenTree] {
pub fn fold_tts<T: Folder>(tts: &[TokenTree], fld: &mut T) -> Vec<TokenTree> {
tts.map(|tt| {
match *tt {
TTTok(span, ref tok) =>

18
src/libsyntax/opt_vec.rs
View file

@ -21,14 +21,14 @@ use std::default::Default;
#[deriving(Clone, Encodable, Decodable, Hash)]
pub enum OptVec<T> {
Empty,
Vec(~[T])
Vec(Vec<T> )
}
pub fn with<T>(t: T) -> OptVec<T> {
Vec(~[t])
Vec(vec!(t))
}
pub fn from<T>(t: ~[T]) -> OptVec<T> {
pub fn from<T>(t: Vec<T> ) -> OptVec<T> {
if t.len() == 0 {
Empty
} else {
@ -44,7 +44,7 @@ impl<T> OptVec<T> {
return;
}
Empty => {
*self = Vec(~[t]);
*self = Vec(vec!(t));
}
}
}
@ -121,11 +121,11 @@ impl<T> OptVec<T> {
}
#[inline]
pub fn map_to_vec<B>(&self, op: |&T| -> B) -> ~[B] {
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) -> ~[B] {
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;
@ -135,16 +135,16 @@ impl<T> OptVec<T> {
}
}
pub fn take_vec<T>(v: OptVec<T>) -> ~[T] {
pub fn take_vec<T>(v: OptVec<T>) -> Vec<T> {
match v {
Empty => ~[],
Empty => Vec::new(),
Vec(v) => v
}
}
impl<T:Clone> OptVec<T> {
pub fn prepend(&self, t: T) -> OptVec<T> {
let mut v0 = ~[t];
let mut v0 = vec!(t);
match *self {
Empty => {}
Vec(ref v1) => { v0.push_all(*v1); }

24
src/libsyntax/parse/attr.rs
View file

@ -17,19 +17,19 @@ use parse::token::INTERPOLATED;
// a parser that can parse attributes.
pub trait ParserAttr {
fn parse_outer_attributes(&mut self) -> ~[ast::Attribute];
fn parse_outer_attributes(&mut self) -> Vec<ast::Attribute> ;
fn parse_attribute(&mut self, permit_inner: bool) -> ast::Attribute;
fn parse_inner_attrs_and_next(&mut self)
-> (~[ast::Attribute], ~[ast::Attribute]);
-> (Vec<ast::Attribute> , Vec<ast::Attribute> );
fn parse_meta_item(&mut self) -> @ast::MetaItem;
fn parse_meta_seq(&mut self) -> ~[@ast::MetaItem];
fn parse_optional_meta(&mut self) -> ~[@ast::MetaItem];
fn parse_meta_seq(&mut self) -> Vec<@ast::MetaItem> ;
fn parse_optional_meta(&mut self) -> Vec<@ast::MetaItem> ;
}
impl ParserAttr for Parser {
// Parse attributes that appear before an item
fn parse_outer_attributes(&mut self) -> ~[ast::Attribute] {
let mut attrs: ~[ast::Attribute] = ~[];
fn parse_outer_attributes(&mut self) -> Vec<ast::Attribute> {
let mut attrs: Vec<ast::Attribute> = Vec::new();
loop {
debug!("parse_outer_attributes: self.token={:?}",
self.token);
@ -116,9 +116,9 @@ impl ParserAttr for Parser {
// you can make the 'next' field an Option, but the result is going to be
// more useful as a vector.
fn parse_inner_attrs_and_next(&mut self)
-> (~[ast::Attribute], ~[ast::Attribute]) {
let mut inner_attrs: ~[ast::Attribute] = ~[];
let mut next_outer_attrs: ~[ast::Attribute] = ~[];
-> (Vec<ast::Attribute> , Vec<ast::Attribute> ) {
let mut inner_attrs: Vec<ast::Attribute> = Vec::new();
let mut next_outer_attrs: Vec<ast::Attribute> = Vec::new();
loop {
let attr = match self.token {
token::INTERPOLATED(token::NtAttr(..)) => {
@ -188,17 +188,17 @@ impl ParserAttr for Parser {
}
// matches meta_seq = ( COMMASEP(meta_item) )
fn parse_meta_seq(&mut self) -> ~[@ast::MetaItem] {
fn parse_meta_seq(&mut self) -> Vec<@ast::MetaItem> {
self.parse_seq(&token::LPAREN,
&token::RPAREN,
seq_sep_trailing_disallowed(token::COMMA),
|p| p.parse_meta_item()).node
}
fn parse_optional_meta(&mut self) -> ~[@ast::MetaItem] {
fn parse_optional_meta(&mut self) -> Vec<@ast::MetaItem> {
match self.token {
token::LPAREN => self.parse_meta_seq(),
_ => ~[]
_ => Vec::new()
}
}
}

36
src/libsyntax/parse/comments.rs
View file

@ -32,7 +32,7 @@ pub enum CommentStyle {
#[deriving(Clone)]
pub struct Comment {
style: CommentStyle,
lines: ~[~str],
lines: Vec<~str> ,
pos: BytePos
}
@ -54,7 +54,7 @@ pub fn doc_comment_style(comment: &str) -> ast::AttrStyle {
pub fn strip_doc_comment_decoration(comment: &str) -> ~str {
/// remove whitespace-only lines from the start/end of lines
fn vertical_trim(lines: ~[~str]) -> ~[~str] {
fn vertical_trim(lines: Vec<~str> ) -> Vec<~str> {
let mut i = 0u;
let mut j = lines.len();
// first line of all-stars should be omitted
@ -75,7 +75,7 @@ pub fn strip_doc_comment_decoration(comment: &str) -> ~str {
}
/// remove a "[ \t]*\*" block from each line, if possible
fn horizontal_trim(lines: ~[~str]) -> ~[~str] {
fn horizontal_trim(lines: Vec<~str> ) -> Vec<~str> {
let mut i = uint::MAX;
let mut can_trim = true;
let mut first = true;
@ -122,7 +122,7 @@ pub fn strip_doc_comment_decoration(comment: &str) -> ~str {
let lines = comment.slice(3u, comment.len() - 2u)
.lines_any()
.map(|s| s.to_owned())
.collect::<~[~str]>();
.collect::<Vec<~str> >();
let lines = vertical_trim(lines);
let lines = horizontal_trim(lines);
@ -157,9 +157,9 @@ fn consume_non_eol_whitespace(rdr: &StringReader) {
}
}
fn push_blank_line_comment(rdr: &StringReader, comments: &mut ~[Comment]) {
fn push_blank_line_comment(rdr: &StringReader, comments: &mut Vec<Comment> ) {
debug!(">>> blank-line comment");
let v: ~[~str] = ~[];
let v: Vec<~str> = Vec::new();
comments.push(Comment {
style: BlankLine,
lines: v,
@ -168,7 +168,7 @@ fn push_blank_line_comment(rdr: &StringReader, comments: &mut ~[Comment]) {
}
fn consume_whitespace_counting_blank_lines(rdr: &StringReader,
comments: &mut ~[Comment]) {
comments: &mut Vec<Comment> ) {
while is_whitespace(rdr.curr.get()) && !is_eof(rdr) {
if rdr.col.get() == CharPos(0u) && rdr.curr_is('\n') {
push_blank_line_comment(rdr, &mut *comments);
@ -179,22 +179,22 @@ fn consume_whitespace_counting_blank_lines(rdr: &StringReader,
fn read_shebang_comment(rdr: &StringReader, code_to_the_left: bool,
comments: &mut ~[Comment]) {
comments: &mut Vec<Comment> ) {
debug!(">>> shebang comment");
let p = rdr.last_pos.get();
debug!("<<< shebang comment");
comments.push(Comment {
style: if code_to_the_left { Trailing } else { Isolated },
lines: ~[read_one_line_comment(rdr)],
lines: vec!(read_one_line_comment(rdr)),
pos: p
});
}
fn read_line_comments(rdr: &StringReader, code_to_the_left: bool,
comments: &mut ~[Comment]) {
comments: &mut Vec<Comment> ) {
debug!(">>> line comments");
let p = rdr.last_pos.get();
let mut lines: ~[~str] = ~[];
let mut lines: Vec<~str> = Vec::new();
while rdr.curr_is('/') && nextch_is(rdr, '/') {
let line = read_one_line_comment(rdr);
debug!("{}", line);
@ -232,7 +232,7 @@ fn all_whitespace(s: &str, col: CharPos) -> Option<uint> {
return Some(cursor);
}
fn trim_whitespace_prefix_and_push_line(lines: &mut ~[~str],
fn trim_whitespace_prefix_and_push_line(lines: &mut Vec<~str> ,
s: ~str, col: CharPos) {
let len = s.len();
let s1 = match all_whitespace(s, col) {
@ -249,10 +249,10 @@ fn trim_whitespace_prefix_and_push_line(lines: &mut ~[~str],
fn read_block_comment(rdr: &StringReader,
code_to_the_left: bool,
comments: &mut ~[Comment]) {
comments: &mut Vec<Comment> ) {
debug!(">>> block comment");
let p = rdr.last_pos.get();
let mut lines: ~[~str] = ~[];
let mut lines: Vec<~str> = Vec::new();
let col: CharPos = rdr.col.get();
bump(rdr);
bump(rdr);
@ -324,7 +324,7 @@ fn peeking_at_comment(rdr: &StringReader) -> bool {
fn consume_comment(rdr: &StringReader,
code_to_the_left: bool,
comments: &mut ~[Comment]) {
comments: &mut Vec<Comment> ) {
debug!(">>> consume comment");
if rdr.curr_is('/') && nextch_is(rdr, '/') {
read_line_comments(rdr, code_to_the_left, comments);
@ -348,15 +348,15 @@ pub fn gather_comments_and_literals(span_diagnostic:
@diagnostic::SpanHandler,
path: ~str,
srdr: &mut io::Reader)
-> (~[Comment], ~[Literal]) {
-> (Vec<Comment> , Vec<Literal> ) {
let src = srdr.read_to_end().unwrap();
let src = str::from_utf8_owned(src).unwrap();
let cm = CodeMap::new();
let filemap = cm.new_filemap(path, src);
let rdr = lexer::new_low_level_string_reader(span_diagnostic, filemap);
let mut comments: ~[Comment] = ~[];
let mut literals: ~[Literal] = ~[];
let mut comments: Vec<Comment> = Vec::new();
let mut literals: Vec<Literal> = Vec::new();
let mut first_read: bool = true;
while !is_eof(&rdr) {
loop {

18
src/libsyntax/parse/lexer.rs
View file

@ -1048,7 +1048,7 @@ mod test {
// check that the given reader produces the desired stream
// of tokens (stop checking after exhausting the expected vec)
fn check_tokenization (env: Env, expected: ~[token::Token]) {
fn check_tokenization (env: Env, expected: Vec<token::Token> ) {
for expected_tok in expected.iter() {
let TokenAndSpan {tok:actual_tok, sp: _} =
env.string_reader.next_token();
@ -1064,32 +1064,32 @@ mod test {
#[test] fn doublecolonparsing () {
let env = setup (~"a b");
check_tokenization (env,
~[mk_ident("a",false),
mk_ident("b",false)]);
vec!(mk_ident("a",false),
mk_ident("b",false)));
}
#[test] fn dcparsing_2 () {
let env = setup (~"a::b");
check_tokenization (env,
~[mk_ident("a",true),
vec!(mk_ident("a",true),
token::MOD_SEP,
mk_ident("b",false)]);
mk_ident("b",false)));
}
#[test] fn dcparsing_3 () {
let env = setup (~"a ::b");
check_tokenization (env,
~[mk_ident("a",false),
vec!(mk_ident("a",false),
token::MOD_SEP,
mk_ident("b",false)]);
mk_ident("b",false)));
}
#[test] fn dcparsing_4 () {
let env = setup (~"a:: b");
check_tokenization (env,
~[mk_ident("a",true),
vec!(mk_ident("a",true),
token::MOD_SEP,
mk_ident("b",false)]);
mk_ident("b",false)));
}
#[test] fn character_a() {

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

@ -42,7 +42,7 @@ pub struct ParseSess {
cm: @codemap::CodeMap, // better be the same as the one in the reader!
span_diagnostic: @SpanHandler, // better be the same as the one in the reader!
/// Used to determine and report recursive mod inclusions
included_mod_stack: RefCell<~[Path]>,
included_mod_stack: RefCell<Vec<Path> >,
}
pub fn new_parse_sess() -> @ParseSess {
@ -50,7 +50,7 @@ pub fn new_parse_sess() -> @ParseSess {
@ParseSess {
cm: cm,
span_diagnostic: mk_span_handler(default_handler(), cm),
included_mod_stack: RefCell::new(~[]),
included_mod_stack: RefCell::new(Vec::new()),
}
}
@ -60,7 +60,7 @@ pub fn new_parse_sess_special_handler(sh: @SpanHandler,
@ParseSess {
cm: cm,
span_diagnostic: sh,
included_mod_stack: RefCell::new(~[]),
included_mod_stack: RefCell::new(Vec::new()),
}
}
@ -82,7 +82,7 @@ pub fn parse_crate_attrs_from_file(
input: &Path,
cfg: ast::CrateConfig,
sess: @ParseSess
) -> ~[ast::Attribute] {
) -> Vec<ast::Attribute> {
let mut parser = new_parser_from_file(sess, cfg, input);
let (inner, _) = parser.parse_inner_attrs_and_next();
return inner;
@ -104,7 +104,7 @@ pub fn parse_crate_attrs_from_source_str(name: ~str,
source: ~str,
cfg: ast::CrateConfig,
sess: @ParseSess)
-> ~[ast::Attribute] {
-> Vec<ast::Attribute> {
let mut p = new_parser_from_source_str(sess,
cfg,
name,
@ -144,7 +144,7 @@ pub fn parse_meta_from_source_str(name: ~str,
pub fn parse_stmt_from_source_str(name: ~str,
source: ~str,
cfg: ast::CrateConfig,
attrs: ~[ast::Attribute],
attrs: Vec<ast::Attribute> ,
sess: @ParseSess)
-> @ast::Stmt {
let mut p = new_parser_from_source_str(
@ -160,7 +160,7 @@ pub fn parse_tts_from_source_str(name: ~str,
source: ~str,
cfg: ast::CrateConfig,
sess: @ParseSess)
-> ~[ast::TokenTree] {
-> Vec<ast::TokenTree> {
let mut p = new_parser_from_source_str(
sess,
cfg,
@ -214,7 +214,7 @@ pub fn filemap_to_parser(sess: @ParseSess,
// compiler expands into it
pub fn new_parser_from_tts(sess: @ParseSess,
cfg: ast::CrateConfig,
tts: ~[ast::TokenTree]) -> Parser {
tts: Vec<ast::TokenTree> ) -> Parser {
tts_to_parser(sess,tts,cfg)
}
@ -256,10 +256,10 @@ pub fn string_to_filemap(sess: @ParseSess, source: ~str, path: ~str)
// given a filemap, produce a sequence of token-trees
pub fn filemap_to_tts(sess: @ParseSess, filemap: @FileMap)
-> ~[ast::TokenTree] {
-> Vec<ast::TokenTree> {
// it appears to me that the cfg doesn't matter here... indeed,
// parsing tt's probably shouldn't require a parser at all.
let cfg = ~[];
let cfg = Vec::new();
let srdr = lexer::new_string_reader(sess.span_diagnostic, filemap);
let mut p1 = Parser(sess, cfg, ~srdr);
p1.parse_all_token_trees()
@ -267,7 +267,7 @@ pub fn filemap_to_tts(sess: @ParseSess, filemap: @FileMap)
// given tts and cfg, produce a parser
pub fn tts_to_parser(sess: @ParseSess,
tts: ~[ast::TokenTree],
tts: Vec<ast::TokenTree> ,
cfg: ast::CrateConfig) -> Parser {
let trdr = lexer::new_tt_reader(sess.span_diagnostic, None, tts);
Parser(sess, cfg, ~trdr)
@ -318,13 +318,13 @@ mod test {
node: ast::ExprPath(ast::Path {
span: sp(0, 1),
global: false,
segments: ~[
segments: vec!(
ast::PathSegment {
identifier: str_to_ident("a"),
lifetimes: opt_vec::Empty,
types: opt_vec::Empty,
}
],
),
}),
span: sp(0, 1)
})
@ -337,7 +337,7 @@ mod test {
node: ast::ExprPath(ast::Path {
span: sp(0, 6),
global: true,
segments: ~[
segments: vec!(
ast::PathSegment {
identifier: str_to_ident("a"),
lifetimes: opt_vec::Empty,
@ -348,7 +348,7 @@ mod test {
lifetimes: opt_vec::Empty,
types: opt_vec::Empty,
}
]
)
}),
span: sp(0, 6)
})
@ -550,13 +550,13 @@ mod test {
node:ast::ExprPath(ast::Path{
span: sp(7, 8),
global: false,
segments: ~[
segments: vec!(
ast::PathSegment {
identifier: str_to_ident("d"),
lifetimes: opt_vec::Empty,
types: opt_vec::Empty,
}
],
),
}),
span:sp(7,8)
})),
@ -572,13 +572,13 @@ mod test {
node: ast::ExprPath(ast::Path {
span:sp(0,1),
global:false,
segments: ~[
segments: vec!(
ast::PathSegment {
identifier: str_to_ident("b"),
lifetimes: opt_vec::Empty,
types: opt_vec::Empty,
}
],
),
}),
span: sp(0,1)},
ast::DUMMY_NODE_ID),
@ -599,13 +599,13 @@ mod test {
ast::Path {
span:sp(0,1),
global:false,
segments: ~[
segments: vec!(
ast::PathSegment {
identifier: str_to_ident("b"),
lifetimes: opt_vec::Empty,
types: opt_vec::Empty,
}
],
),
},
None /* no idea */),
span: sp(0,1)});
@ -618,22 +618,22 @@ mod test {
assert!(string_to_item(~"fn a (b : int) { b; }") ==
Some(
@ast::Item{ident:str_to_ident("a"),
attrs:~[],
attrs:Vec::new(),
id: ast::DUMMY_NODE_ID,
node: ast::ItemFn(ast::P(ast::FnDecl {
inputs: ~[ast::Arg{
inputs: vec!(ast::Arg{
ty: ast::P(ast::Ty{id: ast::DUMMY_NODE_ID,
node: ast::TyPath(ast::Path{
span:sp(10,13),
global:false,
segments: ~[
segments: vec!(
ast::PathSegment {
identifier:
str_to_ident("int"),
lifetimes: opt_vec::Empty,
types: opt_vec::Empty,
}
],
),
}, None, ast::DUMMY_NODE_ID),
span:sp(10,13)
}),
@ -644,21 +644,21 @@ mod test {
ast::Path {
span:sp(6,7),
global:false,
segments: ~[
segments: vec!(
ast::PathSegment {
identifier:
str_to_ident("b"),
lifetimes: opt_vec::Empty,
types: opt_vec::Empty,
}
],
),
},
None // no idea
),
span: sp(6,7)
},
id: ast::DUMMY_NODE_ID
}],
}),
output: ast::P(ast::Ty{id: ast::DUMMY_NODE_ID,
node: ast::TyNil,
span:sp(15,15)}), // not sure
@ -672,15 +672,15 @@ mod test {
ty_params: opt_vec::Empty,
},
ast::P(ast::Block {
view_items: ~[],
stmts: ~[@Spanned{
view_items: Vec::new(),
stmts: vec!(@Spanned{
node: ast::StmtSemi(@ast::Expr{
id: ast::DUMMY_NODE_ID,
node: ast::ExprPath(
ast::Path{
span:sp(17,18),
global:false,
segments: ~[
segments: vec!(
ast::PathSegment {
identifier:
str_to_ident(
@ -690,11 +690,11 @@ mod test {
types:
opt_vec::Empty
}
],
),
}),
span: sp(17,18)},
ast::DUMMY_NODE_ID),
span: sp(17,18)}],
span: sp(17,18)}),
expr: None,
id: ast::DUMMY_NODE_ID,
rules: ast::DefaultBlock, // no idea

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

@ -93,7 +93,7 @@ enum restriction {
RESTRICT_NO_BAR_OR_DOUBLEBAR_OP,
}
type ItemInfo = (Ident, Item_, Option<~[Attribute]>);
type ItemInfo = (Ident, Item_, Option<Vec<Attribute> >);
/// How to parse a path. There are four different kinds of paths, all of which
/// are parsed somewhat differently.
@ -129,7 +129,7 @@ pub struct PathAndBounds {
enum ItemOrViewItem {
// Indicates a failure to parse any kind of item. The attributes are
// returned.
IoviNone(~[Attribute]),
IoviNone(Vec<Attribute> ),
IoviItem(@Item),
IoviForeignItem(@ForeignItem),
IoviViewItem(ViewItem)
@ -257,7 +257,7 @@ macro_rules! maybe_whole (
};
match __found__ {
Some(INTERPOLATED(token::$constructor(x))) => {
return (~[], x)
return (Vec::new(), x)
}
_ => {}
}
@ -266,21 +266,20 @@ macro_rules! maybe_whole (
)
fn maybe_append(lhs: ~[Attribute], rhs: Option<~[Attribute]>)
-> ~[Attribute] {
fn maybe_append(lhs: Vec<Attribute> , rhs: Option<Vec<Attribute> >)
-> Vec<Attribute> {
match rhs {
None => lhs,
Some(ref attrs) => vec::append(lhs, (*attrs))
Some(ref attrs) => vec_ng::append(lhs, (*attrs))
}
}
struct ParsedItemsAndViewItems {
attrs_remaining: ~[Attribute],
view_items: ~[ViewItem],
items: ~[@Item],
foreign_items: ~[@ForeignItem]
}
attrs_remaining: Vec<Attribute> ,
view_items: Vec<ViewItem> ,
items: Vec<@Item> ,
foreign_items: Vec<@ForeignItem> }
/* ident is handled by common.rs */
@ -314,8 +313,8 @@ pub fn Parser(sess: @ParseSess, cfg: ast::CrateConfig, rdr: ~Reader:)
restriction: UNRESTRICTED,
quote_depth: 0,
obsolete_set: HashSet::new(),
mod_path_stack: ~[],
open_braces: ~[],
mod_path_stack: Vec::new(),
open_braces: Vec::new(),
nopod: marker::NoPod
}
}
@ -343,9 +342,9 @@ pub struct Parser {
/// extra detail when the same error is seen twice
obsolete_set: HashSet<ObsoleteSyntax>,
/// Used to determine the path to externally loaded source files
mod_path_stack: ~[InternedString],
mod_path_stack: Vec<InternedString> ,
/// Stack of spans of open delimiters. Used for error message.
open_braces: ~[Span],
open_braces: Vec<Span> ,
/* do not copy the parser; its state is tied to outside state */
priv nopod: marker::NoPod
}
@ -407,7 +406,7 @@ impl Parser {
} else if inedible.contains(&self.token) {
// leave it in the input
} else {
let expected = vec::append(edible.to_owned(), inedible);
let expected = vec_ng::append(edible.to_owned(), inedible);
let expect = tokens_to_str(expected);
let actual = self.this_token_to_str();
self.fatal(
@ -446,7 +445,7 @@ impl Parser {
match e.node {
ExprPath(..) => {
// might be unit-struct construction; check for recoverableinput error.
let expected = vec::append(edible.to_owned(), inedible);
let expected = vec_ng::append(edible.to_owned(), inedible);
self.check_for_erroneous_unit_struct_expecting(expected);
}
_ => {}
@ -465,7 +464,7 @@ impl Parser {
debug!("commit_stmt {:?}", s);
let _s = s; // unused, but future checks might want to inspect `s`.
if self.last_token.as_ref().map_or(false, |t| is_ident_or_path(*t)) {
let expected = vec::append(edible.to_owned(), inedible);
let expected = vec_ng::append(edible.to_owned(), inedible);
self.check_for_erroneous_unit_struct_expecting(expected);
}
self.expect_one_of(edible, inedible)
@ -578,9 +577,9 @@ impl Parser {
&mut self,
sep: &token::Token,
f: |&mut Parser| -> T)
-> ~[T] {
-> Vec<T> {
let mut first = true;
let mut vector = ~[];
let mut vector = Vec::new();
while self.token != token::BINOP(token::OR) &&
self.token != token::OROR {
if first {
@ -655,7 +654,7 @@ impl Parser {
ket: &token::Token,
sep: SeqSep,
f: |&mut Parser| -> T)
-> ~[T] {
-> Vec<T> {
let val = self.parse_seq_to_before_end(ket, sep, f);
self.bump();
val
@ -669,9 +668,9 @@ impl Parser {
ket: &token::Token,
sep: SeqSep,
f: |&mut Parser| -> T)
-> ~[T] {
-> Vec<T> {
let mut first: bool = true;
let mut v: ~[T] = ~[];
let mut v: Vec<T> = Vec::new();
while self.token != *ket {
match sep.sep {
Some(ref t) => {
@ -695,7 +694,7 @@ impl Parser {
ket: &token::Token,
sep: SeqSep,
f: |&mut Parser| -> T)
-> ~[T] {
-> Vec<T> {
self.expect(bra);
let result = self.parse_seq_to_before_end(ket, sep, f);
self.bump();
@ -710,7 +709,7 @@ impl Parser {
ket: &token::Token,
sep: SeqSep,
f: |&mut Parser| -> T)
-> Spanned<~[T]> {
-> Spanned<Vec<T> > {
let lo = self.span.lo;
self.expect(bra);
let result = self.parse_seq_to_before_end(ket, sep, f);
@ -950,7 +949,7 @@ impl Parser {
};
let inputs = if self.eat(&token::OROR) {
~[]
Vec::new()
} else {
self.expect_or();
let inputs = self.parse_seq_to_before_or(
@ -1034,7 +1033,7 @@ impl Parser {
}
// parse the methods in a trait declaration
pub fn parse_trait_methods(&mut self) -> ~[TraitMethod] {
pub fn parse_trait_methods(&mut self) -> Vec<TraitMethod> {
self.parse_unspanned_seq(
&token::LBRACE,
&token::RBRACE,
@ -1083,7 +1082,7 @@ impl Parser {
debug!("parse_trait_methods(): parsing provided method");
let (inner_attrs, body) =
p.parse_inner_attrs_and_block();
let attrs = vec::append(attrs, inner_attrs);
let attrs = vec_ng::append(attrs, inner_attrs);
Provided(@ast::Method {
ident: ident,
attrs: attrs,
@ -1176,7 +1175,7 @@ impl Parser {
// (t) is a parenthesized ty
// (t,) is the type of a tuple with only one field,
// of type t
let mut ts = ~[self.parse_ty(false)];
let mut ts = vec!(self.parse_ty(false));
let mut one_tuple = false;
while self.token == token::COMMA {
self.bump();
@ -1479,7 +1478,7 @@ impl Parser {
// Parse any number of segments and bound sets. A segment is an
// identifier followed by an optional lifetime and a set of types.
// A bound set is a set of type parameter bounds.
let mut segments = ~[];
let mut segments = Vec::new();
loop {
// First, parse an identifier.
let identifier = self.parse_ident();
@ -1541,7 +1540,7 @@ impl Parser {
let span = mk_sp(lo, self.last_span.hi);
// Assemble the path segments.
let mut path_segments = ~[];
let mut path_segments = Vec::new();
let mut bounds = None;
let last_segment_index = segments.len() - 1;
for (i, segment_and_bounds) in segments.move_iter().enumerate() {
@ -1690,11 +1689,11 @@ impl Parser {
ExprBinary(binop, lhs, rhs)
}
pub fn mk_call(&mut self, f: @Expr, args: ~[@Expr]) -> ast::Expr_ {
pub fn mk_call(&mut self, f: @Expr, args: Vec<@Expr> ) -> ast::Expr_ {
ExprCall(f, args)
}
fn mk_method_call(&mut self, ident: Ident, tps: ~[P<Ty>], args: ~[@Expr]) -> ast::Expr_ {
fn mk_method_call(&mut self, ident: Ident, tps: Vec<P<Ty>> , args: Vec<@Expr> ) -> ast::Expr_ {
ExprMethodCall(ident, tps, args)
}
@ -1702,7 +1701,7 @@ impl Parser {
ExprIndex(expr, idx)
}
pub fn mk_field(&mut self, expr: @Expr, ident: Ident, tys: ~[P<Ty>]) -> ast::Expr_ {
pub fn mk_field(&mut self, expr: @Expr, ident: Ident, tys: Vec<P<Ty>> ) -> ast::Expr_ {
ExprField(expr, ident, tys)
}
@ -1754,7 +1753,7 @@ impl Parser {
let lit = @spanned(lo, hi, LitNil);
return self.mk_expr(lo, hi, ExprLit(lit));
}
let mut es = ~[self.parse_expr()];
let mut es = vec!(self.parse_expr());
self.commit_expr(*es.last().unwrap(), &[], &[token::COMMA, token::RPAREN]);
while self.token == token::COMMA {
self.bump();
@ -1786,8 +1785,8 @@ impl Parser {
let decl = self.parse_proc_decl();
let body = self.parse_expr();
let fakeblock = P(ast::Block {
view_items: ~[],
stmts: ~[],
view_items: Vec::new(),
stmts: Vec::new(),
expr: Some(body),
id: ast::DUMMY_NODE_ID,
rules: DefaultBlock,
@ -1840,7 +1839,7 @@ impl Parser {
if self.token == token::RBRACKET {
// Empty vector.
self.bump();
ex = ExprVec(~[], mutbl);
ex = ExprVec(Vec::new(), mutbl);
} else {
// Nonempty vector.
let first_expr = self.parse_expr();
@ -1860,11 +1859,11 @@ impl Parser {
seq_sep_trailing_allowed(token::COMMA),
|p| p.parse_expr()
);
ex = ExprVec(~[first_expr] + remaining_exprs, mutbl);
ex = ExprVec(vec!(first_expr) + remaining_exprs, mutbl);
} else {
// Vector with one element.
self.expect(&token::RBRACKET);
ex = ExprVec(~[first_expr], mutbl);
ex = ExprVec(vec!(first_expr), mutbl);
}
}
hi = self.last_span.hi;
@ -1919,7 +1918,7 @@ impl Parser {
if self.looking_at_struct_literal() {
// It's a struct literal.
self.bump();
let mut fields = ~[];
let mut fields = Vec::new();
let mut base = None;
while self.token != token::RBRACE {
@ -1981,7 +1980,7 @@ impl Parser {
self.expect(&token::LT);
self.parse_generic_values_after_lt()
} else {
(opt_vec::Empty, ~[])
(opt_vec::Empty, Vec::new())
};
// expr.f() method call
@ -2143,7 +2142,7 @@ impl Parser {
// Parse the open delimiter.
self.open_braces.push(self.span);
let mut result = ~[parse_any_tt_tok(self)];
let mut result = vec!(parse_any_tt_tok(self));
let trees =
self.parse_seq_to_before_end(&close_delim,
@ -2163,15 +2162,15 @@ impl Parser {
// parse a stream of tokens into a list of TokenTree's,
// up to EOF.
pub fn parse_all_token_trees(&mut self) -> ~[TokenTree] {
let mut tts = ~[];
pub fn parse_all_token_trees(&mut self) -> Vec<TokenTree> {
let mut tts = Vec::new();
while self.token != token::EOF {
tts.push(self.parse_token_tree());
}
tts
}
pub fn parse_matchers(&mut self) -> ~[Matcher] {
pub fn parse_matchers(&mut self) -> Vec<Matcher> {
// unification of Matcher's and TokenTree's would vastly improve
// the interpolation of Matcher's
maybe_whole!(self, NtMatchers);
@ -2192,8 +2191,8 @@ impl Parser {
pub fn parse_matcher_subseq_upto(&mut self,
name_idx: @Cell<uint>,
ket: &token::Token)
-> ~[Matcher] {
let mut ret_val = ~[];
-> Vec<Matcher> {
let mut ret_val = Vec::new();
let mut lparens = 0u;
while self.token != *ket || lparens > 0u {
@ -2478,7 +2477,7 @@ impl Parser {
_ => {
// No argument list - `do foo {`
P(FnDecl {
inputs: ~[],
inputs: Vec::new(),
output: P(Ty {
id: ast::DUMMY_NODE_ID,
node: TyInfer,
@ -2513,8 +2512,8 @@ impl Parser {
let decl = parse_decl(self);
let body = parse_body(self);
let fakeblock = P(ast::Block {
view_items: ~[],
stmts: ~[],
view_items: Vec::new(),
stmts: Vec::new(),
expr: Some(body),
id: ast::DUMMY_NODE_ID,
rules: DefaultBlock,
@ -2601,7 +2600,7 @@ impl Parser {
let lo = self.last_span.lo;
let discriminant = self.parse_expr();
self.commit_expr_expecting(discriminant, token::LBRACE);
let mut arms: ~[Arm] = ~[];
let mut arms: Vec<Arm> = Vec::new();
while self.token != token::RBRACE {
let pats = self.parse_pats();
let mut guard = None;
@ -2622,8 +2621,8 @@ impl Parser {
}
let blk = P(ast::Block {
view_items: ~[],
stmts: ~[],
view_items: Vec::new(),
stmts: Vec::new(),
expr: Some(expr),
id: ast::DUMMY_NODE_ID,
rules: DefaultBlock,
@ -2662,8 +2661,8 @@ impl Parser {
}
// parse patterns, separated by '|' s
fn parse_pats(&mut self) -> ~[@Pat] {
let mut pats = ~[];
fn parse_pats(&mut self) -> Vec<@Pat> {
let mut pats = Vec::new();
loop {
pats.push(self.parse_pat());
if self.token == token::BINOP(token::OR) { self.bump(); }
@ -2673,10 +2672,10 @@ impl Parser {
fn parse_pat_vec_elements(
&mut self,
) -> (~[@Pat], Option<@Pat>, ~[@Pat]) {
let mut before = ~[];
) -> (Vec<@Pat> , Option<@Pat>, Vec<@Pat> ) {
let mut before = Vec::new();
let mut slice = None;
let mut after = ~[];
let mut after = Vec::new();
let mut first = true;
let mut before_slice = true;
@ -2733,8 +2732,8 @@ impl Parser {
}
// parse the fields of a struct-like pattern
fn parse_pat_fields(&mut self) -> (~[ast::FieldPat], bool) {
let mut fields = ~[];
fn parse_pat_fields(&mut self) -> (Vec<ast::FieldPat> , bool) {
let mut fields = Vec::new();
let mut etc = false;
let mut first = true;
while self.token != token::RBRACE {
@ -2900,7 +2899,7 @@ impl Parser {
let expr = self.mk_expr(lo, hi, ExprLit(lit));
pat = PatLit(expr);
} else {
let mut fields = ~[self.parse_pat()];
let mut fields = vec!(self.parse_pat());
if self.look_ahead(1, |t| *t != token::RPAREN) {
while self.token == token::COMMA {
self.bump();
@ -3002,7 +3001,7 @@ impl Parser {
pat = PatStruct(enum_path, fields, etc);
}
_ => {
let mut args: ~[@Pat] = ~[];
let mut args: Vec<@Pat> = Vec::new();
match self.token {
token::LPAREN => {
let is_star = self.look_ahead(1, |t| {
@ -3128,7 +3127,7 @@ impl Parser {
// parse a structure field
fn parse_name_and_ty(&mut self, pr: Visibility,
attrs: ~[Attribute]) -> StructField {
attrs: Vec<Attribute> ) -> StructField {
let lo = self.span.lo;
if !is_plain_ident(&self.token) {
self.fatal("expected ident");
@ -3146,7 +3145,7 @@ impl Parser {
// parse a statement. may include decl.
// precondition: any attributes are parsed already
pub fn parse_stmt(&mut self, item_attrs: ~[Attribute]) -> @Stmt {
pub fn parse_stmt(&mut self, item_attrs: Vec<Attribute> ) -> @Stmt {
maybe_whole!(self, NtStmt);
fn check_expected_item(p: &mut Parser, found_attrs: bool) {
@ -3229,7 +3228,7 @@ impl Parser {
self.mk_item(
lo, hi, id /*id is good here*/,
ItemMac(spanned(lo, hi, MacInvocTT(pth, tts, EMPTY_CTXT))),
Inherited, ~[/*no attrs*/]))),
Inherited, Vec::new(/*no attrs*/)))),
ast::DUMMY_NODE_ID));
}
@ -3275,12 +3274,12 @@ impl Parser {
}
self.expect(&token::LBRACE);
return self.parse_block_tail_(lo, DefaultBlock, ~[]);
return self.parse_block_tail_(lo, DefaultBlock, Vec::new());
}
// parse a block. Inner attrs are allowed.
fn parse_inner_attrs_and_block(&mut self)
-> (~[Attribute], P<Block>) {
-> (Vec<Attribute> , P<Block>) {
maybe_whole!(pair_empty self, NtBlock);
@ -3299,13 +3298,13 @@ impl Parser {
// necessary, and this should take a qualifier.
// some blocks start with "#{"...
fn parse_block_tail(&mut self, lo: BytePos, s: BlockCheckMode) -> P<Block> {
self.parse_block_tail_(lo, s, ~[])
self.parse_block_tail_(lo, s, Vec::new())
}
// parse the rest of a block expression or function body
fn parse_block_tail_(&mut self, lo: BytePos, s: BlockCheckMode,
first_item_attrs: ~[Attribute]) -> P<Block> {
let mut stmts = ~[];
first_item_attrs: Vec<Attribute> ) -> P<Block> {
let mut stmts = Vec::new();
let mut expr = None;
// wouldn't it be more uniform to parse view items only, here?
@ -3333,7 +3332,7 @@ impl Parser {
token::SEMI => {
if !attributes_box.is_empty() {
self.span_err(self.last_span, "expected item after attributes");
attributes_box = ~[];
attributes_box = Vec::new();
}
self.bump(); // empty
}
@ -3342,7 +3341,7 @@ impl Parser {
}
_ => {
let stmt = self.parse_stmt(attributes_box);
attributes_box = ~[];
attributes_box = Vec::new();
match stmt.node {
StmtExpr(e, stmt_id) => {
// expression without semicolon
@ -3510,7 +3509,7 @@ impl Parser {
}
}
fn parse_generic_values_after_lt(&mut self) -> (OptVec<ast::Lifetime>, ~[P<Ty>]) {
fn parse_generic_values_after_lt(&mut self) -> (OptVec<ast::Lifetime>, Vec<P<Ty>> ) {
let lifetimes = self.parse_lifetimes();
let result = self.parse_seq_to_gt(
Some(token::COMMA),
@ -3519,9 +3518,9 @@ impl Parser {
}
fn parse_fn_args(&mut self, named_args: bool, allow_variadic: bool)
-> (~[Arg], bool) {
-> (Vec<Arg> , bool) {
let sp = self.span;
let mut args: ~[Option<Arg>] =
let mut args: Vec<Option<Arg>> =
self.parse_unspanned_seq(
&token::LPAREN,
&token::RPAREN,
@ -3716,7 +3715,7 @@ impl Parser {
fn_inputs
}
token::RPAREN => {
~[Arg::new_self(explicit_self_sp, mutbl_self)]
vec!(Arg::new_self(explicit_self_sp, mutbl_self))
}
_ => {
let token_str = self.this_token_to_str();
@ -3749,7 +3748,7 @@ impl Parser {
fn parse_fn_block_decl(&mut self) -> P<FnDecl> {
let inputs_captures = {
if self.eat(&token::OROR) {
~[]
Vec::new()
} else {
self.parse_unspanned_seq(
&token::BINOP(token::OR),
@ -3812,7 +3811,7 @@ impl Parser {
fn mk_item(&mut self, lo: BytePos, hi: BytePos, ident: Ident,
node: Item_, vis: Visibility,
attrs: ~[Attribute]) -> @Item {
attrs: Vec<Attribute> ) -> @Item {
@Item {
ident: ident,
attrs: attrs,
@ -3832,7 +3831,7 @@ impl Parser {
}
// parse a method in a trait impl, starting with `attrs` attributes.
fn parse_method(&mut self, already_parsed_attrs: Option<~[Attribute]>) -> @Method {
fn parse_method(&mut self, already_parsed_attrs: Option<Vec<Attribute> >) -> @Method {
let next_attrs = self.parse_outer_attributes();
let attrs = match already_parsed_attrs {
Some(mut a) => { a.push_all_move(next_attrs); a }
@ -3851,7 +3850,7 @@ impl Parser {
let (inner_attrs, body) = self.parse_inner_attrs_and_block();
let hi = body.span.hi;
let attrs = vec::append(attrs, inner_attrs);
let attrs = vec_ng::append(attrs, inner_attrs);
@ast::Method {
ident: ident,
attrs: attrs,
@ -3877,7 +3876,7 @@ impl Parser {
self.bump();
traits = self.parse_trait_ref_list(&token::LBRACE);
} else {
traits = ~[];
traits = Vec::new();
}
let meths = self.parse_trait_methods();
@ -3925,7 +3924,7 @@ impl Parser {
None
};
let mut meths = ~[];
let mut meths = Vec::new();
self.expect(&token::LBRACE);
let (inner_attrs, next) = self.parse_inner_attrs_and_next();
let mut method_attrs = Some(next);
@ -3948,7 +3947,7 @@ impl Parser {
}
// parse B + C<~str,int> + D
fn parse_trait_ref_list(&mut self, ket: &token::Token) -> ~[TraitRef] {
fn parse_trait_ref_list(&mut self, ket: &token::Token) -> Vec<TraitRef> {
self.parse_seq_to_before_end(
ket,
seq_sep_trailing_disallowed(token::BINOP(token::PLUS)),
@ -3961,13 +3960,13 @@ impl Parser {
let class_name = self.parse_ident();
let generics = self.parse_generics();
let mut fields: ~[StructField];
let mut fields: Vec<StructField> ;
let is_tuple_like;
if self.eat(&token::LBRACE) {
// It's a record-like struct.
is_tuple_like = false;
fields = ~[];
fields = Vec::new();
while self.token != token::RBRACE {
fields.push(self.parse_struct_decl_field());
}
@ -3998,7 +3997,7 @@ impl Parser {
} else if self.eat(&token::SEMI) {
// It's a unit-like struct.
is_tuple_like = true;
fields = ~[];
fields = Vec::new();
} else {
let token_str = self.this_token_to_str();
self.fatal(format!("expected `\\{`, `(`, or `;` after struct \
@ -4019,7 +4018,7 @@ impl Parser {
// parse a structure field declaration
pub fn parse_single_struct_field(&mut self,
vis: Visibility,
attrs: ~[Attribute])
attrs: Vec<Attribute> )
-> StructField {
let a_var = self.parse_name_and_ty(vis, attrs);
match self.token {
@ -4064,7 +4063,7 @@ impl Parser {
// attributes (of length 0 or 1), parse all of the items in a module
fn parse_mod_items(&mut self,
term: token::Token,
first_item_attrs: ~[Attribute])
first_item_attrs: Vec<Attribute> )
-> Mod {
// parse all of the items up to closing or an attribute.
// view items are legal here.
@ -4074,7 +4073,7 @@ impl Parser {
items: starting_items,
..
} = self.parse_items_and_view_items(first_item_attrs, true, true);
let mut items: ~[@Item] = starting_items;
let mut items: Vec<@Item> = starting_items;
let attrs_remaining_len = attrs_remaining.len();
// don't think this other loop is even necessary....
@ -4162,7 +4161,7 @@ impl Parser {
id: ast::Ident,
outer_attrs: &[ast::Attribute],
id_sp: Span)
-> (ast::Item_, ~[ast::Attribute]) {
-> (ast::Item_, Vec<ast::Attribute> ) {
let mut prefix = Path::new(self.sess.cm.span_to_filename(self.span));
prefix.pop();
let mod_path = Path::new(".").join_many(self.mod_path_stack);
@ -4201,8 +4200,8 @@ impl Parser {
fn eval_src_mod_from_path(&mut self,
path: Path,
outer_attrs: ~[ast::Attribute],
id_sp: Span) -> (ast::Item_, ~[ast::Attribute]) {
outer_attrs: Vec<ast::Attribute> ,
id_sp: Span) -> (ast::Item_, Vec<ast::Attribute> ) {
{
let mut included_mod_stack = self.sess
.included_mod_stack
@ -4232,7 +4231,7 @@ impl Parser {
&path,
id_sp);
let (inner, next) = p0.parse_inner_attrs_and_next();
let mod_attrs = vec::append(outer_attrs, inner);
let mod_attrs = vec_ng::append(outer_attrs, inner);
let first_item_outer_attrs = next;
let m0 = p0.parse_mod_items(token::EOF, first_item_outer_attrs);
{
@ -4246,7 +4245,7 @@ impl Parser {
// parse a function declaration from a foreign module
fn parse_item_foreign_fn(&mut self, vis: ast::Visibility,
attrs: ~[Attribute]) -> @ForeignItem {
attrs: Vec<Attribute> ) -> @ForeignItem {
let lo = self.span.lo;
// Parse obsolete purity.
@ -4269,7 +4268,7 @@ impl Parser {
// parse a static item from a foreign module
fn parse_item_foreign_static(&mut self, vis: ast::Visibility,
attrs: ~[Attribute]) -> @ForeignItem {
attrs: Vec<Attribute> ) -> @ForeignItem {
let lo = self.span.lo;
self.expect_keyword(keywords::Static);
@ -4303,7 +4302,7 @@ impl Parser {
// parse_foreign_items.
fn parse_foreign_mod_items(&mut self,
abis: AbiSet,
first_item_attrs: ~[Attribute])
first_item_attrs: Vec<Attribute> )
-> ForeignMod {
let ParsedItemsAndViewItems {
attrs_remaining: attrs_remaining,
@ -4332,7 +4331,7 @@ impl Parser {
fn parse_item_extern_crate(&mut self,
lo: BytePos,
visibility: Visibility,
attrs: ~[Attribute])
attrs: Vec<Attribute> )
-> ItemOrViewItem {
let (maybe_path, ident) = match self.token {
@ -4377,7 +4376,7 @@ impl Parser {
lo: BytePos,
opt_abis: Option<AbiSet>,
visibility: Visibility,
attrs: ~[Attribute])
attrs: Vec<Attribute> )
-> ItemOrViewItem {
self.expect(&token::LBRACE);
@ -4410,7 +4409,7 @@ impl Parser {
// parse a structure-like enum variant definition
// this should probably be renamed or refactored...
fn parse_struct_def(&mut self) -> @StructDef {
let mut fields: ~[StructField] = ~[];
let mut fields: Vec<StructField> = Vec::new();
while self.token != token::RBRACE {
fields.push(self.parse_struct_decl_field());
}
@ -4424,7 +4423,7 @@ impl Parser {
// parse the part of an "enum" decl following the '{'
fn parse_enum_def(&mut self, _generics: &ast::Generics) -> EnumDef {
let mut variants = ~[];
let mut variants = Vec::new();
let mut all_nullary = true;
let mut have_disr = false;
while self.token != token::RBRACE {
@ -4435,7 +4434,7 @@ impl Parser {
let ident;
let kind;
let mut args = ~[];
let mut args = Vec::new();
let mut disr_expr = None;
ident = self.parse_ident();
if self.eat(&token::LBRACE) {
@ -4462,7 +4461,7 @@ impl Parser {
disr_expr = Some(self.parse_expr());
kind = TupleVariantKind(args);
} else {
kind = TupleVariantKind(~[]);
kind = TupleVariantKind(Vec::new());
}
let vr = ast::Variant_ {
@ -4551,13 +4550,13 @@ impl Parser {
// NB: this function no longer parses the items inside an
// extern crate.
fn parse_item_or_view_item(&mut self,
attrs: ~[Attribute],
attrs: Vec<Attribute> ,
macros_allowed: bool)
-> ItemOrViewItem {
match self.token {
INTERPOLATED(token::NtItem(item)) => {
self.bump();
let new_attrs = vec::append(attrs, item.attrs);
let new_attrs = vec_ng::append(attrs, item.attrs);
return IoviItem(@Item {
attrs: new_attrs,
..(*item).clone()
@ -4732,7 +4731,7 @@ impl Parser {
// parse a foreign item; on failure, return IoviNone.
fn parse_foreign_item(&mut self,
attrs: ~[Attribute],
attrs: Vec<Attribute> ,
macros_allowed: bool)
-> ItemOrViewItem {
maybe_whole!(iovi self, NtItem);
@ -4756,7 +4755,7 @@ impl Parser {
// this is the fall-through for parsing items.
fn parse_macro_use_or_failure(
&mut self,
attrs: ~[Attribute],
attrs: Vec<Attribute> ,
macros_allowed: bool,
lo: BytePos,
visibility: Visibility
@ -4820,7 +4819,7 @@ impl Parser {
return IoviNone(attrs);
}
pub fn parse_item(&mut self, attrs: ~[Attribute]) -> Option<@Item> {
pub fn parse_item(&mut self, attrs: Vec<Attribute> ) -> Option<@Item> {
match self.parse_item_or_view_item(attrs, true) {
IoviNone(_) => None,
IoviViewItem(_) =>
@ -4854,20 +4853,20 @@ impl Parser {
let path = ast::Path {
span: mk_sp(lo, self.span.hi),
global: false,
segments: ~[]
segments: Vec::new()
};
return @spanned(lo, self.span.hi,
ViewPathList(path, idents, ast::DUMMY_NODE_ID));
}
let first_ident = self.parse_ident();
let mut path = ~[first_ident];
let mut path = vec!(first_ident);
match self.token {
token::EQ => {
// x = foo::bar
self.bump();
let path_lo = self.span.lo;
path = ~[self.parse_ident()];
path = vec!(self.parse_ident());
while self.token == token::MOD_SEP {
self.bump();
let id = self.parse_ident();
@ -4965,8 +4964,8 @@ impl Parser {
}
// matches view_paths = view_path | view_path , view_paths
fn parse_view_paths(&mut self) -> ~[@ViewPath] {
let mut vp = ~[self.parse_view_path()];
fn parse_view_paths(&mut self) -> Vec<@ViewPath> {
let mut vp = vec!(self.parse_view_path());
while self.token == token::COMMA {
self.bump();
self.obsolete(self.last_span, ObsoleteMultipleImport);
@ -4980,15 +4979,15 @@ impl Parser {
// - mod_items uses extern_mod_allowed = true
// - block_tail_ uses extern_mod_allowed = false
fn parse_items_and_view_items(&mut self,
first_item_attrs: ~[Attribute],
first_item_attrs: Vec<Attribute> ,
mut extern_mod_allowed: bool,
macros_allowed: bool)
-> ParsedItemsAndViewItems {
let mut attrs = vec::append(first_item_attrs,
let mut attrs = vec_ng::append(first_item_attrs,
self.parse_outer_attributes());
// First, parse view items.
let mut view_items : ~[ast::ViewItem] = ~[];
let mut items = ~[];
let mut view_items : Vec<ast::ViewItem> = Vec::new();
let mut items = Vec::new();
// I think this code would probably read better as a single
// loop with a mutable three-state-variable (for extern crates,
@ -5001,7 +5000,7 @@ impl Parser {
attrs_remaining: attrs,
view_items: view_items,
items: items,
foreign_items: ~[]
foreign_items: Vec::new()
}
}
IoviViewItem(view_item) => {
@ -5056,18 +5055,18 @@ impl Parser {
attrs_remaining: attrs,
view_items: view_items,
items: items,
foreign_items: ~[]
foreign_items: Vec::new()
}
}
// Parses a sequence of foreign items. Stops when it finds program
// text that can't be parsed as an item
fn parse_foreign_items(&mut self, first_item_attrs: ~[Attribute],
fn parse_foreign_items(&mut self, first_item_attrs: Vec<Attribute> ,
macros_allowed: bool)
-> ParsedItemsAndViewItems {
let mut attrs = vec::append(first_item_attrs,
let mut attrs = vec_ng::append(first_item_attrs,
self.parse_outer_attributes());
let mut foreign_items = ~[];
let mut foreign_items = Vec::new();
loop {
match self.parse_foreign_item(attrs, macros_allowed) {
IoviNone(returned_attrs) => {
@ -5095,8 +5094,8 @@ impl Parser {
ParsedItemsAndViewItems {
attrs_remaining: attrs,
view_items: ~[],
items: ~[],
view_items: Vec::new(),
items: Vec::new(),
foreign_items: foreign_items
}
}

6
src/libsyntax/parse/token.rs
View file

@ -115,7 +115,7 @@ pub enum Nonterminal {
NtAttr(@ast::Attribute), // #[foo]
NtPath(~ast::Path),
NtTT( @ast::TokenTree), // needs @ed to break a circularity
NtMatchers(~[ast::Matcher])
NtMatchers(Vec<ast::Matcher> )
}
impl fmt::Show for Nonterminal {
@ -412,11 +412,11 @@ macro_rules! declare_special_idents_and_keywords {(
// The indices here must correspond to the numbers in
// special_idents, in Keyword to_ident(), and in static
// constants below.
let init_vec = ~[
let init_vec = vec!(
$( $si_str, )*
$( $sk_str, )*
$( $rk_str, )*
];
);
interner::StrInterner::prefill(init_vec)
}

18
src/libsyntax/print/pp.rs
View file

@ -119,7 +119,7 @@ pub fn tok_str(t: Token) -> ~str {
}
}
pub fn buf_str(toks: ~[Token], szs: ~[int], left: uint, right: uint,
pub fn buf_str(toks: Vec<Token> , szs: Vec<int> , left: uint, right: uint,
lim: uint) -> ~str {
let n = toks.len();
assert_eq!(n, szs.len());
@ -156,9 +156,9 @@ pub fn mk_printer(out: ~io::Writer, linewidth: uint) -> Printer {
// fall behind.
let n: uint = 3 * linewidth;
debug!("mk_printer {}", linewidth);
let token: ~[Token] = vec::from_elem(n, Eof);
let size: ~[int] = vec::from_elem(n, 0);
let scan_stack: ~[uint] = vec::from_elem(n, 0u);
let token: Vec<Token> = vec::from_elem(n, Eof);
let size: Vec<int> = vec::from_elem(n, 0);
let scan_stack: Vec<uint> = vec::from_elem(n, 0u);
Printer {
out: out,
buf_len: n,
@ -174,7 +174,7 @@ pub fn mk_printer(out: ~io::Writer, linewidth: uint) -> Printer {
scan_stack_empty: true,
top: 0,
bottom: 0,
print_stack: ~[],
print_stack: Vec::new(),
pending_indentation: 0
}
}
@ -264,8 +264,8 @@ pub struct Printer {
space: int, // number of spaces left on line
left: uint, // index of left side of input stream
right: uint, // index of right side of input stream
token: ~[Token], // ring-buffr stream goes through
size: ~[int], // ring-buffer of calculated sizes
token: Vec<Token> , // ring-buffr stream goes through
size: Vec<int> , // ring-buffer of calculated sizes
left_total: int, // running size of stream "...left"
right_total: int, // running size of stream "...right"
// pseudo-stack, really a ring too. Holds the
@ -274,12 +274,12 @@ pub struct Printer {
// Begin (if there is any) on top of it. Stuff is flushed off the
// bottom as it becomes irrelevant due to the primary ring-buffer
// advancing.
scan_stack: ~[uint],
scan_stack: Vec<uint> ,
scan_stack_empty: bool, // top==bottom disambiguator
top: uint, // index of top of scan_stack
bottom: uint, // index of bottom of scan_stack
// stack of blocks-in-progress being flushed by print
print_stack: ~[PrintStackElem],
print_stack: Vec<PrintStackElem> ,
// buffered indentation to avoid writing trailing whitespace
pending_indentation: int,
}

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

@ -60,10 +60,10 @@ pub struct State<'a> {
s: pp::Printer,
cm: Option<@CodeMap>,
intr: @token::IdentInterner,
comments: Option<~[comments::Comment]>,
literals: Option<~[comments::Literal]>,
comments: Option<Vec<comments::Comment> >,
literals: Option<Vec<comments::Literal> >,
cur_cmnt_and_lit: CurrentCommentAndLiteral,
boxes: RefCell<~[pp::Breaks]>,
boxes: RefCell<Vec<pp::Breaks> >,
ann: &'a PpAnn
}
@ -98,7 +98,7 @@ pub fn rust_printer_annotated<'a>(writer: ~io::Writer, ann: &'a PpAnn) -> State<
cur_cmnt: 0,
cur_lit: 0
},
boxes: RefCell::new(~[]),
boxes: RefCell::new(Vec::new()),
ann: ann
}
}
@ -140,7 +140,7 @@ pub fn print_crate(cm: @CodeMap,
cur_cmnt: 0,
cur_lit: 0
},
boxes: RefCell::new(~[]),
boxes: RefCell::new(Vec::new()),
ann: ann
};
print_crate_(&mut s, krate)
@ -1981,7 +1981,7 @@ pub fn print_generics(s: &mut State,
}
}
let mut ints = ~[];
let mut ints = Vec::new();
for i in range(0u, total) {
ints.push(i);
}
@ -2540,7 +2540,7 @@ mod test {
let abba_ident = token::str_to_ident("abba");
let decl = ast::FnDecl {
inputs: ~[],
inputs: Vec::new(),
output: ast::P(ast::Ty {id: 0,
node: ast::TyNil,
span: codemap::DUMMY_SP}),
@ -2559,9 +2559,9 @@ mod test {
let var = codemap::respan(codemap::DUMMY_SP, ast::Variant_ {
name: ident,
attrs: ~[],
attrs: Vec::new(),
// making this up as I go.... ?
kind: ast::TupleVariantKind(~[]),
kind: ast::TupleVariantKind(Vec::new()),
id: 0,
disr_expr: None,
vis: ast::Public,

8
src/libsyntax/util/interner.rs
View file

@ -24,7 +24,7 @@ use std::rc::Rc;
pub struct Interner<T> {
priv map: RefCell<HashMap<T, Name>>,
priv vect: RefCell<~[T]>,
priv vect: RefCell<Vec<T> >,
}
// when traits can extend traits, we should extend index<Name,T> to get []
@ -32,7 +32,7 @@ impl<T:Eq + Hash + Freeze + Clone + 'static> Interner<T> {
pub fn new() -> Interner<T> {
Interner {
map: RefCell::new(HashMap::new()),
vect: RefCell::new(~[]),
vect: RefCell::new(Vec::new()),
}
}
@ -134,7 +134,7 @@ impl RcStr {
// &str rather than RcStr, resulting in less allocation.
pub struct StrInterner {
priv map: RefCell<HashMap<RcStr, Name>>,
priv vect: RefCell<~[RcStr]>,
priv vect: RefCell<Vec<RcStr> >,
}
// when traits can extend traits, we should extend index<Name,T> to get []
@ -142,7 +142,7 @@ impl StrInterner {
pub fn new() -> StrInterner {
StrInterner {
map: RefCell::new(HashMap::new()),
vect: RefCell::new(~[]),
vect: RefCell::new(Vec::new()),
}
}

12
src/libsyntax/util/parser_testing.rs
View file

@ -17,20 +17,20 @@ use parse::token;
// map a string to tts, using a made-up filename: return both the TokenTree's
// and the ParseSess
pub fn string_to_tts_and_sess (source_str : ~str) -> (~[ast::TokenTree], @ParseSess) {
pub fn string_to_tts_and_sess (source_str : ~str) -> (Vec<ast::TokenTree> , @ParseSess) {
let ps = new_parse_sess();
(filemap_to_tts(ps,string_to_filemap(ps,source_str,~"bogofile")),ps)
}
// map a string to tts, using a made-up filename:
pub fn string_to_tts(source_str : ~str) -> ~[ast::TokenTree] {
pub fn string_to_tts(source_str : ~str) -> Vec<ast::TokenTree> {
let (tts,_) = string_to_tts_and_sess(source_str);
tts
}
pub fn string_to_parser_and_sess(source_str: ~str) -> (Parser,@ParseSess) {
let ps = new_parse_sess();
(new_parser_from_source_str(ps,~[],~"bogofile",source_str),ps)
(new_parser_from_source_str(ps,Vec::new(),~"bogofile",source_str),ps)
}
// map string to parser (via tts)
@ -69,14 +69,14 @@ pub fn string_to_expr (source_str : ~str) -> @ast::Expr {
// parse a string, return an item
pub fn string_to_item (source_str : ~str) -> Option<@ast::Item> {
with_error_checking_parse(source_str, |p| {
p.parse_item(~[])
p.parse_item(Vec::new())
})
}
// parse a string, return a stmt
pub fn string_to_stmt(source_str : ~str) -> @ast::Stmt {
with_error_checking_parse(source_str, |p| {
p.parse_stmt(~[])
p.parse_stmt(Vec::new())
})
}
@ -87,7 +87,7 @@ pub fn string_to_pat(source_str : ~str) -> @ast::Pat {
}
// convert a vector of strings to a vector of ast::Ident's
pub fn strs_to_idents(ids: ~[&str]) -> ~[ast::Ident] {
pub fn strs_to_idents(ids: Vec<&str> ) -> Vec<ast::Ident> {
ids.map(|u| token::str_to_ident(*u))
}

24
src/libsyntax/util/small_vector.rs
View file

@ -14,7 +14,7 @@ use std::vec;
pub enum SmallVector<T> {
priv Zero,
priv One(T),
priv Many(~[T]),
priv Many(Vec<T> ),
}
impl<T> Container for SmallVector<T> {
@ -46,7 +46,7 @@ impl<T> SmallVector<T> {
One(v)
}
pub fn many(vs: ~[T]) -> SmallVector<T> {
pub fn many(vs: Vec<T> ) -> SmallVector<T> {
Many(vs)
}
@ -56,7 +56,7 @@ impl<T> SmallVector<T> {
One(..) => {
let one = mem::replace(self, Zero);
match one {
One(v1) => mem::replace(self, Many(~[v1, v])),
One(v1) => mem::replace(self, Many(vec!(v1, v))),
_ => unreachable!()
};
}
@ -142,7 +142,7 @@ mod test {
assert_eq!(0, v.len());
assert_eq!(1, SmallVector::one(1).len());
assert_eq!(5, SmallVector::many(~[1, 2, 3, 4, 5]).len());
assert_eq!(5, SmallVector::many(vec!(1, 2, 3, 4, 5)).len());
}
#[test]
@ -161,7 +161,7 @@ mod test {
#[test]
fn test_from_iterator() {
let v: SmallVector<int> = (~[1, 2, 3]).move_iter().collect();
let v: SmallVector<int> = (vec!(1, 2, 3)).move_iter().collect();
assert_eq!(3, v.len());
assert_eq!(&1, v.get(0));
assert_eq!(&2, v.get(1));
@ -171,14 +171,14 @@ mod test {
#[test]
fn test_move_iter() {
let v = SmallVector::zero();
let v: ~[int] = v.move_iter().collect();
assert_eq!(~[], v);
let v: Vec<int> = v.move_iter().collect();
assert_eq!(Vec::new(), v);
let v = SmallVector::one(1);
assert_eq!(~[1], v.move_iter().collect());
assert_eq!(vec!(1), v.move_iter().collect());
let v = SmallVector::many(~[1, 2, 3]);
assert_eq!(~[1, 2, 3], v.move_iter().collect());
let v = SmallVector::many(vec!(1, 2, 3));
assert_eq!(vec!(1, 2, 3), v.move_iter().collect());
}
#[test]
@ -190,12 +190,12 @@ mod test {
#[test]
#[should_fail]
fn test_expect_one_many() {
SmallVector::many(~[1, 2]).expect_one("");
SmallVector::many(vec!(1, 2)).expect_one("");
}
#[test]
fn test_expect_one_one() {
assert_eq!(1, SmallVector::one(1).expect_one(""));
assert_eq!(1, SmallVector::many(~[1]).expect_one(""));
assert_eq!(1, SmallVector::many(vec!(1)).expect_one(""));
}
}