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

28 files changed, 556 insertions, 600 deletions

diff --git a/src/libsyntax/ext/asm.rs b/src/libsyntax/ext/asm.rs
index 1bf82573c49..c2d16d83301 100644
--- a/src/libsyntax/ext/asm.rs
+++ b/src/libsyntax/ext/asm.rs
@@ -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 {
diff --git a/src/libsyntax/ext/base.rs b/src/libsyntax/ext/base.rs
index 0636d19163e..85a8be1c876 100644
--- a/src/libsyntax/ext/base.rs
+++ b/src/libsyntax/ext/base.rs
@@ -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
     }
diff --git a/src/libsyntax/ext/build.rs b/src/libsyntax/ext/build.rs
index 1ddd579a2f1..2dc94253a35 100644
--- a/src/libsyntax/ext/build.rs
+++ b/src/libsyntax/ext/build.rs
@@ -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))))
     }
 }
 
diff --git a/src/libsyntax/ext/bytes.rs b/src/libsyntax/ext/bytes.rs
index 68aa757c524..ba6ad4888e2 100644
--- a/src/libsyntax/ext/bytes.rs
+++ b/src/libsyntax/ext/bytes.rs
@@ -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 {
diff --git a/src/libsyntax/ext/cfg.rs b/src/libsyntax/ext/cfg.rs
index 295c456c9d0..e1f487a95bb 100644
--- a/src/libsyntax/ext/cfg.rs
+++ b/src/libsyntax/ext/cfg.rs
@@ -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());
diff --git a/src/libsyntax/ext/concat_idents.rs b/src/libsyntax/ext/concat_idents.rs
index 85cfd4f61e4..25525869398 100644
--- a/src/libsyntax/ext/concat_idents.rs
+++ b/src/libsyntax/ext/concat_idents.rs
@@ -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,
diff --git a/src/libsyntax/ext/deriving/clone.rs b/src/libsyntax/ext/deriving/clone.rs
index f52a2accd8d..3f8fb3ae4f5 100644
--- a/src/libsyntax/ext/deriving/clone.rs
+++ b/src/libsyntax/ext/deriving/clone.rs
@@ -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) => {
diff --git a/src/libsyntax/ext/deriving/cmp/eq.rs b/src/libsyntax/ext/deriving/cmp/eq.rs
index b031f69084d..975b8885de7 100644
--- a/src/libsyntax/ext/deriving/cmp/eq.rs
+++ b/src/libsyntax/ext/deriving/cmp/eq.rs
@@ -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)
 }
diff --git a/src/libsyntax/ext/deriving/cmp/ord.rs b/src/libsyntax/ext/deriving/cmp/ord.rs
index 10a416045cb..5605c0b6107 100644
--- a/src/libsyntax/ext/deriving/cmp/ord.rs
+++ b/src/libsyntax/ext/deriving/cmp/ord.rs
@@ -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)
 }
diff --git a/src/libsyntax/ext/deriving/cmp/totaleq.rs b/src/libsyntax/ext/deriving/cmp/totaleq.rs
index 2bfab8646a6..ffabed95db5 100644
--- a/src/libsyntax/ext/deriving/cmp/totaleq.rs
+++ b/src/libsyntax/ext/deriving/cmp/totaleq.rs
@@ -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)
 }
diff --git a/src/libsyntax/ext/deriving/cmp/totalord.rs b/src/libsyntax/ext/deriving/cmp/totalord.rs
index 2e6c4a54228..13f72f5fc2f 100644
--- a/src/libsyntax/ext/deriving/cmp/totalord.rs
+++ b/src/libsyntax/ext/deriving/cmp/totalord.rs
@@ -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, _| {
diff --git a/src/libsyntax/ext/deriving/decodable.rs b/src/libsyntax/ext/deriving/decodable.rs
index 7aaa66cbfb5..4c9a58c46f7 100644
--- a/src/libsyntax/ext/deriving/decodable.rs
+++ b/src/libsyntax/ext/deriving/decodable.rs
@@ -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)")
     };
diff --git a/src/libsyntax/ext/deriving/default.rs b/src/libsyntax/ext/deriving/default.rs
index c5ef86273b6..46e9dfb89ab 100644
--- a/src/libsyntax/ext/deriving/default.rs
+++ b/src/libsyntax/ext/deriving/default.rs
@@ -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) => {
diff --git a/src/libsyntax/ext/deriving/encodable.rs b/src/libsyntax/ext/deriving/encodable.rs
index ae23013b7cc..2fa6ec6888b 100644
--- a/src/libsyntax/ext/deriving/encodable.rs
+++ b/src/libsyntax/ext/deriving/encodable.rs
@@ -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)")
diff --git a/src/libsyntax/ext/deriving/generic.rs b/src/libsyntax/ext/deriving/generic.rs
index 24d4efb1b0e..6869ff2fd0d 100644
--- a/src/libsyntax/ext/deriving/generic.rs
+++ b/src/libsyntax/ext/deriving/generic.rs
@@ -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,
diff --git a/src/libsyntax/ext/deriving/hash.rs b/src/libsyntax/ext/deriving/hash.rs
index acae4f9efa6..ed7f61d5e94 100644
--- a/src/libsyntax/ext/deriving/hash.rs
+++ b/src/libsyntax/ext/deriving/hash.rs
@@ -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,
diff --git a/src/libsyntax/ext/deriving/primitive.rs b/src/libsyntax/ext/deriving/primitive.rs
index 03192cc1cd2..2615479fa72 100644
--- a/src/libsyntax/ext/deriving/primitive.rs
+++ b/src/libsyntax/ext/deriving/primitive.rs
@@ -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)),
             };
diff --git a/src/libsyntax/ext/deriving/rand.rs b/src/libsyntax/ext/deriving/rand.rs
index 6efe4801592..203e5aae567 100644
--- a/src/libsyntax/ext/deriving/rand.rs
+++ b/src/libsyntax/ext/deriving/rand.rs
@@ -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)`")
diff --git a/src/libsyntax/ext/deriving/show.rs b/src/libsyntax/ext/deriving/show.rs
index 4b9925c8d9f..0622588be8e 100644
--- a/src/libsyntax/ext/deriving/show.rs
+++ b/src/libsyntax/ext/deriving/show.rs
@@ -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);
diff --git a/src/libsyntax/ext/deriving/ty.rs b/src/libsyntax/ext/deriving/ty.rs
index 1d3dd9185ca..f7019d65058 100644
--- a/src/libsyntax/ext/deriving/ty.rs
+++ b/src/libsyntax/ext/deriving/ty.rs
@@ -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,
diff --git a/src/libsyntax/ext/deriving/zero.rs b/src/libsyntax/ext/deriving/zero.rs
index 90f4fa0eb58..9feae186894 100644
--- a/src/libsyntax/ext/deriving/zero.rs
+++ b/src/libsyntax/ext/deriving/zero.rs
@@ -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) => {
diff --git a/src/libsyntax/ext/expand.rs b/src/libsyntax/ext/expand.rs
index b49f9fb3a38..08d40745894 100644
--- a/src/libsyntax/ext/expand.rs
+++ b/src/libsyntax/ext/expand.rs
@@ -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")));
     }
 
 }
diff --git a/src/libsyntax/ext/format.rs b/src/libsyntax/ext/format.rs
index 2642ee00458..4b27951aa50 100644
--- a/src/libsyntax/ext/format.rs
+++ b/src/libsyntax/ext/format.rs
@@ -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;
diff --git a/src/libsyntax/ext/quote.rs b/src/libsyntax/ext/quote.rs
index 35a5cbd235a..3b8df84acc3 100644
--- a/src/libsyntax/ext/quote.rs
+++ b/src/libsyntax/ext/quote.rs
@@ -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);
diff --git a/src/libsyntax/ext/registrar.rs b/src/libsyntax/ext/registrar.rs
index f0bad1b40eb..15e753ee49f 100644
--- a/src/libsyntax/ext/registrar.rs
+++ b/src/libsyntax/ext/registrar.rs
@@ -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() {
diff --git a/src/libsyntax/ext/tt/macro_parser.rs b/src/libsyntax/ext/tt/macro_parser.rs
index edd875a57a7..cb86f2cecaa 100644
--- a/src/libsyntax/ext/tt/macro_parser.rs
+++ b/src/libsyntax/ext/tt/macro_parser.rs
@@ -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*/)),
diff --git a/src/libsyntax/ext/tt/macro_rules.rs b/src/libsyntax/ext/tt/macro_rules.rs
index 45fe24ebf68..ed127c43117 100644
--- a/src/libsyntax/ext/tt/macro_rules.rs
+++ b/src/libsyntax/ext/tt/macro_rules.rs
@@ -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):
diff --git a/src/libsyntax/ext/tt/transcribe.rs b/src/libsyntax/ext/tt/transcribe.rs
index a8c9fe37226..690ae82741c 100644
--- a/src/libsyntax/ext/tt/transcribe.rs
+++ b/src/libsyntax/ext/tt/transcribe.rs
@@ -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),