diff --git a/mk/crates.mk b/mk/crates.mk
index c7abf271e5127..25192bfd27a44 100644
--- a/mk/crates.mk
+++ b/mk/crates.mk
@@ -121,7 +121,7 @@ DEPS_rustc_driver := arena flate getopts graphviz libc rustc rustc_back rustc_bo
                      rustc_trans rustc_privacy rustc_lint rustc_plugin \
                      rustc_metadata syntax_ext proc_macro_plugin \
                      rustc_passes rustc_save_analysis rustc_const_eval \
-                     rustc_incremental syntax_pos rustc_errors proc_macro
+                     rustc_incremental syntax_pos rustc_errors proc_macro rustc_data_structures
 DEPS_rustc_errors := log libc serialize syntax_pos
 DEPS_rustc_lint := rustc log syntax syntax_pos rustc_const_eval
 DEPS_rustc_llvm := native:rustllvm libc std rustc_bitflags
diff --git a/src/Cargo.lock b/src/Cargo.lock
index 64c8ec101916b..5826995cc3cfc 100644
--- a/src/Cargo.lock
+++ b/src/Cargo.lock
@@ -383,6 +383,7 @@ dependencies = [
  "rustc_back 0.0.0",
  "rustc_borrowck 0.0.0",
  "rustc_const_eval 0.0.0",
+ "rustc_data_structures 0.0.0",
  "rustc_errors 0.0.0",
  "rustc_incremental 0.0.0",
  "rustc_lint 0.0.0",
diff --git a/src/libcollections/slice.rs b/src/libcollections/slice.rs
index 245579afbbadf..75796cf94bfc2 100644
--- a/src/libcollections/slice.rs
+++ b/src/libcollections/slice.rs
@@ -1170,7 +1170,7 @@ impl<T> [T] {
     /// let x = s.into_vec();
     /// // `s` cannot be used anymore because it has been converted into `x`.
     ///
-    /// assert_eq!(x, vec!(10, 40, 30));
+    /// assert_eq!(x, vec![10, 40, 30]);
     /// ```
     #[stable(feature = "rust1", since = "1.0.0")]
     #[inline]
diff --git a/src/libcollections/vec.rs b/src/libcollections/vec.rs
index 7fdf7e903d5ca..d94a27917e869 100644
--- a/src/libcollections/vec.rs
+++ b/src/libcollections/vec.rs
@@ -148,7 +148,7 @@ use super::range::RangeArgument;
 /// [`Index`] trait. An example will be more explicit:
 ///
 /// ```
-/// let v = vec!(0, 2, 4, 6);
+/// let v = vec![0, 2, 4, 6];
 /// println!("{}", v[1]); // it will display '2'
 /// ```
 ///
@@ -156,7 +156,7 @@ use super::range::RangeArgument;
 /// your software will panic! You cannot do this:
 ///
 /// ```ignore
-/// let v = vec!(0, 2, 4, 6);
+/// let v = vec![0, 2, 4, 6];
 /// println!("{}", v[6]); // it will panic!
 /// ```
 ///
@@ -173,7 +173,7 @@ use super::range::RangeArgument;
 ///     // ...
 /// }
 ///
-/// let v = vec!(0, 1);
+/// let v = vec![0, 1];
 /// read_slice(&v);
 ///
 /// // ... and that's all!
diff --git a/src/libcore/option.rs b/src/libcore/option.rs
index cb18feff73422..a74979911d34d 100644
--- a/src/libcore/option.rs
+++ b/src/libcore/option.rs
@@ -914,12 +914,12 @@ impl<A, V: FromIterator<A>> FromIterator<Option<A>> for Option<V> {
     /// ```
     /// use std::u16;
     ///
-    /// let v = vec!(1, 2);
+    /// let v = vec![1, 2];
     /// let res: Option<Vec<u16>> = v.iter().map(|&x: &u16|
     ///     if x == u16::MAX { None }
     ///     else { Some(x + 1) }
     /// ).collect();
-    /// assert!(res == Some(vec!(2, 3)));
+    /// assert!(res == Some(vec![2, 3]));
     /// ```
     #[inline]
     fn from_iter<I: IntoIterator<Item=Option<A>>>(iter: I) -> Option<V> {
diff --git a/src/libcore/result.rs b/src/libcore/result.rs
index 78230b608044b..9cb42124e00bf 100644
--- a/src/libcore/result.rs
+++ b/src/libcore/result.rs
@@ -977,12 +977,12 @@ impl<A, E, V: FromIterator<A>> FromIterator<Result<A, E>> for Result<V, E> {
     /// ```
     /// use std::u32;
     ///
-    /// let v = vec!(1, 2);
+    /// let v = vec![1, 2];
     /// let res: Result<Vec<u32>, &'static str> = v.iter().map(|&x: &u32|
     ///     if x == u32::MAX { Err("Overflow!") }
     ///     else { Ok(x + 1) }
     /// ).collect();
-    /// assert!(res == Ok(vec!(2, 3)));
+    /// assert!(res == Ok(vec![2, 3]));
     /// ```
     #[inline]
     fn from_iter<I: IntoIterator<Item=Result<A, E>>>(iter: I) -> Result<V, E> {
diff --git a/src/libgetopts/lib.rs b/src/libgetopts/lib.rs
index 42200795bb3a5..4d2f1b999a2ae 100644
--- a/src/libgetopts/lib.rs
+++ b/src/libgetopts/lib.rs
@@ -1610,8 +1610,8 @@ Options:
 
     #[test]
     fn test_args_with_equals() {
-        let args = vec!("--one".to_string(), "A=B".to_string(),
-                        "--two=C=D".to_string());
+        let args = vec!["--one".to_string(), "A=B".to_string(),
+                        "--two=C=D".to_string()];
         let opts = vec![optopt("o", "one", "One", "INFO"),
                         optopt("t", "two", "Two", "INFO")];
         let matches = &match getopts(&args, &opts) {
diff --git a/src/libgraphviz/lib.rs b/src/libgraphviz/lib.rs
index 95c46ec5715e7..03057af4a843b 100644
--- a/src/libgraphviz/lib.rs
+++ b/src/libgraphviz/lib.rs
@@ -58,7 +58,7 @@
 //! struct Edges(Vec<Ed>);
 //!
 //! pub fn render_to<W: Write>(output: &mut W) {
-//!     let edges = Edges(vec!((0,1), (0,2), (1,3), (2,3), (3,4), (4,4)));
+//!     let edges = Edges(vec![(0,1), (0,2), (1,3), (2,3), (3,4), (4,4)]);
 //!     dot::render(&edges, output).unwrap()
 //! }
 //!
@@ -164,8 +164,8 @@
 //! struct Graph { nodes: Vec<&'static str>, edges: Vec<(usize,usize)> }
 //!
 //! pub fn render_to<W: Write>(output: &mut W) {
-//!     let nodes = vec!("{x,y}","{x}","{y}","{}");
-//!     let edges = vec!((0,1), (0,2), (1,3), (2,3));
+//!     let nodes = vec!["{x,y}","{x}","{y}","{}"];
+//!     let edges = vec![(0,1), (0,2), (1,3), (2,3)];
 //!     let graph = Graph { nodes: nodes, edges: edges };
 //!
 //!     dot::render(&graph, output).unwrap()
@@ -226,8 +226,8 @@
 //! struct Graph { nodes: Vec<&'static str>, edges: Vec<(usize,usize)> }
 //!
 //! pub fn render_to<W: Write>(output: &mut W) {
-//!     let nodes = vec!("{x,y}","{x}","{y}","{}");
-//!     let edges = vec!((0,1), (0,2), (1,3), (2,3));
+//!     let nodes = vec!["{x,y}","{x}","{y}","{}"];
+//!     let edges = vec![(0,1), (0,2), (1,3), (2,3)];
 //!     let graph = Graph { nodes: nodes, edges: edges };
 //!
 //!     dot::render(&graph, output).unwrap()
diff --git a/src/librand/chacha.rs b/src/librand/chacha.rs
index 8ca1738bb18f4..7dc0d19e6a615 100644
--- a/src/librand/chacha.rs
+++ b/src/librand/chacha.rs
@@ -253,17 +253,17 @@ mod tests {
 
         let v = (0..16).map(|_| ra.next_u32()).collect::<Vec<_>>();
         assert_eq!(v,
-                   vec!(0xade0b876, 0x903df1a0, 0xe56a5d40, 0x28bd8653,
+                   vec![0xade0b876, 0x903df1a0, 0xe56a5d40, 0x28bd8653,
                         0xb819d2bd, 0x1aed8da0, 0xccef36a8, 0xc70d778b,
                         0x7c5941da, 0x8d485751, 0x3fe02477, 0x374ad8b8,
-                        0xf4b8436a, 0x1ca11815, 0x69b687c3, 0x8665eeb2));
+                        0xf4b8436a, 0x1ca11815, 0x69b687c3, 0x8665eeb2]);
 
         let v = (0..16).map(|_| ra.next_u32()).collect::<Vec<_>>();
         assert_eq!(v,
-                   vec!(0xbee7079f, 0x7a385155, 0x7c97ba98, 0x0d082d73,
+                   vec![0xbee7079f, 0x7a385155, 0x7c97ba98, 0x0d082d73,
                         0xa0290fcb, 0x6965e348, 0x3e53c612, 0xed7aee32,
                         0x7621b729, 0x434ee69c, 0xb03371d5, 0xd539d874,
-                        0x281fed31, 0x45fb0a51, 0x1f0ae1ac, 0x6f4d794b));
+                        0x281fed31, 0x45fb0a51, 0x1f0ae1ac, 0x6f4d794b]);
 
 
         let seed: &[_] = &[0, 1, 2, 3, 4, 5, 6, 7];
@@ -280,10 +280,10 @@ mod tests {
         }
 
         assert_eq!(v,
-                   vec!(0xf225c81a, 0x6ab1be57, 0x04d42951, 0x70858036,
+                   vec![0xf225c81a, 0x6ab1be57, 0x04d42951, 0x70858036,
                         0x49884684, 0x64efec72, 0x4be2d186, 0x3615b384,
                         0x11cfa18e, 0xd3c50049, 0x75c775f6, 0x434c6530,
-                        0x2c5bad8f, 0x898881dc, 0x5f1c86d9, 0xc1f8e7f4));
+                        0x2c5bad8f, 0x898881dc, 0x5f1c86d9, 0xc1f8e7f4]);
     }
 
     #[test]
diff --git a/src/librand/distributions/mod.rs b/src/librand/distributions/mod.rs
index c5588d94876c0..41175c81df891 100644
--- a/src/librand/distributions/mod.rs
+++ b/src/librand/distributions/mod.rs
@@ -312,37 +312,37 @@ mod tests {
             }}
         }
 
-        t!(vec!(Weighted { weight: 1, item: 10 }),
+        t!(vec![Weighted { weight: 1, item: 10 }],
            [10]);
 
         // skip some
-        t!(vec!(Weighted { weight: 0, item: 20 },
+        t!(vec![Weighted { weight: 0, item: 20 },
                 Weighted { weight: 2, item: 21 },
                 Weighted { weight: 0, item: 22 },
-                Weighted { weight: 1, item: 23 }),
+                Weighted { weight: 1, item: 23 }],
            [21, 21, 23]);
 
         // different weights
-        t!(vec!(Weighted { weight: 4, item: 30 },
-                Weighted { weight: 3, item: 31 }),
+        t!(vec![Weighted { weight: 4, item: 30 },
+                Weighted { weight: 3, item: 31 }],
            [30, 30, 30, 30, 31, 31, 31]);
 
         // check that we're binary searching
         // correctly with some vectors of odd
         // length.
-        t!(vec!(Weighted { weight: 1, item: 40 },
+        t!(vec![Weighted { weight: 1, item: 40 },
                 Weighted { weight: 1, item: 41 },
                 Weighted { weight: 1, item: 42 },
                 Weighted { weight: 1, item: 43 },
-                Weighted { weight: 1, item: 44 }),
+                Weighted { weight: 1, item: 44 }],
            [40, 41, 42, 43, 44]);
-        t!(vec!(Weighted { weight: 1, item: 50 },
+        t!(vec![Weighted { weight: 1, item: 50 },
                 Weighted { weight: 1, item: 51 },
                 Weighted { weight: 1, item: 52 },
                 Weighted { weight: 1, item: 53 },
                 Weighted { weight: 1, item: 54 },
                 Weighted { weight: 1, item: 55 },
-                Weighted { weight: 1, item: 56 }),
+                Weighted { weight: 1, item: 56 }],
            [50, 51, 52, 53, 54, 55, 56]);
     }
 
diff --git a/src/librand/isaac.rs b/src/librand/isaac.rs
index 974f65ac2c5b5..69d5015f18140 100644
--- a/src/librand/isaac.rs
+++ b/src/librand/isaac.rs
@@ -662,8 +662,8 @@ mod tests {
         // Regression test that isaac is actually using the above vector
         let v = (0..10).map(|_| ra.next_u32()).collect::<Vec<_>>();
         assert_eq!(v,
-                   vec!(2558573138, 873787463, 263499565, 2103644246, 3595684709,
-                        4203127393, 264982119, 2765226902, 2737944514, 3900253796));
+                   vec![2558573138, 873787463, 263499565, 2103644246, 3595684709,
+                        4203127393, 264982119, 2765226902, 2737944514, 3900253796]);
 
         let seed: &[_] = &[12345, 67890, 54321, 9876];
         let mut rb: IsaacRng = SeedableRng::from_seed(seed);
@@ -674,8 +674,8 @@ mod tests {
 
         let v = (0..10).map(|_| rb.next_u32()).collect::<Vec<_>>();
         assert_eq!(v,
-                   vec!(3676831399, 3183332890, 2834741178, 3854698763, 2717568474,
-                        1576568959, 3507990155, 179069555, 141456972, 2478885421));
+                   vec![3676831399, 3183332890, 2834741178, 3854698763, 2717568474,
+                        1576568959, 3507990155, 179069555, 141456972, 2478885421]);
     }
     #[test]
     #[rustfmt_skip]
@@ -685,10 +685,10 @@ mod tests {
         // Regression test that isaac is actually using the above vector
         let v = (0..10).map(|_| ra.next_u64()).collect::<Vec<_>>();
         assert_eq!(v,
-                   vec!(547121783600835980, 14377643087320773276, 17351601304698403469,
+                   vec![547121783600835980, 14377643087320773276, 17351601304698403469,
                         1238879483818134882, 11952566807690396487, 13970131091560099343,
                         4469761996653280935, 15552757044682284409, 6860251611068737823,
-                        13722198873481261842));
+                        13722198873481261842]);
 
         let seed: &[_] = &[12345, 67890, 54321, 9876];
         let mut rb: Isaac64Rng = SeedableRng::from_seed(seed);
@@ -699,10 +699,10 @@ mod tests {
 
         let v = (0..10).map(|_| rb.next_u64()).collect::<Vec<_>>();
         assert_eq!(v,
-                   vec!(18143823860592706164, 8491801882678285927, 2699425367717515619,
+                   vec![18143823860592706164, 8491801882678285927, 2699425367717515619,
                         17196852593171130876, 2606123525235546165, 15790932315217671084,
                         596345674630742204, 9947027391921273664, 11788097613744130851,
-                        10391409374914919106));
+                        10391409374914919106]);
 
     }
 
diff --git a/src/librustc/cfg/construct.rs b/src/librustc/cfg/construct.rs
index 50d4cbc982e97..1b2976b7435d8 100644
--- a/src/librustc/cfg/construct.rs
+++ b/src/librustc/cfg/construct.rs
@@ -536,7 +536,7 @@ impl<'a, 'tcx> CFGBuilder<'a, 'tcx> {
     fn add_contained_edge(&mut self,
                           source: CFGIndex,
                           target: CFGIndex) {
-        let data = CFGEdgeData {exiting_scopes: vec!() };
+        let data = CFGEdgeData {exiting_scopes: vec![] };
         self.graph.add_edge(source, target, data);
     }
 
@@ -545,7 +545,7 @@ impl<'a, 'tcx> CFGBuilder<'a, 'tcx> {
                         from_index: CFGIndex,
                         to_loop: LoopScope,
                         to_index: CFGIndex) {
-        let mut data = CFGEdgeData {exiting_scopes: vec!() };
+        let mut data = CFGEdgeData {exiting_scopes: vec![] };
         let mut scope = self.tcx.region_maps.node_extent(from_expr.id);
         let target_scope = self.tcx.region_maps.node_extent(to_loop.loop_id);
         while scope != target_scope {
@@ -559,7 +559,7 @@ impl<'a, 'tcx> CFGBuilder<'a, 'tcx> {
                           _from_expr: &hir::Expr,
                           from_index: CFGIndex) {
         let mut data = CFGEdgeData {
-            exiting_scopes: vec!(),
+            exiting_scopes: vec![],
         };
         for &LoopScope { loop_id: id, .. } in self.loop_scopes.iter().rev() {
             data.exiting_scopes.push(id);
diff --git a/src/librustc/hir/lowering.rs b/src/librustc/hir/lowering.rs
index a489567fbb2a8..620ee30c95628 100644
--- a/src/librustc/hir/lowering.rs
+++ b/src/librustc/hir/lowering.rs
@@ -1218,7 +1218,7 @@ impl<'a> LoweringContext<'a> {
                         alignstack,
                         dialect,
                         expn_id,
-                    }) => hir::ExprInlineAsm(hir::InlineAsm {
+                    }) => hir::ExprInlineAsm(P(hir::InlineAsm {
                     inputs: inputs.iter().map(|&(ref c, _)| c.clone()).collect(),
                     outputs: outputs.iter()
                                     .map(|out| {
@@ -1236,7 +1236,7 @@ impl<'a> LoweringContext<'a> {
                     alignstack: alignstack,
                     dialect: dialect,
                     expn_id: expn_id,
-                }, outputs.iter().map(|out| self.lower_expr(&out.expr)).collect(),
+                }), outputs.iter().map(|out| self.lower_expr(&out.expr)).collect(),
                    inputs.iter().map(|&(_, ref input)| self.lower_expr(input)).collect()),
                 ExprKind::Struct(ref path, ref fields, ref maybe_expr) => {
                     hir::ExprStruct(self.lower_path(path),
diff --git a/src/librustc/hir/mod.rs b/src/librustc/hir/mod.rs
index ed83e228a23c1..c451a789193aa 100644
--- a/src/librustc/hir/mod.rs
+++ b/src/librustc/hir/mod.rs
@@ -940,7 +940,7 @@ pub enum Expr_ {
     ExprRet(Option<P<Expr>>),
 
     /// Inline assembly (from `asm!`), with its outputs and inputs.
-    ExprInlineAsm(InlineAsm, Vec<P<Expr>>, Vec<P<Expr>>),
+    ExprInlineAsm(P<InlineAsm>, HirVec<P<Expr>>, HirVec<P<Expr>>),
 
     /// A struct or struct-like variant literal expression.
     ///
diff --git a/src/librustc/infer/error_reporting.rs b/src/librustc/infer/error_reporting.rs
index be6594320244d..5e3925b0b3c98 100644
--- a/src/librustc/infer/error_reporting.rs
+++ b/src/librustc/infer/error_reporting.rs
@@ -457,7 +457,7 @@ impl<'a, 'gcx, 'tcx> InferCtxt<'a, 'gcx, 'tcx> {
             }
             same_regions.push(SameRegions {
                 scope_id: scope_id,
-                regions: vec!(sub_fr.bound_region, sup_fr.bound_region)
+                regions: vec![sub_fr.bound_region, sup_fr.bound_region]
             })
         }
     }
@@ -1359,7 +1359,7 @@ impl<'a, 'gcx, 'tcx> Rebuilder<'a, 'gcx, 'tcx> {
                                 region_names: &HashSet<ast::Name>)
                                 -> P<hir::Ty> {
         let mut new_ty = P(ty.clone());
-        let mut ty_queue = vec!(ty);
+        let mut ty_queue = vec![ty];
         while !ty_queue.is_empty() {
             let cur_ty = ty_queue.remove(0);
             match cur_ty.node {
diff --git a/src/librustc/lib.rs b/src/librustc/lib.rs
index 5f2ba9e68d74d..d17402d21342b 100644
--- a/src/librustc/lib.rs
+++ b/src/librustc/lib.rs
@@ -111,8 +111,6 @@ pub mod traits;
 pub mod ty;
 
 pub mod util {
-    pub use rustc_back::sha2;
-
     pub mod common;
     pub mod ppaux;
     pub mod nodemap;
diff --git a/src/librustc/lint/context.rs b/src/librustc/lint/context.rs
index 81d3d440b566f..afdcddb83fc33 100644
--- a/src/librustc/lint/context.rs
+++ b/src/librustc/lint/context.rs
@@ -127,9 +127,9 @@ impl LintStore {
 
     pub fn new() -> LintStore {
         LintStore {
-            lints: vec!(),
-            early_passes: Some(vec!()),
-            late_passes: Some(vec!()),
+            lints: vec![],
+            early_passes: Some(vec![]),
+            late_passes: Some(vec![]),
             by_name: FnvHashMap(),
             levels: FnvHashMap(),
             future_incompatible: FnvHashMap(),
@@ -345,7 +345,7 @@ macro_rules! run_lints { ($cx:expr, $f:ident, $ps:ident, $($args:expr),*) => ({
 // See also the hir version just below.
 pub fn gather_attrs(attrs: &[ast::Attribute])
                     -> Vec<Result<(InternedString, Level, Span), Span>> {
-    let mut out = vec!();
+    let mut out = vec![];
     for attr in attrs {
         let r = gather_attr(attr);
         out.extend(r.into_iter());
@@ -355,7 +355,7 @@ pub fn gather_attrs(attrs: &[ast::Attribute])
 
 pub fn gather_attr(attr: &ast::Attribute)
                    -> Vec<Result<(InternedString, Level, Span), Span>> {
-    let mut out = vec!();
+    let mut out = vec![];
 
     let level = match Level::from_str(&attr.name()) {
         None => return out,
diff --git a/src/librustc/middle/lang_items.rs b/src/librustc/middle/lang_items.rs
index 078cce9c49ff4..3175230ab6a5e 100644
--- a/src/librustc/middle/lang_items.rs
+++ b/src/librustc/middle/lang_items.rs
@@ -59,7 +59,7 @@ impl LanguageItems {
         fn foo(_: LangItem) -> Option<DefId> { None }
 
         LanguageItems {
-            items: vec!($(foo($variant)),*),
+            items: vec![$(foo($variant)),*],
             missing: Vec::new(),
         }
     }
diff --git a/src/librustc/mir/mod.rs b/src/librustc/mir/mod.rs
index 994316d05ec78..9d82006ac9f9d 100644
--- a/src/librustc/mir/mod.rs
+++ b/src/librustc/mir/mod.rs
@@ -63,7 +63,8 @@ macro_rules! newtype_index {
 }
 
 /// Lowered representation of a single function.
-#[derive(Clone, RustcEncodable, RustcDecodable, Debug)]
+// Do not implement clone for Mir, its easy to do so accidently and its kind of expensive.
+#[derive(RustcEncodable, RustcDecodable, Debug)]
 pub struct Mir<'tcx> {
     /// List of basic blocks. References to basic block use a newtyped index type `BasicBlock`
     /// that indexes into this vector.
@@ -1142,8 +1143,7 @@ impl<'tcx> Debug for Rvalue<'tcx> {
                     AggregateKind::Adt(adt_def, variant, substs, _) => {
                         let variant_def = &adt_def.variants[variant];
 
-                        ppaux::parameterized(fmt, substs, variant_def.did,
-                                             ppaux::Ns::Value, &[])?;
+                        ppaux::parameterized(fmt, substs, variant_def.did, &[])?;
 
                         match variant_def.ctor_kind {
                             CtorKind::Const => Ok(()),
@@ -1238,7 +1238,7 @@ impl<'tcx> Debug for Literal<'tcx> {
         use self::Literal::*;
         match *self {
             Item { def_id, substs } => {
-                ppaux::parameterized(fmt, substs, def_id, ppaux::Ns::Value, &[])
+                ppaux::parameterized(fmt, substs, def_id, &[])
             }
             Value { ref value } => {
                 write!(fmt, "const ")?;
diff --git a/src/librustc/session/config.rs b/src/librustc/session/config.rs
index 7b5413984a205..87a5c6410a841 100644
--- a/src/librustc/session/config.rs
+++ b/src/librustc/session/config.rs
@@ -715,7 +715,7 @@ macro_rules! options {
                     true
                 }
                 v => {
-                    let mut passes = vec!();
+                    let mut passes = vec![];
                     if parse_list(&mut passes, v) {
                         *slot = SomePasses(passes);
                         true
@@ -1293,7 +1293,7 @@ pub fn build_session_options_and_crate_config(matches: &getopts::Matches)
     let crate_types = parse_crate_types_from_list(unparsed_crate_types)
         .unwrap_or_else(|e| early_error(error_format, &e[..]));
 
-    let mut lint_opts = vec!();
+    let mut lint_opts = vec![];
     let mut describe_lints = false;
 
     for &level in &[lint::Allow, lint::Warn, lint::Deny, lint::Forbid] {
diff --git a/src/librustc/session/mod.rs b/src/librustc/session/mod.rs
index d002aba595bca..6543ad137eb06 100644
--- a/src/librustc/session/mod.rs
+++ b/src/librustc/session/mod.rs
@@ -268,7 +268,7 @@ impl Session {
             }
             return;
         }
-        lints.insert(id, vec!((lint_id, sp, msg)));
+        lints.insert(id, vec![(lint_id, sp, msg)]);
     }
     pub fn reserve_node_ids(&self, count: usize) -> ast::NodeId {
         let id = self.next_node_id.get();
diff --git a/src/librustc/traits/project.rs b/src/librustc/traits/project.rs
index f1f1658cc824d..ce882c48377f7 100644
--- a/src/librustc/traits/project.rs
+++ b/src/librustc/traits/project.rs
@@ -275,7 +275,7 @@ impl<'a, 'b, 'gcx, 'tcx> AssociatedTypeNormalizer<'a, 'b, 'gcx, 'tcx> {
         AssociatedTypeNormalizer {
             selcx: selcx,
             cause: cause,
-            obligations: vec!(),
+            obligations: vec![],
             depth: depth,
         }
     }
@@ -396,7 +396,7 @@ pub fn normalize_projection_type<'a, 'b, 'gcx, 'tcx>(
                 cause, depth + 1, projection.to_predicate());
             Normalized {
                 value: ty_var,
-                obligations: vec!(obligation)
+                obligations: vec![obligation]
             }
         })
 }
@@ -545,7 +545,7 @@ fn opt_normalize_projection_type<'a, 'b, 'gcx, 'tcx>(
                    projected_ty);
             let result = Normalized {
                 value: projected_ty,
-                obligations: vec!()
+                obligations: vec![]
             };
             infcx.projection_cache.borrow_mut()
                                   .complete(projection_ty, &result, true);
@@ -604,7 +604,7 @@ fn normalize_to_error<'a, 'gcx, 'tcx>(selcx: &mut SelectionContext<'a, 'gcx, 'tc
     let new_value = selcx.infcx().next_ty_var();
     Normalized {
         value: new_value,
-        obligations: vec!(trait_obligation)
+        obligations: vec![trait_obligation]
     }
 }
 
diff --git a/src/librustc/ty/util.rs b/src/librustc/ty/util.rs
index bb36fa1487eee..cca4069ba5a17 100644
--- a/src/librustc/ty/util.rs
+++ b/src/librustc/ty/util.rs
@@ -405,6 +405,7 @@ impl<'a, 'gcx, 'tcx> TyCtxt<'a, 'gcx, 'tcx> {
 ///
 /// The same goes for endianess: We always convert multi-byte integers to little
 /// endian before hashing.
+#[derive(Debug)]
 pub struct ArchIndependentHasher<H> {
     inner: H,
 }
@@ -413,6 +414,10 @@ impl<H> ArchIndependentHasher<H> {
     pub fn new(inner: H) -> ArchIndependentHasher<H> {
         ArchIndependentHasher { inner: inner }
     }
+
+    pub fn into_inner(self) -> H {
+        self.inner
+    }
 }
 
 impl<H: Hasher> Hasher for ArchIndependentHasher<H> {
diff --git a/src/librustc/ty/walk.rs b/src/librustc/ty/walk.rs
index dd3a62f7cd2dd..bebdebf127a54 100644
--- a/src/librustc/ty/walk.rs
+++ b/src/librustc/ty/walk.rs
@@ -22,7 +22,7 @@ pub struct TypeWalker<'tcx> {
 
 impl<'tcx> TypeWalker<'tcx> {
     pub fn new(ty: Ty<'tcx>) -> TypeWalker<'tcx> {
-        TypeWalker { stack: vec!(ty), last_subtree: 1, }
+        TypeWalker { stack: vec![ty], last_subtree: 1, }
     }
 
     /// Skips the subtree of types corresponding to the last type
diff --git a/src/librustc/ty/wf.rs b/src/librustc/ty/wf.rs
index 0557660e98c2f..1135199d2254a 100644
--- a/src/librustc/ty/wf.rs
+++ b/src/librustc/ty/wf.rs
@@ -201,11 +201,11 @@ fn implied_bounds_from_components<'tcx>(sub_region: &'tcx ty::Region,
         .flat_map(|component| {
             match component {
                 Component::Region(r) =>
-                    vec!(ImpliedBound::RegionSubRegion(sub_region, r)),
+                    vec![ImpliedBound::RegionSubRegion(sub_region, r)],
                 Component::Param(p) =>
-                    vec!(ImpliedBound::RegionSubParam(sub_region, p)),
+                    vec![ImpliedBound::RegionSubParam(sub_region, p)],
                 Component::Projection(p) =>
-                    vec!(ImpliedBound::RegionSubProjection(sub_region, p)),
+                    vec![ImpliedBound::RegionSubProjection(sub_region, p)],
                 Component::EscapingProjection(_) =>
                     // If the projection has escaping regions, don't
                     // try to infer any implied bounds even for its
@@ -215,9 +215,9 @@ fn implied_bounds_from_components<'tcx>(sub_region: &'tcx ty::Region,
                     // idea is that the WAY that the caller proves
                     // that may change in the future and we want to
                     // give ourselves room to get smarter here.
-                    vec!(),
+                    vec![],
                 Component::UnresolvedInferenceVariable(..) =>
-                    vec!(),
+                    vec![],
             }
         })
         .collect()
diff --git a/src/librustc/util/ppaux.rs b/src/librustc/util/ppaux.rs
index 13202a454fe55..5ca567410291a 100644
--- a/src/librustc/util/ppaux.rs
+++ b/src/librustc/util/ppaux.rs
@@ -9,6 +9,7 @@
 // except according to those terms.
 
 use hir::def_id::DefId;
+use hir::map::definitions::DefPathData;
 use ty::subst::{self, Subst};
 use ty::{BrAnon, BrEnv, BrFresh, BrNamed};
 use ty::{TyBool, TyChar, TyAdt};
@@ -56,17 +57,9 @@ fn fn_sig(f: &mut fmt::Formatter,
     Ok(())
 }
 
-/// Namespace of the path given to parameterized to print.
-#[derive(Copy, Clone, PartialEq, Debug)]
-pub enum Ns {
-    Type,
-    Value
-}
-
 pub fn parameterized(f: &mut fmt::Formatter,
                      substs: &subst::Substs,
                      did: DefId,
-                     ns: Ns,
                      projections: &[ty::ProjectionPredicate])
                      -> fmt::Result {
     let mut verbose = false;
@@ -75,8 +68,34 @@ pub fn parameterized(f: &mut fmt::Formatter,
     let mut num_regions = 0;
     let mut num_types = 0;
     let mut item_name = None;
+    let mut is_value_path = false;
     let fn_trait_kind = ty::tls::with(|tcx| {
-        let mut generics = tcx.lookup_generics(did);
+        // Unfortunately, some kinds of items (e.g., closures) don't have
+        // generics. So walk back up the find the closest parent that DOES
+        // have them.
+        let mut item_def_id = did;
+        loop {
+            let key = tcx.def_key(item_def_id);
+            match key.disambiguated_data.data {
+                DefPathData::TypeNs(_) => {
+                    break;
+                }
+                DefPathData::ValueNs(_) | DefPathData::EnumVariant(_) => {
+                    is_value_path = true;
+                    break;
+                }
+                _ => {
+                    // if we're making a symbol for something, there ought
+                    // to be a value or type-def or something in there
+                    // *somewhere*
+                    item_def_id.index = key.parent.unwrap_or_else(|| {
+                        bug!("finding type for {:?}, encountered def-id {:?} with no \
+                             parent", did, item_def_id);
+                    });
+                }
+            }
+        }
+        let mut generics = tcx.lookup_generics(item_def_id);
         let mut path_def_id = did;
         verbose = tcx.sess.verbose();
         has_self = generics.has_self;
@@ -84,7 +103,7 @@ pub fn parameterized(f: &mut fmt::Formatter,
         let mut child_types = 0;
         if let Some(def_id) = generics.parent {
             // Methods.
-            assert_eq!(ns, Ns::Value);
+            assert!(is_value_path);
             child_types = generics.types.len();
             generics = tcx.lookup_generics(def_id);
             num_regions = generics.regions.len();
@@ -97,7 +116,7 @@ pub fn parameterized(f: &mut fmt::Formatter,
             item_name = Some(tcx.item_name(did));
             path_def_id = def_id;
         } else {
-            if ns == Ns::Value {
+            if is_value_path {
                 // Functions.
                 assert_eq!(has_self, false);
             } else {
@@ -192,7 +211,7 @@ pub fn parameterized(f: &mut fmt::Formatter,
     start_or_continue(f, "", ">")?;
 
     // For values, also print their name and type parameters.
-    if ns == Ns::Value {
+    if is_value_path {
         empty.set(true);
 
         if has_self {
@@ -298,7 +317,6 @@ impl<'tcx> fmt::Display for TraitAndProjections<'tcx> {
         let TraitAndProjections(ref trait_ref, ref projection_bounds) = *self;
         parameterized(f, trait_ref.substs,
                       trait_ref.def_id,
-                      Ns::Type,
                       projection_bounds)
     }
 }
@@ -398,7 +416,7 @@ impl<'tcx> fmt::Debug for ty::ExistentialTraitRef<'tcx> {
             let trait_ref = tcx.lift(&ty::Binder(*self))
                                .expect("could not lift TraitRef for printing")
                                .with_self_ty(tcx, dummy_self).0;
-            parameterized(f, trait_ref.substs, trait_ref.def_id, Ns::Type, &[])
+            parameterized(f, trait_ref.substs, trait_ref.def_id, &[])
         })
     }
 }
@@ -798,7 +816,7 @@ impl<'tcx> fmt::Display for ty::Binder<ty::OutlivesPredicate<&'tcx ty::Region,
 
 impl<'tcx> fmt::Display for ty::TraitRef<'tcx> {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        parameterized(f, self.substs, self.def_id, Ns::Type, &[])
+        parameterized(f, self.substs, self.def_id, &[])
     }
 }
 
@@ -851,7 +869,7 @@ impl<'tcx> fmt::Display for ty::TypeVariants<'tcx> {
                 }
 
                 write!(f, "{} {{", bare_fn.sig.0)?;
-                parameterized(f, substs, def_id, Ns::Value, &[])?;
+                parameterized(f, substs, def_id, &[])?;
                 write!(f, "}}")
             }
             TyFnPtr(ref bare_fn) => {
@@ -874,7 +892,7 @@ impl<'tcx> fmt::Display for ty::TypeVariants<'tcx> {
                           !tcx.tcache.borrow().contains_key(&def.did) {
                         write!(f, "{}<..>", tcx.item_path_str(def.did))
                     } else {
-                        parameterized(f, substs, def.did, Ns::Type, &[])
+                        parameterized(f, substs, def.did, &[])
                     }
                 })
             }
diff --git a/src/librustc_back/lib.rs b/src/librustc_back/lib.rs
index e6d1982d31c2d..da5f787bdf31e 100644
--- a/src/librustc_back/lib.rs
+++ b/src/librustc_back/lib.rs
@@ -36,9 +36,8 @@
 #![feature(rand)]
 #![feature(rustc_private)]
 #![feature(staged_api)]
-#![feature(step_by)]
 #![cfg_attr(stage0, feature(question_mark))]
-#![cfg_attr(test, feature(test, rand))]
+#![cfg_attr(test, feature(rand))]
 
 extern crate syntax;
 extern crate libc;
@@ -48,7 +47,6 @@ extern crate serialize;
 extern crate serialize as rustc_serialize; // used by deriving
 
 pub mod tempdir;
-pub mod sha2;
 pub mod target;
 pub mod slice;
 pub mod dynamic_lib;
diff --git a/src/librustc_back/sha2.rs b/src/librustc_back/sha2.rs
deleted file mode 100644
index 97fb39c17ea0e..0000000000000
--- a/src/librustc_back/sha2.rs
+++ /dev/null
@@ -1,679 +0,0 @@
-// Copyright 2012-2014 The Rust Project Developers. See the COPYRIGHT
-// file at the top-level directory of this distribution and at
-// http://rust-lang.org/COPYRIGHT.
-//
-// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
-// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
-// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
-// option. This file may not be copied, modified, or distributed
-// except according to those terms.
-
-//! This module implements only the Sha256 function since that is all that is needed for internal
-//! use. This implementation is not intended for external use or for any use where security is
-//! important.
-
-use serialize::hex::ToHex;
-
-/// Write a u32 into a vector, which must be 4 bytes long. The value is written in big-endian
-/// format.
-fn write_u32_be(dst: &mut[u8], input: u32) {
-    dst[0] = (input >> 24) as u8;
-    dst[1] = (input >> 16) as u8;
-    dst[2] = (input >> 8) as u8;
-    dst[3] = input as u8;
-}
-
-/// Read the value of a vector of bytes as a u32 value in big-endian format.
-fn read_u32_be(input: &[u8]) -> u32 {
-    (input[0] as u32) << 24 |
-        (input[1] as u32) << 16 |
-        (input[2] as u32) << 8 |
-        (input[3] as u32)
-}
-
-/// Read a vector of bytes into a vector of u32s. The values are read in big-endian format.
-fn read_u32v_be(dst: &mut[u32], input: &[u8]) {
-    assert!(dst.len() * 4 == input.len());
-    let mut pos = 0;
-    for chunk in input.chunks(4) {
-        dst[pos] = read_u32_be(chunk);
-        pos += 1;
-    }
-}
-
-trait ToBits: Sized {
-    /// Convert the value in bytes to the number of bits, a tuple where the 1st item is the
-    /// high-order value and the 2nd item is the low order value.
-    fn to_bits(self) -> (Self, Self);
-}
-
-impl ToBits for u64 {
-    fn to_bits(self) -> (u64, u64) {
-        (self >> 61, self << 3)
-    }
-}
-
-/// Adds the specified number of bytes to the bit count. panic!() if this would cause numeric
-/// overflow.
-fn add_bytes_to_bits(bits: u64, bytes: u64) -> u64 {
-    let (new_high_bits, new_low_bits) = bytes.to_bits();
-
-    if new_high_bits > 0 {
-        panic!("numeric overflow occurred.")
-    }
-
-    match bits.checked_add(new_low_bits) {
-        Some(x) => x,
-        None => panic!("numeric overflow occurred.")
-    }
-}
-
-/// A FixedBuffer, likes its name implies, is a fixed size buffer. When the buffer becomes full, it
-/// must be processed. The input() method takes care of processing and then clearing the buffer
-/// automatically. However, other methods do not and require the caller to process the buffer. Any
-/// method that modifies the buffer directory or provides the caller with bytes that can be modified
-/// results in those bytes being marked as used by the buffer.
-trait FixedBuffer {
-    /// Input a vector of bytes. If the buffer becomes full, process it with the provided
-    /// function and then clear the buffer.
-    fn input<F>(&mut self, input: &[u8], func: F) where
-        F: FnMut(&[u8]);
-
-    /// Reset the buffer.
-    fn reset(&mut self);
-
-    /// Zero the buffer up until the specified index. The buffer position currently must not be
-    /// greater than that index.
-    fn zero_until(&mut self, idx: usize);
-
-    /// Get a slice of the buffer of the specified size. There must be at least that many bytes
-    /// remaining in the buffer.
-    fn next<'s>(&'s mut self, len: usize) -> &'s mut [u8];
-
-    /// Get the current buffer. The buffer must already be full. This clears the buffer as well.
-    fn full_buffer<'s>(&'s mut self) -> &'s [u8];
-
-    /// Get the current position of the buffer.
-    fn position(&self) -> usize;
-
-    /// Get the number of bytes remaining in the buffer until it is full.
-    fn remaining(&self) -> usize;
-
-    /// Get the size of the buffer
-    fn size(&self) -> usize;
-}
-
-/// A FixedBuffer of 64 bytes useful for implementing Sha256 which has a 64 byte blocksize.
-struct FixedBuffer64 {
-    buffer: [u8; 64],
-    buffer_idx: usize,
-}
-
-impl FixedBuffer64 {
-    /// Create a new FixedBuffer64
-    fn new() -> FixedBuffer64 {
-        FixedBuffer64 {
-            buffer: [0; 64],
-            buffer_idx: 0
-        }
-    }
-}
-
-impl FixedBuffer for FixedBuffer64 {
-    fn input<F>(&mut self, input: &[u8], mut func: F) where
-        F: FnMut(&[u8]),
-    {
-        let mut i = 0;
-
-        let size = self.size();
-
-        // If there is already data in the buffer, copy as much as we can into it and process
-        // the data if the buffer becomes full.
-        if self.buffer_idx != 0 {
-            let buffer_remaining = size - self.buffer_idx;
-            if input.len() >= buffer_remaining {
-                self.buffer[self.buffer_idx..size]
-                    .copy_from_slice(&input[..buffer_remaining]);
-                self.buffer_idx = 0;
-                func(&self.buffer);
-                i += buffer_remaining;
-            } else {
-                self.buffer[self.buffer_idx..self.buffer_idx + input.len()]
-                    .copy_from_slice(input);
-                self.buffer_idx += input.len();
-                return;
-            }
-        }
-
-        // While we have at least a full buffer size chunk's worth of data, process that data
-        // without copying it into the buffer
-        while input.len() - i >= size {
-            func(&input[i..i + size]);
-            i += size;
-        }
-
-        // Copy any input data into the buffer. At this point in the method, the amount of
-        // data left in the input vector will be less than the buffer size and the buffer will
-        // be empty.
-        let input_remaining = input.len() - i;
-        self.buffer[..input_remaining].copy_from_slice(&input[i..]);
-        self.buffer_idx += input_remaining;
-    }
-
-    fn reset(&mut self) {
-        self.buffer_idx = 0;
-    }
-
-    fn zero_until(&mut self, idx: usize) {
-        assert!(idx >= self.buffer_idx);
-        for slot in self.buffer[self.buffer_idx..idx].iter_mut() {
-            *slot = 0;
-        }
-        self.buffer_idx = idx;
-    }
-
-    fn next<'s>(&'s mut self, len: usize) -> &'s mut [u8] {
-        self.buffer_idx += len;
-        &mut self.buffer[self.buffer_idx - len..self.buffer_idx]
-    }
-
-    fn full_buffer<'s>(&'s mut self) -> &'s [u8] {
-        assert!(self.buffer_idx == 64);
-        self.buffer_idx = 0;
-        &self.buffer[..64]
-    }
-
-    fn position(&self) -> usize { self.buffer_idx }
-
-    fn remaining(&self) -> usize { 64 - self.buffer_idx }
-
-    fn size(&self) -> usize { 64 }
-}
-
-/// The StandardPadding trait adds a method useful for Sha256 to a FixedBuffer struct.
-trait StandardPadding {
-    /// Add padding to the buffer. The buffer must not be full when this method is called and is
-    /// guaranteed to have exactly rem remaining bytes when it returns. If there are not at least
-    /// rem bytes available, the buffer will be zero padded, processed, cleared, and then filled
-    /// with zeros again until only rem bytes are remaining.
-    fn standard_padding<F>(&mut self, rem: usize, func: F) where F: FnMut(&[u8]);
-}
-
-impl <T: FixedBuffer> StandardPadding for T {
-    fn standard_padding<F>(&mut self, rem: usize, mut func: F) where F: FnMut(&[u8]) {
-        let size = self.size();
-
-        self.next(1)[0] = 128;
-
-        if self.remaining() < rem {
-            self.zero_until(size);
-            func(self.full_buffer());
-        }
-
-        self.zero_until(size - rem);
-    }
-}
-
-/// The Digest trait specifies an interface common to digest functions, such as SHA-1 and the SHA-2
-/// family of digest functions.
-pub trait Digest {
-    /// Provide message data.
-    ///
-    /// # Arguments
-    ///
-    /// * input - A vector of message data
-    fn input(&mut self, input: &[u8]);
-
-    /// Retrieve the digest result. This method may be called multiple times.
-    ///
-    /// # Arguments
-    ///
-    /// * out - the vector to hold the result. Must be large enough to contain output_bits().
-    fn result(&mut self, out: &mut [u8]);
-
-    /// Reset the digest. This method must be called after result() and before supplying more
-    /// data.
-    fn reset(&mut self);
-
-    /// Get the output size in bits.
-    fn output_bits(&self) -> usize;
-
-    /// Convenience function that feeds a string into a digest.
-    ///
-    /// # Arguments
-    ///
-    /// * `input` The string to feed into the digest
-    fn input_str(&mut self, input: &str) {
-        self.input(input.as_bytes());
-    }
-
-    /// Convenience function that retrieves the result of a digest as a
-    /// newly allocated vec of bytes.
-    fn result_bytes(&mut self) -> Vec<u8> {
-        let mut buf = vec![0; (self.output_bits()+7)/8];
-        self.result(&mut buf);
-        buf
-    }
-
-    /// Convenience function that retrieves the result of a digest as a
-    /// String in hexadecimal format.
-    fn result_str(&mut self) -> String {
-        self.result_bytes().to_hex().to_string()
-    }
-}
-
-// A structure that represents that state of a digest computation for the SHA-2 512 family of digest
-// functions
-struct Engine256State {
-    h0: u32,
-    h1: u32,
-    h2: u32,
-    h3: u32,
-    h4: u32,
-    h5: u32,
-    h6: u32,
-    h7: u32,
-}
-
-impl Engine256State {
-    fn new(h: &[u32; 8]) -> Engine256State {
-        Engine256State {
-            h0: h[0],
-            h1: h[1],
-            h2: h[2],
-            h3: h[3],
-            h4: h[4],
-            h5: h[5],
-            h6: h[6],
-            h7: h[7]
-        }
-    }
-
-    fn reset(&mut self, h: &[u32; 8]) {
-        self.h0 = h[0];
-        self.h1 = h[1];
-        self.h2 = h[2];
-        self.h3 = h[3];
-        self.h4 = h[4];
-        self.h5 = h[5];
-        self.h6 = h[6];
-        self.h7 = h[7];
-    }
-
-    fn process_block(&mut self, data: &[u8]) {
-        fn ch(x: u32, y: u32, z: u32) -> u32 {
-            ((x & y) ^ ((!x) & z))
-        }
-
-        fn maj(x: u32, y: u32, z: u32) -> u32 {
-            ((x & y) ^ (x & z) ^ (y & z))
-        }
-
-        fn sum0(x: u32) -> u32 {
-            ((x >> 2) | (x << 30)) ^ ((x >> 13) | (x << 19)) ^ ((x >> 22) | (x << 10))
-        }
-
-        fn sum1(x: u32) -> u32 {
-            ((x >> 6) | (x << 26)) ^ ((x >> 11) | (x << 21)) ^ ((x >> 25) | (x << 7))
-        }
-
-        fn sigma0(x: u32) -> u32 {
-            ((x >> 7) | (x << 25)) ^ ((x >> 18) | (x << 14)) ^ (x >> 3)
-        }
-
-        fn sigma1(x: u32) -> u32 {
-            ((x >> 17) | (x << 15)) ^ ((x >> 19) | (x << 13)) ^ (x >> 10)
-        }
-
-        let mut a = self.h0;
-        let mut b = self.h1;
-        let mut c = self.h2;
-        let mut d = self.h3;
-        let mut e = self.h4;
-        let mut f = self.h5;
-        let mut g = self.h6;
-        let mut h = self.h7;
-
-        let mut w = [0; 64];
-
-        // Sha-512 and Sha-256 use basically the same calculations which are implemented
-        // by these macros. Inlining the calculations seems to result in better generated code.
-        macro_rules! schedule_round { ($t:expr) => (
-            w[$t] = sigma1(w[$t - 2]).wrapping_add(w[$t - 7])
-                .wrapping_add(sigma0(w[$t - 15])).wrapping_add(w[$t - 16]);
-            )
-        }
-
-        macro_rules! sha2_round {
-            ($A:ident, $B:ident, $C:ident, $D:ident,
-             $E:ident, $F:ident, $G:ident, $H:ident, $K:ident, $t:expr) => (
-                {
-                    $H = $H.wrapping_add(sum1($E)).wrapping_add(ch($E, $F, $G))
-                        .wrapping_add($K[$t]).wrapping_add(w[$t]);
-                    $D = $D.wrapping_add($H);
-                    $H = $H.wrapping_add(sum0($A)).wrapping_add(maj($A, $B, $C));
-                }
-             )
-        }
-
-        read_u32v_be(&mut w[0..16], data);
-
-        // Putting the message schedule inside the same loop as the round calculations allows for
-        // the compiler to generate better code.
-        for t in (0..48).step_by(8) {
-            schedule_round!(t + 16);
-            schedule_round!(t + 17);
-            schedule_round!(t + 18);
-            schedule_round!(t + 19);
-            schedule_round!(t + 20);
-            schedule_round!(t + 21);
-            schedule_round!(t + 22);
-            schedule_round!(t + 23);
-
-            sha2_round!(a, b, c, d, e, f, g, h, K32, t);
-            sha2_round!(h, a, b, c, d, e, f, g, K32, t + 1);
-            sha2_round!(g, h, a, b, c, d, e, f, K32, t + 2);
-            sha2_round!(f, g, h, a, b, c, d, e, K32, t + 3);
-            sha2_round!(e, f, g, h, a, b, c, d, K32, t + 4);
-            sha2_round!(d, e, f, g, h, a, b, c, K32, t + 5);
-            sha2_round!(c, d, e, f, g, h, a, b, K32, t + 6);
-            sha2_round!(b, c, d, e, f, g, h, a, K32, t + 7);
-        }
-
-        for t in (48..64).step_by(8) {
-            sha2_round!(a, b, c, d, e, f, g, h, K32, t);
-            sha2_round!(h, a, b, c, d, e, f, g, K32, t + 1);
-            sha2_round!(g, h, a, b, c, d, e, f, K32, t + 2);
-            sha2_round!(f, g, h, a, b, c, d, e, K32, t + 3);
-            sha2_round!(e, f, g, h, a, b, c, d, K32, t + 4);
-            sha2_round!(d, e, f, g, h, a, b, c, K32, t + 5);
-            sha2_round!(c, d, e, f, g, h, a, b, K32, t + 6);
-            sha2_round!(b, c, d, e, f, g, h, a, K32, t + 7);
-        }
-
-        self.h0 = self.h0.wrapping_add(a);
-        self.h1 = self.h1.wrapping_add(b);
-        self.h2 = self.h2.wrapping_add(c);
-        self.h3 = self.h3.wrapping_add(d);
-        self.h4 = self.h4.wrapping_add(e);
-        self.h5 = self.h5.wrapping_add(f);
-        self.h6 = self.h6.wrapping_add(g);
-        self.h7 = self.h7.wrapping_add(h);
-    }
-}
-
-static K32: [u32; 64] = [
-    0x428a2f98, 0x71374491, 0xb5c0fbcf, 0xe9b5dba5,
-    0x3956c25b, 0x59f111f1, 0x923f82a4, 0xab1c5ed5,
-    0xd807aa98, 0x12835b01, 0x243185be, 0x550c7dc3,
-    0x72be5d74, 0x80deb1fe, 0x9bdc06a7, 0xc19bf174,
-    0xe49b69c1, 0xefbe4786, 0x0fc19dc6, 0x240ca1cc,
-    0x2de92c6f, 0x4a7484aa, 0x5cb0a9dc, 0x76f988da,
-    0x983e5152, 0xa831c66d, 0xb00327c8, 0xbf597fc7,
-    0xc6e00bf3, 0xd5a79147, 0x06ca6351, 0x14292967,
-    0x27b70a85, 0x2e1b2138, 0x4d2c6dfc, 0x53380d13,
-    0x650a7354, 0x766a0abb, 0x81c2c92e, 0x92722c85,
-    0xa2bfe8a1, 0xa81a664b, 0xc24b8b70, 0xc76c51a3,
-    0xd192e819, 0xd6990624, 0xf40e3585, 0x106aa070,
-    0x19a4c116, 0x1e376c08, 0x2748774c, 0x34b0bcb5,
-    0x391c0cb3, 0x4ed8aa4a, 0x5b9cca4f, 0x682e6ff3,
-    0x748f82ee, 0x78a5636f, 0x84c87814, 0x8cc70208,
-    0x90befffa, 0xa4506ceb, 0xbef9a3f7, 0xc67178f2
-];
-
-// A structure that keeps track of the state of the Sha-256 operation and contains the logic
-// necessary to perform the final calculations.
-struct Engine256 {
-    length_bits: u64,
-    buffer: FixedBuffer64,
-    state: Engine256State,
-    finished: bool,
-}
-
-impl Engine256 {
-    fn new(h: &[u32; 8]) -> Engine256 {
-        Engine256 {
-            length_bits: 0,
-            buffer: FixedBuffer64::new(),
-            state: Engine256State::new(h),
-            finished: false
-        }
-    }
-
-    fn reset(&mut self, h: &[u32; 8]) {
-        self.length_bits = 0;
-        self.buffer.reset();
-        self.state.reset(h);
-        self.finished = false;
-    }
-
-    fn input(&mut self, input: &[u8]) {
-        assert!(!self.finished);
-        // Assumes that input.len() can be converted to u64 without overflow
-        self.length_bits = add_bytes_to_bits(self.length_bits, input.len() as u64);
-        let self_state = &mut self.state;
-        self.buffer.input(input, |input: &[u8]| { self_state.process_block(input) });
-    }
-
-    fn finish(&mut self) {
-        if !self.finished {
-            let self_state = &mut self.state;
-            self.buffer.standard_padding(8, |input: &[u8]| { self_state.process_block(input) });
-            write_u32_be(self.buffer.next(4), (self.length_bits >> 32) as u32 );
-            write_u32_be(self.buffer.next(4), self.length_bits as u32);
-            self_state.process_block(self.buffer.full_buffer());
-
-            self.finished = true;
-        }
-    }
-}
-
-/// The SHA-256 hash algorithm
-pub struct Sha256 {
-    engine: Engine256
-}
-
-impl Sha256 {
-    /// Construct a new instance of a SHA-256 digest.
-    /// Do not – under any circumstances – use this where timing attacks might be possible!
-    pub fn new() -> Sha256 {
-        Sha256 {
-            engine: Engine256::new(&H256)
-        }
-    }
-}
-
-impl Digest for Sha256 {
-    fn input(&mut self, d: &[u8]) {
-        self.engine.input(d);
-    }
-
-    fn result(&mut self, out: &mut [u8]) {
-        self.engine.finish();
-
-        write_u32_be(&mut out[0..4], self.engine.state.h0);
-        write_u32_be(&mut out[4..8], self.engine.state.h1);
-        write_u32_be(&mut out[8..12], self.engine.state.h2);
-        write_u32_be(&mut out[12..16], self.engine.state.h3);
-        write_u32_be(&mut out[16..20], self.engine.state.h4);
-        write_u32_be(&mut out[20..24], self.engine.state.h5);
-        write_u32_be(&mut out[24..28], self.engine.state.h6);
-        write_u32_be(&mut out[28..32], self.engine.state.h7);
-    }
-
-    fn reset(&mut self) {
-        self.engine.reset(&H256);
-    }
-
-    fn output_bits(&self) -> usize { 256 }
-}
-
-static H256: [u32; 8] = [
-    0x6a09e667,
-    0xbb67ae85,
-    0x3c6ef372,
-    0xa54ff53a,
-    0x510e527f,
-    0x9b05688c,
-    0x1f83d9ab,
-    0x5be0cd19
-];
-
-#[cfg(test)]
-mod tests {
-    #![allow(deprecated)]
-    extern crate rand;
-
-    use self::rand::Rng;
-    use self::rand::isaac::IsaacRng;
-    use serialize::hex::FromHex;
-    use std::u64;
-    use super::{Digest, Sha256};
-
-    // A normal addition - no overflow occurs
-    #[test]
-    fn test_add_bytes_to_bits_ok() {
-        assert!(super::add_bytes_to_bits(100, 10) == 180);
-    }
-
-    // A simple failure case - adding 1 to the max value
-    #[test]
-    #[should_panic]
-    fn test_add_bytes_to_bits_overflow() {
-        super::add_bytes_to_bits(u64::MAX, 1);
-    }
-
-    struct Test {
-        input: String,
-        output_str: String,
-    }
-
-    fn test_hash<D: Digest>(sh: &mut D, tests: &[Test]) {
-        // Test that it works when accepting the message all at once
-        for t in tests {
-            sh.reset();
-            sh.input_str(&t.input);
-            let out_str = sh.result_str();
-            assert!(out_str == t.output_str);
-        }
-
-        // Test that it works when accepting the message in pieces
-        for t in tests {
-            sh.reset();
-            let len = t.input.len();
-            let mut left = len;
-            while left > 0 {
-                let take = (left + 1) / 2;
-                sh.input_str(&t.input[len - left..take + len - left]);
-                left = left - take;
-            }
-            let out_str = sh.result_str();
-            assert!(out_str == t.output_str);
-        }
-    }
-
-    #[test]
-    fn test_sha256() {
-        // Examples from wikipedia
-        let wikipedia_tests = vec!(
-            Test {
-                input: "".to_string(),
-                output_str: "e3b0c44298fc1c149afb\
-            f4c8996fb92427ae41e4649b934ca495991b7852b855".to_string()
-            },
-            Test {
-                input: "The quick brown fox jumps over the lazy \
-                        dog".to_string(),
-                output_str: "d7a8fbb307d7809469ca\
-            9abcb0082e4f8d5651e46d3cdb762d02d0bf37c9e592".to_string()
-            },
-            Test {
-                input: "The quick brown fox jumps over the lazy \
-                        dog.".to_string(),
-                output_str: "ef537f25c895bfa78252\
-            6529a9b63d97aa631564d5d789c2b765448c8635fb6c".to_string()
-            });
-
-        let tests = wikipedia_tests;
-
-        let mut sh: Box<_> = box Sha256::new();
-
-        test_hash(&mut *sh, &tests);
-    }
-
-    /// Feed 1,000,000 'a's into the digest with varying input sizes and check that the result is
-    /// correct.
-    fn test_digest_1million_random<D: Digest>(digest: &mut D, blocksize: usize, expected: &str) {
-        let total_size = 1000000;
-        let buffer = vec![b'a'; blocksize * 2];
-        let mut rng = IsaacRng::new_unseeded();
-        let mut count = 0;
-
-        digest.reset();
-
-        while count < total_size {
-            let next: usize = rng.gen_range(0, 2 * blocksize + 1);
-            let remaining = total_size - count;
-            let size = if next > remaining { remaining } else { next };
-            digest.input(&buffer[..size]);
-            count += size;
-        }
-
-        let result_str = digest.result_str();
-        let result_bytes = digest.result_bytes();
-
-        assert_eq!(expected, result_str);
-
-        let expected_vec: Vec<u8> = expected.from_hex()
-                                            .unwrap()
-                                            .into_iter()
-                                            .collect();
-        assert_eq!(expected_vec, result_bytes);
-    }
-
-    #[test]
-    fn test_1million_random_sha256() {
-        let mut sh = Sha256::new();
-        test_digest_1million_random(
-            &mut sh,
-            64,
-            "cdc76e5c9914fb9281a1c7e284d73e67f1809a48a497200e046d39ccc7112cd0");
-    }
-}
-
-#[cfg(test)]
-mod bench {
-    extern crate test;
-    use self::test::Bencher;
-    use super::{Sha256, Digest};
-
-    #[bench]
-    pub fn sha256_10(b: &mut Bencher) {
-        let mut sh = Sha256::new();
-        let bytes = [1; 10];
-        b.iter(|| {
-            sh.input(&bytes);
-        });
-        b.bytes = bytes.len() as u64;
-    }
-
-    #[bench]
-    pub fn sha256_1k(b: &mut Bencher) {
-        let mut sh = Sha256::new();
-        let bytes = [1; 1024];
-        b.iter(|| {
-            sh.input(&bytes);
-        });
-        b.bytes = bytes.len() as u64;
-    }
-
-    #[bench]
-    pub fn sha256_64k(b: &mut Bencher) {
-        let mut sh = Sha256::new();
-        let bytes = [1; 65536];
-        b.iter(|| {
-            sh.input(&bytes);
-        });
-        b.bytes = bytes.len() as u64;
-    }
-}
diff --git a/src/librustc_back/target/dragonfly_base.rs b/src/librustc_back/target/dragonfly_base.rs
index e2c4003a8b6e9..7555181a15cf2 100644
--- a/src/librustc_back/target/dragonfly_base.rs
+++ b/src/librustc_back/target/dragonfly_base.rs
@@ -17,7 +17,7 @@ pub fn opts() -> TargetOptions {
         executables: true,
         linker_is_gnu: true,
         has_rpath: true,
-        pre_link_args: vec!(
+        pre_link_args: vec![
             // GNU-style linkers will use this to omit linking to libraries
             // which don't actually fulfill any relocations, but only for
             // libraries which follow this flag.  Thus, use it before
@@ -26,7 +26,7 @@ pub fn opts() -> TargetOptions {
 
             // Always enable NX protection when it is available
             "-Wl,-z,noexecstack".to_string(),
-        ),
+        ],
         position_independent_executables: true,
         exe_allocation_crate: super::maybe_jemalloc(),
         .. Default::default()
diff --git a/src/librustc_back/target/freebsd_base.rs b/src/librustc_back/target/freebsd_base.rs
index e2c4003a8b6e9..7555181a15cf2 100644
--- a/src/librustc_back/target/freebsd_base.rs
+++ b/src/librustc_back/target/freebsd_base.rs
@@ -17,7 +17,7 @@ pub fn opts() -> TargetOptions {
         executables: true,
         linker_is_gnu: true,
         has_rpath: true,
-        pre_link_args: vec!(
+        pre_link_args: vec![
             // GNU-style linkers will use this to omit linking to libraries
             // which don't actually fulfill any relocations, but only for
             // libraries which follow this flag.  Thus, use it before
@@ -26,7 +26,7 @@ pub fn opts() -> TargetOptions {
 
             // Always enable NX protection when it is available
             "-Wl,-z,noexecstack".to_string(),
-        ),
+        ],
         position_independent_executables: true,
         exe_allocation_crate: super::maybe_jemalloc(),
         .. Default::default()
diff --git a/src/librustc_back/target/le32_unknown_nacl.rs b/src/librustc_back/target/le32_unknown_nacl.rs
index a98a33feb5e9d..891e7dda14a2a 100644
--- a/src/librustc_back/target/le32_unknown_nacl.rs
+++ b/src/librustc_back/target/le32_unknown_nacl.rs
@@ -15,10 +15,10 @@ pub fn target() -> TargetResult {
         linker: "pnacl-clang".to_string(),
         ar: "pnacl-ar".to_string(),
 
-        pre_link_args: vec!("--pnacl-exceptions=sjlj".to_string(),
+        pre_link_args: vec!["--pnacl-exceptions=sjlj".to_string(),
                             "--target=le32-unknown-nacl".to_string(),
-                            "-Wl,--start-group".to_string()),
-        post_link_args: vec!("-Wl,--end-group".to_string()),
+                            "-Wl,--start-group".to_string()],
+        post_link_args: vec!["-Wl,--end-group".to_string()],
         dynamic_linking: false,
         executables: true,
         exe_suffix: ".pexe".to_string(),
diff --git a/src/librustc_back/target/netbsd_base.rs b/src/librustc_back/target/netbsd_base.rs
index cc03ed56aa4d7..6e038a7ed56ee 100644
--- a/src/librustc_back/target/netbsd_base.rs
+++ b/src/librustc_back/target/netbsd_base.rs
@@ -17,7 +17,7 @@ pub fn opts() -> TargetOptions {
         executables: true,
         linker_is_gnu: true,
         has_rpath: true,
-        pre_link_args: vec!(
+        pre_link_args: vec![
             // GNU-style linkers will use this to omit linking to libraries
             // which don't actually fulfill any relocations, but only for
             // libraries which follow this flag.  Thus, use it before
@@ -26,7 +26,7 @@ pub fn opts() -> TargetOptions {
 
             // Always enable NX protection when it is available
             "-Wl,-z,noexecstack".to_string(),
-        ),
+        ],
         position_independent_executables: true,
         .. Default::default()
     }
diff --git a/src/librustc_back/target/openbsd_base.rs b/src/librustc_back/target/openbsd_base.rs
index 7afdfcd691134..90e6631841bef 100644
--- a/src/librustc_back/target/openbsd_base.rs
+++ b/src/librustc_back/target/openbsd_base.rs
@@ -17,7 +17,7 @@ pub fn opts() -> TargetOptions {
         executables: true,
         linker_is_gnu: true,
         has_rpath: true,
-        pre_link_args: vec!(
+        pre_link_args: vec![
             // GNU-style linkers will use this to omit linking to libraries
             // which don't actually fulfill any relocations, but only for
             // libraries which follow this flag.  Thus, use it before
@@ -26,7 +26,7 @@ pub fn opts() -> TargetOptions {
 
             // Always enable NX protection when it is available
             "-Wl,-z,noexecstack".to_string(),
-        ),
+        ],
         position_independent_executables: true,
         exe_allocation_crate: "alloc_system".to_string(),
         .. Default::default()
diff --git a/src/librustc_back/target/windows_base.rs b/src/librustc_back/target/windows_base.rs
index c398ee40f2f97..19ca0df51b9dc 100644
--- a/src/librustc_back/target/windows_base.rs
+++ b/src/librustc_back/target/windows_base.rs
@@ -26,7 +26,7 @@ pub fn opts() -> TargetOptions {
         no_default_libraries: true,
         is_like_windows: true,
         allows_weak_linkage: false,
-        pre_link_args: vec!(
+        pre_link_args: vec![
             // And here, we see obscure linker flags #45. On windows, it has been
             // found to be necessary to have this flag to compile liblibc.
             //
@@ -63,26 +63,26 @@ pub fn opts() -> TargetOptions {
 
             // Do not use the standard system startup files or libraries when linking
             "-nostdlib".to_string(),
-        ),
-        pre_link_objects_exe: vec!(
+        ],
+        pre_link_objects_exe: vec![
             "crt2.o".to_string(),    // mingw C runtime initialization for executables
             "rsbegin.o".to_string(), // Rust compiler runtime initialization, see rsbegin.rs
-        ),
-        pre_link_objects_dll: vec!(
+        ],
+        pre_link_objects_dll: vec![
             "dllcrt2.o".to_string(), // mingw C runtime initialization for dlls
             "rsbegin.o".to_string(),
-        ),
-        late_link_args: vec!(
+        ],
+        late_link_args: vec![
             "-lmingwex".to_string(),
             "-lmingw32".to_string(),
             "-lgcc".to_string(), // alas, mingw* libraries above depend on libgcc
             "-lmsvcrt".to_string(),
             "-luser32".to_string(),
             "-lkernel32".to_string(),
-        ),
-        post_link_objects: vec!(
+        ],
+        post_link_objects: vec![
             "rsend.o".to_string()
-        ),
+        ],
         custom_unwind_resume: true,
 
         .. Default::default()
diff --git a/src/librustc_borrowck/borrowck/gather_loans/move_error.rs b/src/librustc_borrowck/borrowck/gather_loans/move_error.rs
index 9fbf1492f5d28..47f8d978704f4 100644
--- a/src/librustc_borrowck/borrowck/gather_loans/move_error.rs
+++ b/src/librustc_borrowck/borrowck/gather_loans/move_error.rs
@@ -92,7 +92,7 @@ fn group_errors_with_same_origin<'tcx>(errors: &Vec<MoveError<'tcx>>)
         let move_from_id = error.move_from.id;
         debug!("append_to_grouped_errors(move_from_id={})", move_from_id);
         let move_to = if error.move_to.is_some() {
-            vec!(error.move_to.clone().unwrap())
+            vec![error.move_to.clone().unwrap()]
         } else {
             Vec::new()
         };
diff --git a/src/librustc_borrowck/borrowck/move_data.rs b/src/librustc_borrowck/borrowck/move_data.rs
index e9ba406389f88..ba036f1a8b157 100644
--- a/src/librustc_borrowck/borrowck/move_data.rs
+++ b/src/librustc_borrowck/borrowck/move_data.rs
@@ -331,7 +331,7 @@ impl<'a, 'tcx> MoveData<'tcx> {
 
     fn existing_base_paths(&self, lp: &Rc<LoanPath<'tcx>>)
                            -> Vec<MovePathIndex> {
-        let mut result = vec!();
+        let mut result = vec![];
         self.add_existing_base_paths(lp, &mut result);
         result
     }
diff --git a/src/librustc_const_eval/diagnostics.rs b/src/librustc_const_eval/diagnostics.rs
index 092638cdee260..db72057636a85 100644
--- a/src/librustc_const_eval/diagnostics.rs
+++ b/src/librustc_const_eval/diagnostics.rs
@@ -454,7 +454,7 @@ loop variable, consider using a `match` or `if let` inside the loop body. For
 instance:
 
 ```compile_fail,E0297
-let xs : Vec<Option<i32>> = vec!(Some(1), None);
+let xs : Vec<Option<i32>> = vec![Some(1), None];
 
 // This fails because `None` is not covered.
 for Some(x) in xs {
@@ -465,7 +465,7 @@ for Some(x) in xs {
 Match inside the loop instead:
 
 ```
-let xs : Vec<Option<i32>> = vec!(Some(1), None);
+let xs : Vec<Option<i32>> = vec![Some(1), None];
 
 for item in xs {
     match item {
@@ -478,7 +478,7 @@ for item in xs {
 Or use `if let`:
 
 ```
-let xs : Vec<Option<i32>> = vec!(Some(1), None);
+let xs : Vec<Option<i32>> = vec![Some(1), None];
 
 for item in xs {
     if let Some(x) = item {
diff --git a/src/librustc_data_structures/blake2b.rs b/src/librustc_data_structures/blake2b.rs
index 996df2e7fcfca..8c82c135dc426 100644
--- a/src/librustc_data_structures/blake2b.rs
+++ b/src/librustc_data_structures/blake2b.rs
@@ -20,17 +20,25 @@
 // implementation. If you have the luxury of being able to use crates from
 // crates.io, you can go there and find still faster implementations.
 
+use std::mem;
+use std::slice;
+
 pub struct Blake2bCtx {
     b: [u8; 128],
     h: [u64; 8],
     t: [u64; 2],
     c: usize,
-    outlen: usize,
+    outlen: u16,
+    finalized: bool
 }
 
 impl ::std::fmt::Debug for Blake2bCtx {
     fn fmt(&self, fmt: &mut ::std::fmt::Formatter) -> Result<(), ::std::fmt::Error> {
-        write!(fmt, "{:?}", self.h)
+        try!(write!(fmt, "hash: "));
+        for v in &self.h[..] {
+            try!(write!(fmt, "{:x}", v));
+        }
+        Ok(())
     }
 }
 
@@ -136,7 +144,7 @@ fn blake2b_compress(ctx: &mut Blake2bCtx, last: bool) {
     }
 }
 
-pub fn blake2b_new(outlen: usize, key: &[u8]) -> Blake2bCtx {
+fn blake2b_new(outlen: usize, key: &[u8]) -> Blake2bCtx {
     assert!(outlen > 0 && outlen <= 64 && key.len() <= 64);
 
     let mut ctx = Blake2bCtx {
@@ -144,7 +152,8 @@ pub fn blake2b_new(outlen: usize, key: &[u8]) -> Blake2bCtx {
         h: BLAKE2B_IV,
         t: [0; 2],
         c: 0,
-        outlen: outlen,
+        outlen: outlen as u16,
+        finalized: false,
     };
 
     ctx.h[0] ^= 0x01010000 ^ ((key.len() << 8) as u64) ^ (outlen as u64);
@@ -157,8 +166,9 @@ pub fn blake2b_new(outlen: usize, key: &[u8]) -> Blake2bCtx {
     ctx
 }
 
-pub fn blake2b_update(ctx: &mut Blake2bCtx, mut data: &[u8])
-{
+fn blake2b_update(ctx: &mut Blake2bCtx, mut data: &[u8]) {
+    assert!(!ctx.finalized, "Blake2bCtx already finalized");
+
     let mut bytes_to_copy = data.len();
     let mut space_in_buffer = ctx.b.len() - ctx.c;
 
@@ -183,8 +193,10 @@ pub fn blake2b_update(ctx: &mut Blake2bCtx, mut data: &[u8])
     }
 }
 
-pub fn blake2b_final(mut ctx: Blake2bCtx, out: &mut [u8])
+fn blake2b_final(ctx: &mut Blake2bCtx)
 {
+    assert!(!ctx.finalized, "Blake2bCtx already finalized");
+
     ctx.t[0] = ctx.t[0].wrapping_add(ctx.c as u64);
     if ctx.t[0] < ctx.c as u64 {
         ctx.t[1] += 1;
@@ -195,7 +207,7 @@ pub fn blake2b_final(mut ctx: Blake2bCtx, out: &mut [u8])
         ctx.c += 1;
     }
 
-    blake2b_compress(&mut ctx, true);
+    blake2b_compress(ctx, true);
 
     if cfg!(target_endian = "big") {
         // Make sure that the data is in memory in little endian format, as is
@@ -205,13 +217,13 @@ pub fn blake2b_final(mut ctx: Blake2bCtx, out: &mut [u8])
         }
     }
 
-    checked_mem_copy(&ctx.h, out, ctx.outlen);
+    ctx.finalized = true;
 }
 
 #[inline(always)]
 fn checked_mem_copy<T1, T2>(from: &[T1], to: &mut [T2], byte_count: usize) {
-    let from_size = from.len() * ::std::mem::size_of::<T1>();
-    let to_size = to.len() * ::std::mem::size_of::<T2>();
+    let from_size = from.len() * mem::size_of::<T1>();
+    let to_size = to.len() * mem::size_of::<T2>();
     assert!(from_size >= byte_count);
     assert!(to_size >= byte_count);
     let from_byte_ptr = from.as_ptr() as * const u8;
@@ -225,7 +237,45 @@ pub fn blake2b(out: &mut [u8], key: &[u8],  data: &[u8])
 {
     let mut ctx = blake2b_new(out.len(), key);
     blake2b_update(&mut ctx, data);
-    blake2b_final(ctx, out);
+    blake2b_final(&mut ctx);
+    checked_mem_copy(&ctx.h, out, ctx.outlen as usize);
+}
+
+pub struct Blake2bHasher(Blake2bCtx);
+
+impl ::std::hash::Hasher for Blake2bHasher {
+    fn write(&mut self, bytes: &[u8]) {
+        blake2b_update(&mut self.0, bytes);
+    }
+
+    fn finish(&self) -> u64 {
+        assert!(self.0.outlen == 8,
+                "Hasher initialized with incompatible output length");
+        u64::from_le(self.0.h[0])
+    }
+}
+
+impl Blake2bHasher {
+    pub fn new(outlen: usize, key: &[u8]) -> Blake2bHasher {
+        Blake2bHasher(blake2b_new(outlen, key))
+    }
+
+    pub fn finalize(&mut self) -> &[u8] {
+        if !self.0.finalized {
+            blake2b_final(&mut self.0);
+        }
+        debug_assert!(mem::size_of_val(&self.0.h) >= self.0.outlen as usize);
+        let raw_ptr = (&self.0.h[..]).as_ptr() as * const u8;
+        unsafe {
+            slice::from_raw_parts(raw_ptr, self.0.outlen as usize)
+        }
+    }
+}
+
+impl ::std::fmt::Debug for Blake2bHasher {
+    fn fmt(&self, fmt: &mut ::std::fmt::Formatter) -> Result<(), ::std::fmt::Error> {
+        write!(fmt, "{:?}", self.0)
+    }
 }
 
 #[cfg(test)]
@@ -245,6 +295,8 @@ fn selftest_seq(out: &mut [u8], seed: u32)
 #[test]
 fn blake2b_selftest()
 {
+    use std::hash::Hasher;
+
     // grand hash of hash results
     const BLAKE2B_RES: [u8; 32] = [
         0xC2, 0x3A, 0x78, 0x00, 0xD9, 0x81, 0x23, 0xBD,
@@ -261,7 +313,7 @@ fn blake2b_selftest()
     let mut md = [0u8; 64];
     let mut key = [0u8; 64];
 
-    let mut ctx = blake2b_new(32, &[]);
+    let mut hasher = Blake2bHasher::new(32, &[]);
 
     for i in 0 .. 4 {
        let outlen = B2B_MD_LEN[i];
@@ -270,16 +322,16 @@ fn blake2b_selftest()
 
             selftest_seq(&mut data[.. inlen], inlen as u32); // unkeyed hash
             blake2b(&mut md[.. outlen], &[], &data[.. inlen]);
-            blake2b_update(&mut ctx, &md[.. outlen]); // hash the hash
+            hasher.write(&md[.. outlen]); // hash the hash
 
             selftest_seq(&mut key[0 .. outlen], outlen as u32); // keyed hash
             blake2b(&mut md[.. outlen], &key[.. outlen], &data[.. inlen]);
-            blake2b_update(&mut ctx, &md[.. outlen]); // hash the hash
+            hasher.write(&md[.. outlen]); // hash the hash
        }
     }
 
     // compute and compare the hash of hashes
-    blake2b_final(ctx, &mut md[..]);
+    let md = hasher.finalize();
     for i in 0 .. 32 {
         assert_eq!(md[i], BLAKE2B_RES[i]);
     }
diff --git a/src/librustc_data_structures/fmt_wrap.rs b/src/librustc_data_structures/fmt_wrap.rs
new file mode 100644
index 0000000000000..50fd1d802b7ff
--- /dev/null
+++ b/src/librustc_data_structures/fmt_wrap.rs
@@ -0,0 +1,31 @@
+// Copyright 2016 The Rust Project Developers. See the COPYRIGHT
+// file at the top-level directory of this distribution and at
+// http://rust-lang.org/COPYRIGHT.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+use std::fmt;
+
+// Provide some more formatting options for some data types (at the moment
+// that's just `{:x}` for slices of u8).
+
+pub struct FmtWrap<T>(pub T);
+
+impl<'a> fmt::LowerHex for FmtWrap<&'a [u8]> {
+    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
+        for byte in self.0.iter() {
+            try!(write!(formatter, "{:02x}", byte));
+        }
+        Ok(())
+    }
+}
+
+#[test]
+fn test_lower_hex() {
+    let bytes: &[u8] = &[0x01, 0x23, 0x45, 0x67, 0x89, 0xab, 0xcd, 0xef];
+    assert_eq!("0123456789abcdef", &format!("{:x}", FmtWrap(bytes)));
+}
diff --git a/src/librustc_data_structures/lib.rs b/src/librustc_data_structures/lib.rs
index 143c180f823d0..fc963dac9495f 100644
--- a/src/librustc_data_structures/lib.rs
+++ b/src/librustc_data_structures/lib.rs
@@ -49,6 +49,7 @@ pub mod accumulate_vec;
 pub mod bitslice;
 pub mod blake2b;
 pub mod bitvec;
+pub mod fmt_wrap;
 pub mod graph;
 pub mod ivar;
 pub mod indexed_set;
diff --git a/src/librustc_driver/Cargo.toml b/src/librustc_driver/Cargo.toml
index 98e2aa881891d..99d3e155e8936 100644
--- a/src/librustc_driver/Cargo.toml
+++ b/src/librustc_driver/Cargo.toml
@@ -18,6 +18,7 @@ rustc = { path = "../librustc" }
 rustc_back = { path = "../librustc_back" }
 rustc_borrowck = { path = "../librustc_borrowck" }
 rustc_const_eval = { path = "../librustc_const_eval" }
+rustc_data_structures = { path = "../librustc_data_structures" }
 rustc_errors = { path = "../librustc_errors" }
 rustc_incremental = { path = "../librustc_incremental" }
 rustc_lint = { path = "../librustc_lint" }
diff --git a/src/librustc_driver/driver.rs b/src/librustc_driver/driver.rs
index 318616726f417..da1d5ad2c4a9b 100644
--- a/src/librustc_driver/driver.rs
+++ b/src/librustc_driver/driver.rs
@@ -12,6 +12,9 @@ use rustc::hir;
 use rustc::hir::{map as hir_map, FreevarMap, TraitMap};
 use rustc::hir::def::DefMap;
 use rustc::hir::lowering::lower_crate;
+use rustc_data_structures::blake2b::Blake2bHasher;
+use rustc_data_structures::fmt_wrap::FmtWrap;
+use rustc::ty::util::ArchIndependentHasher;
 use rustc_mir as mir;
 use rustc::session::{Session, CompileResult, compile_result_from_err_count};
 use rustc::session::config::{self, Input, OutputFilenames, OutputType,
@@ -23,7 +26,6 @@ use rustc::middle::privacy::AccessLevels;
 use rustc::ty::{self, TyCtxt};
 use rustc::util::common::time;
 use rustc::util::nodemap::NodeSet;
-use rustc_back::sha2::{Sha256, Digest};
 use rustc_borrowck as borrowck;
 use rustc_incremental::{self, IncrementalHashesMap};
 use rustc_resolve::{MakeGlobMap, Resolver};
@@ -1221,7 +1223,16 @@ pub fn collect_crate_types(session: &Session, attrs: &[ast::Attribute]) -> Vec<c
 }
 
 pub fn compute_crate_disambiguator(session: &Session) -> String {
-    let mut hasher = Sha256::new();
+    use std::hash::Hasher;
+
+    // The crate_disambiguator is a 128 bit hash. The disambiguator is fed
+    // into various other hashes quite a bit (symbol hashes, incr. comp. hashes,
+    // debuginfo type IDs, etc), so we don't want it to be too wide. 128 bits
+    // should still be safe enough to avoid collisions in practice.
+    // FIXME(mw): It seems that the crate_disambiguator is used everywhere as
+    //            a hex-string instead of raw bytes. We should really use the
+    //            smaller representation.
+    let mut hasher = ArchIndependentHasher::new(Blake2bHasher::new(128 / 8, &[]));
 
     let mut metadata = session.opts.cg.metadata.clone();
     // We don't want the crate_disambiguator to dependent on the order
@@ -1230,24 +1241,23 @@ pub fn compute_crate_disambiguator(session: &Session) -> String {
     // Every distinct -C metadata value is only incorporated once:
     metadata.dedup();
 
-    hasher.input_str("metadata");
+    hasher.write(b"metadata");
     for s in &metadata {
         // Also incorporate the length of a metadata string, so that we generate
         // different values for `-Cmetadata=ab -Cmetadata=c` and
         // `-Cmetadata=a -Cmetadata=bc`
-        hasher.input_str(&format!("{}", s.len())[..]);
-        hasher.input_str(&s[..]);
+        hasher.write_usize(s.len());
+        hasher.write(s.as_bytes());
     }
 
-    let mut hash = hasher.result_str();
+    let mut hash_state = hasher.into_inner();
+    let hash_bytes = hash_state.finalize();
 
     // If this is an executable, add a special suffix, so that we don't get
     // symbol conflicts when linking against a library of the same name.
-    if session.crate_types.borrow().contains(&config::CrateTypeExecutable) {
-       hash.push_str("-exe");
-    }
+    let is_exe = session.crate_types.borrow().contains(&config::CrateTypeExecutable);
 
-    hash
+    format!("{:x}{}", FmtWrap(hash_bytes), if is_exe { "-exe" } else {""})
 }
 
 pub fn build_output_filenames(input: &Input,
diff --git a/src/librustc_driver/lib.rs b/src/librustc_driver/lib.rs
index f4cae91289885..cb78baa12a6ad 100644
--- a/src/librustc_driver/lib.rs
+++ b/src/librustc_driver/lib.rs
@@ -42,6 +42,7 @@ extern crate rustc;
 extern crate rustc_back;
 extern crate rustc_borrowck;
 extern crate rustc_const_eval;
+extern crate rustc_data_structures;
 extern crate rustc_errors as errors;
 extern crate rustc_passes;
 extern crate rustc_lint;
diff --git a/src/librustc_incremental/calculate_svh/hasher.rs b/src/librustc_incremental/calculate_svh/hasher.rs
index d92a8d375e0d3..49683a81227b1 100644
--- a/src/librustc_incremental/calculate_svh/hasher.rs
+++ b/src/librustc_incremental/calculate_svh/hasher.rs
@@ -8,21 +8,22 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-use std::hash::Hasher;
 use std::mem;
-use rustc_data_structures::blake2b;
+use rustc_data_structures::blake2b::Blake2bHasher;
+use rustc::ty::util::ArchIndependentHasher;
 use ich::Fingerprint;
 
 #[derive(Debug)]
 pub struct IchHasher {
-    state: blake2b::Blake2bCtx,
+    state: ArchIndependentHasher<Blake2bHasher>,
     bytes_hashed: u64,
 }
 
 impl IchHasher {
     pub fn new() -> IchHasher {
+        let hash_size = mem::size_of::<Fingerprint>();
         IchHasher {
-            state: blake2b::blake2b_new(mem::size_of::<Fingerprint>(), &[]),
+            state: ArchIndependentHasher::new(Blake2bHasher::new(hash_size, &[])),
             bytes_hashed: 0
         }
     }
@@ -33,40 +34,19 @@ impl IchHasher {
 
     pub fn finish(self) -> Fingerprint {
         let mut fingerprint = Fingerprint::zero();
-        blake2b::blake2b_final(self.state, &mut fingerprint.0);
+        fingerprint.0.copy_from_slice(self.state.into_inner().finalize());
         fingerprint
     }
 }
 
-impl Hasher for IchHasher {
+impl ::std::hash::Hasher for IchHasher {
     fn finish(&self) -> u64 {
         bug!("Use other finish() implementation to get the full 128-bit hash.");
     }
 
     #[inline]
     fn write(&mut self, bytes: &[u8]) {
-        blake2b::blake2b_update(&mut self.state, bytes);
+        self.state.write(bytes);
         self.bytes_hashed += bytes.len() as u64;
     }
-
-    #[inline]
-    fn write_u16(&mut self, i: u16) {
-        self.write(&unsafe { mem::transmute::<_, [u8; 2]>(i.to_le()) })
-    }
-
-    #[inline]
-    fn write_u32(&mut self, i: u32) {
-        self.write(&unsafe { mem::transmute::<_, [u8; 4]>(i.to_le()) })
-    }
-
-    #[inline]
-    fn write_u64(&mut self, i: u64) {
-        self.write(&unsafe { mem::transmute::<_, [u8; 8]>(i.to_le()) })
-    }
-
-    #[inline]
-    fn write_usize(&mut self, i: usize) {
-        // always hash as u64, so we don't depend on the size of `usize`
-        self.write_u64(i as u64);
-    }
 }
diff --git a/src/librustc_metadata/creader.rs b/src/librustc_metadata/creader.rs
index f4558a2871d19..e72ac8419941c 100644
--- a/src/librustc_metadata/creader.rs
+++ b/src/librustc_metadata/creader.rs
@@ -340,10 +340,10 @@ impl<'a> CrateLoader<'a> {
                     target: &self.sess.target.target,
                     triple: &self.sess.opts.target_triple,
                     root: root,
-                    rejected_via_hash: vec!(),
-                    rejected_via_triple: vec!(),
-                    rejected_via_kind: vec!(),
-                    rejected_via_version: vec!(),
+                    rejected_via_hash: vec![],
+                    rejected_via_triple: vec![],
+                    rejected_via_kind: vec![],
+                    rejected_via_version: vec![],
                     should_match_name: true,
                 };
                 match self.load(&mut locate_ctxt) {
@@ -481,10 +481,10 @@ impl<'a> CrateLoader<'a> {
             target: &self.sess.host,
             triple: config::host_triple(),
             root: &None,
-            rejected_via_hash: vec!(),
-            rejected_via_triple: vec!(),
-            rejected_via_kind: vec!(),
-            rejected_via_version: vec!(),
+            rejected_via_hash: vec![],
+            rejected_via_triple: vec![],
+            rejected_via_kind: vec![],
+            rejected_via_version: vec![],
             should_match_name: true,
         };
         let library = self.load(&mut locate_ctxt).or_else(|| {
diff --git a/src/librustc_plugin/registry.rs b/src/librustc_plugin/registry.rs
index 9c74a644c3d9d..88e248e2efa38 100644
--- a/src/librustc_plugin/registry.rs
+++ b/src/librustc_plugin/registry.rs
@@ -73,12 +73,12 @@ impl<'a> Registry<'a> {
             sess: sess,
             args_hidden: None,
             krate_span: krate_span,
-            syntax_exts: vec!(),
-            early_lint_passes: vec!(),
-            late_lint_passes: vec!(),
+            syntax_exts: vec![],
+            early_lint_passes: vec![],
+            late_lint_passes: vec![],
             lint_groups: HashMap::new(),
-            llvm_passes: vec!(),
-            attributes: vec!(),
+            llvm_passes: vec![],
+            attributes: vec![],
             mir_passes: Vec::new(),
         }
     }
diff --git a/src/librustc_save_analysis/dump_visitor.rs b/src/librustc_save_analysis/dump_visitor.rs
index 73d0e5e50c6c7..8a628289b7f94 100644
--- a/src/librustc_save_analysis/dump_visitor.rs
+++ b/src/librustc_save_analysis/dump_visitor.rs
@@ -153,7 +153,7 @@ impl<'l, 'tcx: 'l, 'll, D: Dump + 'll> DumpVisitor<'l, 'tcx, 'll, D> {
         // What could go wrong...?
         if spans.len() < path.segments.len() {
             if generated_code(path.span) {
-                return vec!();
+                return vec![];
             }
             error!("Mis-calculated spans for path '{}'. Found {} spans, expected {}. Found spans:",
                    path_to_string(path),
@@ -167,12 +167,12 @@ impl<'l, 'tcx: 'l, 'll, D: Dump + 'll> DumpVisitor<'l, 'tcx, 'll, D> {
                        loc.line);
             }
             error!("    master span: {:?}: `{}`", path.span, self.span.snippet(path.span));
-            return vec!();
+            return vec![];
         }
 
-        let mut result: Vec<(Span, String)> = vec!();
+        let mut result: Vec<(Span, String)> = vec![];
 
-        let mut segs = vec!();
+        let mut segs = vec![];
         for (i, (seg, span)) in path.segments.iter().zip(&spans).enumerate() {
             segs.push(seg.clone());
             let sub_path = ast::Path {
diff --git a/src/librustc_save_analysis/json_dumper.rs b/src/librustc_save_analysis/json_dumper.rs
index 0378d75cc6eb1..eb613c3afdab3 100644
--- a/src/librustc_save_analysis/json_dumper.rs
+++ b/src/librustc_save_analysis/json_dumper.rs
@@ -129,7 +129,7 @@ impl From<DefId> for Id {
 #[derive(Debug, RustcEncodable)]
 struct Import {
     kind: ImportKind,
-    id: Id,
+    ref_id: Option<Id>,
     span: SpanData,
     name: String,
     value: String,
@@ -146,7 +146,7 @@ impl From<ExternCrateData> for Import {
     fn from(data: ExternCrateData) -> Import {
         Import {
             kind: ImportKind::ExternCrate,
-            id: From::from(data.id),
+            ref_id: None,
             span: data.span,
             name: data.name,
             value: String::new(),
@@ -157,7 +157,7 @@ impl From<UseData> for Import {
     fn from(data: UseData) -> Import {
         Import {
             kind: ImportKind::Use,
-            id: From::from(data.id),
+            ref_id: data.mod_id.map(|id| From::from(id)),
             span: data.span,
             name: data.name,
             value: String::new(),
@@ -168,7 +168,7 @@ impl From<UseGlobData> for Import {
     fn from(data: UseGlobData) -> Import {
         Import {
             kind: ImportKind::GlobUse,
-            id: From::from(data.id),
+            ref_id: None,
             span: data.span,
             name: "*".to_owned(),
             value: data.names.join(", "),
diff --git a/src/librustc_save_analysis/span_utils.rs b/src/librustc_save_analysis/span_utils.rs
index 22c087aba80f1..031b9a6a5aa51 100644
--- a/src/librustc_save_analysis/span_utils.rs
+++ b/src/librustc_save_analysis/span_utils.rs
@@ -225,7 +225,7 @@ impl<'a> SpanUtils<'a> {
     // Nesting = 0: all idents outside of brackets: [Foo]
     // Nesting = 1: idents within one level of brackets: [Bar, Bar]
     pub fn spans_with_brackets(&self, span: Span, nesting: isize, limit: isize) -> Vec<Span> {
-        let mut result: Vec<Span> = vec!();
+        let mut result: Vec<Span> = vec![];
 
         let mut toks = self.retokenise_span(span);
         // We keep track of how many brackets we're nested in
@@ -236,7 +236,7 @@ impl<'a> SpanUtils<'a> {
             if ts.tok == token::Eof {
                 if bracket_count != 0 {
                     if generated_code(span) {
-                        return vec!();
+                        return vec![];
                     }
                     let loc = self.sess.codemap().lookup_char_pos(span.lo);
                     span_bug!(span,
diff --git a/src/librustc_trans/asm.rs b/src/librustc_trans/asm.rs
index 308118b1fbc6c..8c704cc32993c 100644
--- a/src/librustc_trans/asm.rs
+++ b/src/librustc_trans/asm.rs
@@ -61,7 +61,7 @@ pub fn trans_inline_asm<'blk, 'tcx>(bcx: Block<'blk, 'tcx>,
     // Default per-arch clobbers
     // Basically what clang does
     let arch_clobbers = match &bcx.sess().target.target.arch[..] {
-        "x86" | "x86_64" => vec!("~{dirflag}", "~{fpsr}", "~{flags}"),
+        "x86" | "x86_64" => vec!["~{dirflag}", "~{fpsr}", "~{flags}"],
         _                => Vec::new()
     };
 
diff --git a/src/librustc_trans/back/rpath.rs b/src/librustc_trans/back/rpath.rs
index 4ed860bd40d86..8758cdcf9d0ab 100644
--- a/src/librustc_trans/back/rpath.rs
+++ b/src/librustc_trans/back/rpath.rs
@@ -68,7 +68,7 @@ fn get_rpaths(config: &mut RPathConfig, libs: &[PathBuf]) -> Vec<String> {
     let rel_rpaths = get_rpaths_relative_to_output(config, libs);
 
     // And a final backup rpath to the global library location.
-    let fallback_rpaths = vec!(get_install_prefix_rpath(config));
+    let fallback_rpaths = vec![get_install_prefix_rpath(config)];
 
     fn log_rpaths(desc: &str, rpaths: &[String]) {
         debug!("{} rpaths:", desc);
diff --git a/src/librustc_trans/back/symbol_names.rs b/src/librustc_trans/back/symbol_names.rs
index f0661e03bc815..bf2a5d76c10d4 100644
--- a/src/librustc_trans/back/symbol_names.rs
+++ b/src/librustc_trans/back/symbol_names.rs
@@ -99,7 +99,8 @@
 
 use common::SharedCrateContext;
 use monomorphize::Instance;
-use util::sha2::{Digest, Sha256};
+use rustc_data_structures::fmt_wrap::FmtWrap;
+use rustc_data_structures::blake2b::Blake2bHasher;
 
 use rustc::middle::weak_lang_items;
 use rustc::hir::def_id::LOCAL_CRATE;
@@ -113,21 +114,6 @@ use rustc::util::common::record_time;
 
 use syntax::attr;
 use syntax::parse::token::{self, InternedString};
-use serialize::hex::ToHex;
-
-use std::hash::Hasher;
-
-struct Sha256Hasher<'a>(&'a mut Sha256);
-
-impl<'a> Hasher for Sha256Hasher<'a> {
-    fn write(&mut self, msg: &[u8]) {
-        self.0.input(msg)
-    }
-
-    fn finish(&self) -> u64 {
-        bug!("Sha256Hasher::finish should not be called");
-    }
-}
 
 fn get_symbol_hash<'a, 'tcx>(scx: &SharedCrateContext<'a, 'tcx>,
 
@@ -149,12 +135,9 @@ fn get_symbol_hash<'a, 'tcx>(scx: &SharedCrateContext<'a, 'tcx>,
 
     let tcx = scx.tcx();
 
-    let mut hash_state = scx.symbol_hasher().borrow_mut();
-    record_time(&tcx.sess.perf_stats.symbol_hash_time, || {
-        hash_state.reset();
-        let hasher = Sha256Hasher(&mut hash_state);
-        let mut hasher = ty::util::TypeIdHasher::new(tcx, hasher);
+    let mut hasher = ty::util::TypeIdHasher::new(tcx, Blake2bHasher::new(8, &[]));
 
+    record_time(&tcx.sess.perf_stats.symbol_hash_time, || {
         // the main symbol name is not necessarily unique; hash in the
         // compiler's internal def-path, guaranteeing each symbol has a
         // truly unique path
@@ -175,8 +158,9 @@ fn get_symbol_hash<'a, 'tcx>(scx: &SharedCrateContext<'a, 'tcx>,
     });
 
     // 64 bits should be enough to avoid collisions.
-    let output = hash_state.result_bytes();
-    format!("h{}", output[..8].to_hex())
+    let mut hasher = hasher.into_inner();
+    let hash_bytes = hasher.finalize();
+    format!("h{:x}", FmtWrap(hash_bytes))
 }
 
 impl<'a, 'tcx> Instance<'tcx> {
diff --git a/src/librustc_trans/back/write.rs b/src/librustc_trans/back/write.rs
index 04b814e2b9772..9012914deeb09 100644
--- a/src/librustc_trans/back/write.rs
+++ b/src/librustc_trans/back/write.rs
@@ -665,7 +665,7 @@ pub fn run_passes(sess: &Session,
     // Figure out what we actually need to build.
 
     let mut modules_config = ModuleConfig::new(tm, sess.opts.cg.passes.clone());
-    let mut metadata_config = ModuleConfig::new(tm, vec!());
+    let mut metadata_config = ModuleConfig::new(tm, vec![]);
 
     modules_config.opt_level = Some(get_llvm_opt_level(sess.opts.optimize));
     modules_config.opt_size = Some(get_llvm_opt_size(sess.opts.optimize));
diff --git a/src/librustc_trans/base.rs b/src/librustc_trans/base.rs
index 54dff8c8bb3cf..977ababbf5688 100644
--- a/src/librustc_trans/base.rs
+++ b/src/librustc_trans/base.rs
@@ -79,7 +79,6 @@ use type_::Type;
 use type_of;
 use value::Value;
 use Disr;
-use util::sha2::Sha256;
 use util::nodemap::{NodeSet, FnvHashMap, FnvHashSet};
 
 use arena::TypedArena;
@@ -1550,7 +1549,6 @@ pub fn trans_crate<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
 
     let shared_ccx = SharedCrateContext::new(tcx,
                                              export_map,
-                                             Sha256::new(),
                                              link_meta.clone(),
                                              reachable,
                                              check_overflow);
diff --git a/src/librustc_trans/cleanup.rs b/src/librustc_trans/cleanup.rs
index d368ce47430b7..b9f24eba9dc1e 100644
--- a/src/librustc_trans/cleanup.rs
+++ b/src/librustc_trans/cleanup.rs
@@ -305,7 +305,7 @@ impl<'blk, 'tcx> FunctionContext<'blk, 'tcx> {
         assert!(orig_scopes_len > 0);
 
         // Remove any scopes that do not have cleanups on panic:
-        let mut popped_scopes = vec!();
+        let mut popped_scopes = vec![];
         while !self.top_scope(|s| s.needs_invoke()) {
             debug!("top scope does not need invoke");
             popped_scopes.push(self.pop_scope());
@@ -402,7 +402,7 @@ impl<'blk, 'tcx> FunctionContext<'blk, 'tcx> {
 
         let orig_scopes_len = self.scopes_len();
         let mut prev_llbb;
-        let mut popped_scopes = vec!();
+        let mut popped_scopes = vec![];
         let mut skip = 0;
 
         // First we pop off all the cleanup stacks that are
@@ -585,8 +585,8 @@ impl<'tcx> CleanupScope<'tcx> {
     fn new(debug_loc: DebugLoc) -> CleanupScope<'tcx> {
         CleanupScope {
             debug_loc: debug_loc,
-            cleanups: vec!(),
-            cached_early_exits: vec!(),
+            cleanups: vec![],
+            cached_early_exits: vec![],
             cached_landing_pad: None,
         }
     }
diff --git a/src/librustc_trans/context.rs b/src/librustc_trans/context.rs
index 42773a8cd2c44..fc75b1018ec35 100644
--- a/src/librustc_trans/context.rs
+++ b/src/librustc_trans/context.rs
@@ -32,7 +32,6 @@ use session::config::NoDebugInfo;
 use session::Session;
 use session::config;
 use symbol_map::SymbolMap;
-use util::sha2::Sha256;
 use util::nodemap::{NodeSet, DefIdMap, FnvHashMap, FnvHashSet};
 
 use std::ffi::{CStr, CString};
@@ -69,7 +68,6 @@ pub struct SharedCrateContext<'a, 'tcx: 'a> {
     export_map: ExportMap,
     reachable: NodeSet,
     link_meta: LinkMeta,
-    symbol_hasher: RefCell<Sha256>,
     tcx: TyCtxt<'a, 'tcx, 'tcx>,
     stats: Stats,
     check_overflow: bool,
@@ -436,7 +434,6 @@ unsafe fn create_context_and_module(sess: &Session, mod_name: &str) -> (ContextR
 impl<'b, 'tcx> SharedCrateContext<'b, 'tcx> {
     pub fn new(tcx: TyCtxt<'b, 'tcx, 'tcx>,
                export_map: ExportMap,
-               symbol_hasher: Sha256,
                link_meta: LinkMeta,
                reachable: NodeSet,
                check_overflow: bool)
@@ -496,7 +493,6 @@ impl<'b, 'tcx> SharedCrateContext<'b, 'tcx> {
             export_map: export_map,
             reachable: reachable,
             link_meta: link_meta,
-            symbol_hasher: RefCell::new(symbol_hasher),
             tcx: tcx,
             stats: Stats {
                 n_glues_created: Cell::new(0),
@@ -575,10 +571,6 @@ impl<'b, 'tcx> SharedCrateContext<'b, 'tcx> {
         })
     }
 
-    pub fn symbol_hasher(&self) -> &RefCell<Sha256> {
-        &self.symbol_hasher
-    }
-
     pub fn metadata_symbol_name(&self) -> String {
         format!("rust_metadata_{}_{}",
                 self.link_meta().crate_name,
@@ -877,10 +869,6 @@ impl<'b, 'tcx> CrateContext<'b, 'tcx> {
         &self.local().llsizingtypes
     }
 
-    pub fn symbol_hasher<'a>(&'a self) -> &'a RefCell<Sha256> {
-        &self.shared.symbol_hasher
-    }
-
     pub fn type_hashcodes<'a>(&'a self) -> &'a RefCell<FnvHashMap<Ty<'tcx>, String>> {
         &self.local().type_hashcodes
     }
diff --git a/src/librustc_trans/debuginfo/metadata.rs b/src/librustc_trans/debuginfo/metadata.rs
index 2804e3ffe37dd..863aecc824433 100644
--- a/src/librustc_trans/debuginfo/metadata.rs
+++ b/src/librustc_trans/debuginfo/metadata.rs
@@ -30,7 +30,7 @@ use rustc::ty::fold::TypeVisitor;
 use rustc::ty::subst::Substs;
 use rustc::ty::util::TypeIdHasher;
 use rustc::hir;
-use rustc_data_structures::blake2b;
+use rustc_data_structures::blake2b::Blake2bHasher;
 use {type_of, machine, monomorphize};
 use common::CrateContext;
 use type_::Type;
@@ -149,10 +149,16 @@ impl<'tcx> TypeMap<'tcx> {
             None => { /* generate one */}
         };
 
+        // The hasher we are using to generate the UniqueTypeId. We want
+        // something that provides more than the 64 bits of the DefaultHasher.
+        const TYPE_ID_HASH_LENGTH: usize = 20;
+
         let mut type_id_hasher = TypeIdHasher::new(cx.tcx(),
-                                                   DebugInfoTypeIdHasher::new());
+                                                   Blake2bHasher::new(TYPE_ID_HASH_LENGTH, &[]));
         type_id_hasher.visit_ty(type_);
-        let hash = type_id_hasher.into_inner().into_hash();
+        let mut hash_state = type_id_hasher.into_inner();
+        let hash: &[u8] = hash_state.finalize();
+        debug_assert!(hash.len() == TYPE_ID_HASH_LENGTH);
 
         let mut unique_type_id = String::with_capacity(TYPE_ID_HASH_LENGTH * 2);
 
@@ -164,39 +170,6 @@ impl<'tcx> TypeMap<'tcx> {
         self.type_to_unique_id.insert(type_, UniqueTypeId(key));
 
         return UniqueTypeId(key);
-
-        // The hasher we are using to generate the UniqueTypeId. We want
-        // something that provides more than the 64 bits of the DefaultHasher.
-        const TYPE_ID_HASH_LENGTH: usize = 20;
-
-        struct DebugInfoTypeIdHasher {
-            state: blake2b::Blake2bCtx
-        }
-
-        impl ::std::hash::Hasher for DebugInfoTypeIdHasher {
-            fn finish(&self) -> u64 {
-                unimplemented!()
-            }
-
-            #[inline]
-            fn write(&mut self, bytes: &[u8]) {
-                blake2b::blake2b_update(&mut self.state, bytes);
-            }
-        }
-
-        impl DebugInfoTypeIdHasher {
-            fn new() -> DebugInfoTypeIdHasher {
-                DebugInfoTypeIdHasher {
-                    state: blake2b::blake2b_new(TYPE_ID_HASH_LENGTH, &[])
-                }
-            }
-
-            fn into_hash(self) -> [u8; TYPE_ID_HASH_LENGTH] {
-                let mut hash = [0u8; TYPE_ID_HASH_LENGTH];
-                blake2b::blake2b_final(self.state, &mut hash);
-                hash
-            }
-        }
     }
 
     // Get the UniqueTypeId for an enum variant. Enum variants are not really
diff --git a/src/librustc_trans/mir/block.rs b/src/librustc_trans/mir/block.rs
index 6d4b01b1d693d..8bf27b4babfc2 100644
--- a/src/librustc_trans/mir/block.rs
+++ b/src/librustc_trans/mir/block.rs
@@ -37,13 +37,14 @@ use super::analyze::CleanupKind;
 use super::constant::Const;
 use super::lvalue::{LvalueRef};
 use super::operand::OperandRef;
-use super::operand::OperandValue::*;
+use super::operand::OperandValue::{Pair, Ref, Immediate};
+
+use std::cell::Ref as CellRef;
 
 impl<'bcx, 'tcx> MirContext<'bcx, 'tcx> {
     pub fn trans_block(&mut self, bb: mir::BasicBlock) {
         let mut bcx = self.bcx(bb);
-        let mir = self.mir.clone();
-        let data = &mir[bb];
+        let data = &CellRef::clone(&self.mir)[bb];
 
         debug!("trans_block({:?}={:?})", bb, data);
 
@@ -228,7 +229,7 @@ impl<'bcx, 'tcx> MirContext<'bcx, 'tcx> {
             }
 
             mir::TerminatorKind::Drop { ref location, target, unwind } => {
-                let ty = location.ty(&mir, bcx.tcx()).to_ty(bcx.tcx());
+                let ty = location.ty(&self.mir, bcx.tcx()).to_ty(bcx.tcx());
                 let ty = bcx.monomorphize(&ty);
 
                 // Double check for necessity to drop
diff --git a/src/librustc_trans/monomorphize.rs b/src/librustc_trans/monomorphize.rs
index ab2a39864336f..270ce79620f8b 100644
--- a/src/librustc_trans/monomorphize.rs
+++ b/src/librustc_trans/monomorphize.rs
@@ -26,7 +26,7 @@ pub struct Instance<'tcx> {
 
 impl<'tcx> fmt::Display for Instance<'tcx> {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        ppaux::parameterized(f, &self.substs, self.def, ppaux::Ns::Value, &[])
+        ppaux::parameterized(f, &self.substs, self.def, &[])
     }
 }
 
diff --git a/src/librustc_typeck/check/intrinsic.rs b/src/librustc_typeck/check/intrinsic.rs
index cbe3893fbf67a..7d2547ec17f3a 100644
--- a/src/librustc_typeck/check/intrinsic.rs
+++ b/src/librustc_typeck/check/intrinsic.rs
@@ -86,18 +86,18 @@ pub fn check_intrinsic_type(ccx: &CrateCtxt, it: &hir::ForeignItem) {
 
         //We only care about the operation here
         let (n_tps, inputs, output) = match split[1] {
-            "cxchg" | "cxchgweak" => (1, vec!(tcx.mk_mut_ptr(param(ccx, 0)),
+            "cxchg" | "cxchgweak" => (1, vec![tcx.mk_mut_ptr(param(ccx, 0)),
                                               param(ccx, 0),
-                                              param(ccx, 0)),
+                                              param(ccx, 0)],
                                       tcx.intern_tup(&[param(ccx, 0), tcx.types.bool])),
-            "load" => (1, vec!(tcx.mk_imm_ptr(param(ccx, 0))),
+            "load" => (1, vec![tcx.mk_imm_ptr(param(ccx, 0))],
                        param(ccx, 0)),
-            "store" => (1, vec!(tcx.mk_mut_ptr(param(ccx, 0)), param(ccx, 0)),
+            "store" => (1, vec![tcx.mk_mut_ptr(param(ccx, 0)), param(ccx, 0)],
                         tcx.mk_nil()),
 
             "xchg" | "xadd" | "xsub" | "and"  | "nand" | "or" | "xor" | "max" |
             "min"  | "umax" | "umin" => {
-                (1, vec!(tcx.mk_mut_ptr(param(ccx, 0)), param(ccx, 0)),
+                (1, vec![tcx.mk_mut_ptr(param(ccx, 0)), param(ccx, 0)],
                  param(ccx, 0))
             }
             "fence" | "singlethreadfence" => {
@@ -129,14 +129,14 @@ pub fn check_intrinsic_type(ccx: &CrateCtxt, it: &hir::ForeignItem) {
             "rustc_peek" => (1, vec![param(ccx, 0)], param(ccx, 0)),
             "init" => (1, Vec::new(), param(ccx, 0)),
             "uninit" => (1, Vec::new(), param(ccx, 0)),
-            "forget" => (1, vec!( param(ccx, 0) ), tcx.mk_nil()),
-            "transmute" => (2, vec!( param(ccx, 0) ), param(ccx, 1)),
+            "forget" => (1, vec![ param(ccx, 0) ], tcx.mk_nil()),
+            "transmute" => (2, vec![ param(ccx, 0) ], param(ccx, 1)),
             "move_val_init" => {
                 (1,
-                 vec!(
+                 vec![
                     tcx.mk_mut_ptr(param(ccx, 0)),
                     param(ccx, 0)
-                  ),
+                  ],
                tcx.mk_nil())
             }
             "drop_in_place" => {
@@ -148,13 +148,13 @@ pub fn check_intrinsic_type(ccx: &CrateCtxt, it: &hir::ForeignItem) {
             "type_id" => (1, Vec::new(), ccx.tcx.types.u64),
             "offset" | "arith_offset" => {
               (1,
-               vec!(
+               vec![
                   tcx.mk_ptr(ty::TypeAndMut {
                       ty: param(ccx, 0),
                       mutbl: hir::MutImmutable
                   }),
                   ccx.tcx.types.isize
-               ),
+               ],
                tcx.mk_ptr(ty::TypeAndMut {
                    ty: param(ccx, 0),
                    mutbl: hir::MutImmutable
@@ -162,7 +162,7 @@ pub fn check_intrinsic_type(ccx: &CrateCtxt, it: &hir::ForeignItem) {
             }
             "copy" | "copy_nonoverlapping" => {
               (1,
-               vec!(
+               vec![
                   tcx.mk_ptr(ty::TypeAndMut {
                       ty: param(ccx, 0),
                       mutbl: hir::MutImmutable
@@ -172,12 +172,12 @@ pub fn check_intrinsic_type(ccx: &CrateCtxt, it: &hir::ForeignItem) {
                       mutbl: hir::MutMutable
                   }),
                   tcx.types.usize,
-               ),
+               ],
                tcx.mk_nil())
             }
             "volatile_copy_memory" | "volatile_copy_nonoverlapping_memory" => {
               (1,
-               vec!(
+               vec![
                   tcx.mk_ptr(ty::TypeAndMut {
                       ty: param(ccx, 0),
                       mutbl: hir::MutMutable
@@ -187,93 +187,93 @@ pub fn check_intrinsic_type(ccx: &CrateCtxt, it: &hir::ForeignItem) {
                       mutbl: hir::MutImmutable
                   }),
                   tcx.types.usize,
-               ),
+               ],
                tcx.mk_nil())
             }
             "write_bytes" | "volatile_set_memory" => {
               (1,
-               vec!(
+               vec![
                   tcx.mk_ptr(ty::TypeAndMut {
                       ty: param(ccx, 0),
                       mutbl: hir::MutMutable
                   }),
                   tcx.types.u8,
                   tcx.types.usize,
-               ),
+               ],
                tcx.mk_nil())
             }
-            "sqrtf32" => (0, vec!( tcx.types.f32 ), tcx.types.f32),
-            "sqrtf64" => (0, vec!( tcx.types.f64 ), tcx.types.f64),
+            "sqrtf32" => (0, vec![ tcx.types.f32 ], tcx.types.f32),
+            "sqrtf64" => (0, vec![ tcx.types.f64 ], tcx.types.f64),
             "powif32" => {
                (0,
-                vec!( tcx.types.f32, tcx.types.i32 ),
+                vec![ tcx.types.f32, tcx.types.i32 ],
                 tcx.types.f32)
             }
             "powif64" => {
                (0,
-                vec!( tcx.types.f64, tcx.types.i32 ),
+                vec![ tcx.types.f64, tcx.types.i32 ],
                 tcx.types.f64)
             }
-            "sinf32" => (0, vec!( tcx.types.f32 ), tcx.types.f32),
-            "sinf64" => (0, vec!( tcx.types.f64 ), tcx.types.f64),
-            "cosf32" => (0, vec!( tcx.types.f32 ), tcx.types.f32),
-            "cosf64" => (0, vec!( tcx.types.f64 ), tcx.types.f64),
+            "sinf32" => (0, vec![ tcx.types.f32 ], tcx.types.f32),
+            "sinf64" => (0, vec![ tcx.types.f64 ], tcx.types.f64),
+            "cosf32" => (0, vec![ tcx.types.f32 ], tcx.types.f32),
+            "cosf64" => (0, vec![ tcx.types.f64 ], tcx.types.f64),
             "powf32" => {
                (0,
-                vec!( tcx.types.f32, tcx.types.f32 ),
+                vec![ tcx.types.f32, tcx.types.f32 ],
                 tcx.types.f32)
             }
             "powf64" => {
                (0,
-                vec!( tcx.types.f64, tcx.types.f64 ),
+                vec![ tcx.types.f64, tcx.types.f64 ],
                 tcx.types.f64)
             }
-            "expf32"   => (0, vec!( tcx.types.f32 ), tcx.types.f32),
-            "expf64"   => (0, vec!( tcx.types.f64 ), tcx.types.f64),
-            "exp2f32"  => (0, vec!( tcx.types.f32 ), tcx.types.f32),
-            "exp2f64"  => (0, vec!( tcx.types.f64 ), tcx.types.f64),
-            "logf32"   => (0, vec!( tcx.types.f32 ), tcx.types.f32),
-            "logf64"   => (0, vec!( tcx.types.f64 ), tcx.types.f64),
-            "log10f32" => (0, vec!( tcx.types.f32 ), tcx.types.f32),
-            "log10f64" => (0, vec!( tcx.types.f64 ), tcx.types.f64),
-            "log2f32"  => (0, vec!( tcx.types.f32 ), tcx.types.f32),
-            "log2f64"  => (0, vec!( tcx.types.f64 ), tcx.types.f64),
+            "expf32"   => (0, vec![ tcx.types.f32 ], tcx.types.f32),
+            "expf64"   => (0, vec![ tcx.types.f64 ], tcx.types.f64),
+            "exp2f32"  => (0, vec![ tcx.types.f32 ], tcx.types.f32),
+            "exp2f64"  => (0, vec![ tcx.types.f64 ], tcx.types.f64),
+            "logf32"   => (0, vec![ tcx.types.f32 ], tcx.types.f32),
+            "logf64"   => (0, vec![ tcx.types.f64 ], tcx.types.f64),
+            "log10f32" => (0, vec![ tcx.types.f32 ], tcx.types.f32),
+            "log10f64" => (0, vec![ tcx.types.f64 ], tcx.types.f64),
+            "log2f32"  => (0, vec![ tcx.types.f32 ], tcx.types.f32),
+            "log2f64"  => (0, vec![ tcx.types.f64 ], tcx.types.f64),
             "fmaf32" => {
                 (0,
-                 vec!( tcx.types.f32, tcx.types.f32, tcx.types.f32 ),
+                 vec![ tcx.types.f32, tcx.types.f32, tcx.types.f32 ],
                  tcx.types.f32)
             }
             "fmaf64" => {
                 (0,
-                 vec!( tcx.types.f64, tcx.types.f64, tcx.types.f64 ),
+                 vec![ tcx.types.f64, tcx.types.f64, tcx.types.f64 ],
                  tcx.types.f64)
             }
-            "fabsf32"      => (0, vec!( tcx.types.f32 ), tcx.types.f32),
-            "fabsf64"      => (0, vec!( tcx.types.f64 ), tcx.types.f64),
-            "copysignf32"  => (0, vec!( tcx.types.f32, tcx.types.f32 ), tcx.types.f32),
-            "copysignf64"  => (0, vec!( tcx.types.f64, tcx.types.f64 ), tcx.types.f64),
-            "floorf32"     => (0, vec!( tcx.types.f32 ), tcx.types.f32),
-            "floorf64"     => (0, vec!( tcx.types.f64 ), tcx.types.f64),
-            "ceilf32"      => (0, vec!( tcx.types.f32 ), tcx.types.f32),
-            "ceilf64"      => (0, vec!( tcx.types.f64 ), tcx.types.f64),
-            "truncf32"     => (0, vec!( tcx.types.f32 ), tcx.types.f32),
-            "truncf64"     => (0, vec!( tcx.types.f64 ), tcx.types.f64),
-            "rintf32"      => (0, vec!( tcx.types.f32 ), tcx.types.f32),
-            "rintf64"      => (0, vec!( tcx.types.f64 ), tcx.types.f64),
-            "nearbyintf32" => (0, vec!( tcx.types.f32 ), tcx.types.f32),
-            "nearbyintf64" => (0, vec!( tcx.types.f64 ), tcx.types.f64),
-            "roundf32"     => (0, vec!( tcx.types.f32 ), tcx.types.f32),
-            "roundf64"     => (0, vec!( tcx.types.f64 ), tcx.types.f64),
+            "fabsf32"      => (0, vec![ tcx.types.f32 ], tcx.types.f32),
+            "fabsf64"      => (0, vec![ tcx.types.f64 ], tcx.types.f64),
+            "copysignf32"  => (0, vec![ tcx.types.f32, tcx.types.f32 ], tcx.types.f32),
+            "copysignf64"  => (0, vec![ tcx.types.f64, tcx.types.f64 ], tcx.types.f64),
+            "floorf32"     => (0, vec![ tcx.types.f32 ], tcx.types.f32),
+            "floorf64"     => (0, vec![ tcx.types.f64 ], tcx.types.f64),
+            "ceilf32"      => (0, vec![ tcx.types.f32 ], tcx.types.f32),
+            "ceilf64"      => (0, vec![ tcx.types.f64 ], tcx.types.f64),
+            "truncf32"     => (0, vec![ tcx.types.f32 ], tcx.types.f32),
+            "truncf64"     => (0, vec![ tcx.types.f64 ], tcx.types.f64),
+            "rintf32"      => (0, vec![ tcx.types.f32 ], tcx.types.f32),
+            "rintf64"      => (0, vec![ tcx.types.f64 ], tcx.types.f64),
+            "nearbyintf32" => (0, vec![ tcx.types.f32 ], tcx.types.f32),
+            "nearbyintf64" => (0, vec![ tcx.types.f64 ], tcx.types.f64),
+            "roundf32"     => (0, vec![ tcx.types.f32 ], tcx.types.f32),
+            "roundf64"     => (0, vec![ tcx.types.f64 ], tcx.types.f64),
 
             "volatile_load" =>
-                (1, vec!( tcx.mk_imm_ptr(param(ccx, 0)) ), param(ccx, 0)),
+                (1, vec![ tcx.mk_imm_ptr(param(ccx, 0)) ], param(ccx, 0)),
             "volatile_store" =>
-                (1, vec!( tcx.mk_mut_ptr(param(ccx, 0)), param(ccx, 0) ), tcx.mk_nil()),
+                (1, vec![ tcx.mk_mut_ptr(param(ccx, 0)), param(ccx, 0) ], tcx.mk_nil()),
 
-            "ctpop" | "ctlz" | "cttz" | "bswap" => (1, vec!(param(ccx, 0)), param(ccx, 0)),
+            "ctpop" | "ctlz" | "cttz" | "bswap" => (1, vec![param(ccx, 0)], param(ccx, 0)),
 
             "add_with_overflow" | "sub_with_overflow"  | "mul_with_overflow" =>
-                (1, vec!(param(ccx, 0), param(ccx, 0)),
+                (1, vec![param(ccx, 0), param(ccx, 0)],
                 tcx.intern_tup(&[param(ccx, 0), tcx.types.bool])),
 
             "unchecked_div" | "unchecked_rem" =>
diff --git a/src/librustc_typeck/collect.rs b/src/librustc_typeck/collect.rs
index 40b19b01cd901..202e176df0dbc 100644
--- a/src/librustc_typeck/collect.rs
+++ b/src/librustc_typeck/collect.rs
@@ -1387,7 +1387,7 @@ fn convert_trait_predicates<'a, 'tcx>(ccx: &CrateCtxt<'a, 'tcx>, it: &hir::Item)
             let bounds = match trait_item.node {
                 hir::TypeTraitItem(ref bounds, _) => bounds,
                 _ => {
-                    return vec!().into_iter();
+                    return vec![].into_iter();
                 }
             };
 
diff --git a/src/librustc_typeck/lib.rs b/src/librustc_typeck/lib.rs
index 7752690e534bc..c16dd788c4ec8 100644
--- a/src/librustc_typeck/lib.rs
+++ b/src/librustc_typeck/lib.rs
@@ -291,10 +291,10 @@ fn check_start_fn_ty(ccx: &CrateCtxt,
                 unsafety: hir::Unsafety::Normal,
                 abi: Abi::Rust,
                 sig: ty::Binder(ty::FnSig {
-                    inputs: vec!(
+                    inputs: vec![
                         tcx.types.isize,
                         tcx.mk_imm_ptr(tcx.mk_imm_ptr(tcx.types.u8))
-                    ),
+                    ],
                     output: tcx.types.isize,
                     variadic: false,
                 }),
diff --git a/src/librustdoc/core.rs b/src/librustdoc/core.rs
index 5ce7581000626..f03b6a5ab3f1f 100644
--- a/src/librustdoc/core.rs
+++ b/src/librustdoc/core.rs
@@ -143,8 +143,8 @@ pub fn run_core(search_paths: SearchPaths,
     let sessopts = config::Options {
         maybe_sysroot: maybe_sysroot,
         search_paths: search_paths,
-        crate_types: vec!(config::CrateTypeRlib),
-        lint_opts: vec!((warning_lint, lint::Allow)),
+        crate_types: vec![config::CrateTypeRlib],
+        lint_opts: vec![(warning_lint, lint::Allow)],
         lint_cap: Some(lint::Allow),
         externs: externs,
         target_triple: triple.unwrap_or(config::host_triple().to_string()),
diff --git a/src/librustdoc/html/markdown.rs b/src/librustdoc/html/markdown.rs
index f12349e5b7c6b..67cf12f4f4a6e 100644
--- a/src/librustdoc/html/markdown.rs
+++ b/src/librustdoc/html/markdown.rs
@@ -644,7 +644,7 @@ mod tests {
         t("test_harness",          false,        false,  false,  true,  true,  false, Vec::new());
         t("compile_fail",          false,        true,   false,  true,  false, true,  Vec::new());
         t("E0450",                 false,        false,  false,  true,  false, false,
-                                   vec!("E0450".to_owned()));
+                                   vec!["E0450".to_owned()]);
         t("{.no_run .example}",    false,        true,   false,  true,  false, false, Vec::new());
         t("{.sh .should_panic}",   true,         false,  false,  true,  false, false, Vec::new());
         t("{.example .rust}",      false,        false,  false,  true,  false, false, Vec::new());
diff --git a/src/librustdoc/html/render.rs b/src/librustdoc/html/render.rs
index 77a5ff3243a6c..a848a011f88db 100644
--- a/src/librustdoc/html/render.rs
+++ b/src/librustdoc/html/render.rs
@@ -1260,7 +1260,7 @@ impl Context {
         item.name = Some(krate.name);
 
         // render the crate documentation
-        let mut work = vec!((self, item));
+        let mut work = vec![(self, item)];
 
         while let Some((mut cx, item)) = work.pop() {
             cx.item(item, |cx, item| {
diff --git a/src/librustdoc/html/toc.rs b/src/librustdoc/html/toc.rs
index 305e6258baa41..a7da1c5cca48c 100644
--- a/src/librustdoc/html/toc.rs
+++ b/src/librustdoc/html/toc.rs
@@ -247,7 +247,7 @@ mod tests {
         macro_rules! toc {
             ($(($level: expr, $name: expr, $(($sub: tt))* )),*) => {
                 Toc {
-                    entries: vec!(
+                    entries: vec![
                         $(
                             TocEntry {
                                 level: $level,
@@ -257,7 +257,7 @@ mod tests {
                                 children: toc!($($sub),*)
                             }
                             ),*
-                        )
+                        ]
                 }
             }
         }
diff --git a/src/librustdoc/lib.rs b/src/librustdoc/lib.rs
index 0be36eb3a8508..cf5e8e5e34a3c 100644
--- a/src/librustdoc/lib.rs
+++ b/src/librustdoc/lib.rs
@@ -111,7 +111,7 @@ fn unstable(g: getopts::OptGroup) -> RustcOptGroup { RustcOptGroup::unstable(g)
 
 pub fn opts() -> Vec<RustcOptGroup> {
     use getopts::*;
-    vec!(
+    vec![
         stable(optflag("h", "help", "show this help message")),
         stable(optflag("V", "version", "print rustdoc's version")),
         stable(optflag("v", "verbose", "use verbose output")),
@@ -162,7 +162,7 @@ pub fn opts() -> Vec<RustcOptGroup> {
         unstable(optmulti("Z", "",
                           "internal and debugging options (only on nightly build)", "FLAG")),
         stable(optopt("", "sysroot", "Override the system root", "PATH")),
-    )
+    ]
 }
 
 pub fn usage(argv0: &str) {
diff --git a/src/librustdoc/test.rs b/src/librustdoc/test.rs
index 45c3d413500bf..1bbd67fb9be3a 100644
--- a/src/librustdoc/test.rs
+++ b/src/librustdoc/test.rs
@@ -66,7 +66,7 @@ pub fn run(input: &str,
         maybe_sysroot: Some(env::current_exe().unwrap().parent().unwrap()
                                               .parent().unwrap().to_path_buf()),
         search_paths: libs.clone(),
-        crate_types: vec!(config::CrateTypeDylib),
+        crate_types: vec![config::CrateTypeDylib],
         externs: externs.clone(),
         unstable_features: UnstableFeatures::from_environment(),
         ..config::basic_options().clone()
@@ -185,7 +185,7 @@ fn runtest(test: &str, cratename: &str, cfgs: Vec<String>, libs: SearchPaths,
         maybe_sysroot: Some(env::current_exe().unwrap().parent().unwrap()
                                               .parent().unwrap().to_path_buf()),
         search_paths: libs,
-        crate_types: vec!(config::CrateTypeExecutable),
+        crate_types: vec![config::CrateTypeExecutable],
         output_types: outputs,
         externs: externs,
         cg: config::CodegenOptions {
diff --git a/src/libserialize/json.rs b/src/libserialize/json.rs
index 3e976c9062830..239d32c8fc8dd 100644
--- a/src/libserialize/json.rs
+++ b/src/libserialize/json.rs
@@ -3880,8 +3880,8 @@ mod tests {
         use std::collections::{HashMap,BTreeMap};
         use super::ToJson;
 
-        let array2 = Array(vec!(U64(1), U64(2)));
-        let array3 = Array(vec!(U64(1), U64(2), U64(3)));
+        let array2 = Array(vec![U64(1), U64(2)]);
+        let array3 = Array(vec![U64(1), U64(2), U64(3)]);
         let object = {
             let mut tree_map = BTreeMap::new();
             tree_map.insert("a".to_string(), U64(1));
@@ -3915,7 +3915,7 @@ mod tests {
         assert_eq!([1_usize, 2_usize].to_json(), array2);
         assert_eq!((&[1_usize, 2_usize, 3_usize]).to_json(), array3);
         assert_eq!((vec![1_usize, 2_usize]).to_json(), array2);
-        assert_eq!(vec!(1_usize, 2_usize, 3_usize).to_json(), array3);
+        assert_eq!(vec![1_usize, 2_usize, 3_usize].to_json(), array3);
         let mut tree_map = BTreeMap::new();
         tree_map.insert("a".to_string(), 1 as usize);
         tree_map.insert("b".to_string(), 2);
diff --git a/src/libstd/io/cursor.rs b/src/libstd/io/cursor.rs
index ca9452ffe3eca..cb9e7bd327028 100644
--- a/src/libstd/io/cursor.rs
+++ b/src/libstd/io/cursor.rs
@@ -392,7 +392,7 @@ mod tests {
 
     #[test]
     fn test_mem_reader() {
-        let mut reader = Cursor::new(vec!(0, 1, 2, 3, 4, 5, 6, 7));
+        let mut reader = Cursor::new(vec![0, 1, 2, 3, 4, 5, 6, 7]);
         let mut buf = [];
         assert_eq!(reader.read(&mut buf).unwrap(), 0);
         assert_eq!(reader.position(), 0);
@@ -414,7 +414,7 @@ mod tests {
 
     #[test]
     fn test_boxed_slice_reader() {
-        let mut reader = Cursor::new(vec!(0, 1, 2, 3, 4, 5, 6, 7).into_boxed_slice());
+        let mut reader = Cursor::new(vec![0, 1, 2, 3, 4, 5, 6, 7].into_boxed_slice());
         let mut buf = [];
         assert_eq!(reader.read(&mut buf).unwrap(), 0);
         assert_eq!(reader.position(), 0);
@@ -436,7 +436,7 @@ mod tests {
 
     #[test]
     fn read_to_end() {
-        let mut reader = Cursor::new(vec!(0, 1, 2, 3, 4, 5, 6, 7));
+        let mut reader = Cursor::new(vec![0, 1, 2, 3, 4, 5, 6, 7]);
         let mut v = Vec::new();
         reader.read_to_end(&mut v).unwrap();
         assert_eq!(v, [0, 1, 2, 3, 4, 5, 6, 7]);
@@ -512,7 +512,7 @@ mod tests {
         assert_eq!(r.seek(SeekFrom::Start(10)).unwrap(), 10);
         assert_eq!(r.read(&mut [0]).unwrap(), 0);
 
-        let mut r = Cursor::new(vec!(10));
+        let mut r = Cursor::new(vec![10]);
         assert_eq!(r.seek(SeekFrom::Start(10)).unwrap(), 10);
         assert_eq!(r.read(&mut [0]).unwrap(), 0);
 
@@ -532,14 +532,14 @@ mod tests {
         let mut r = Cursor::new(&buf[..]);
         assert!(r.seek(SeekFrom::End(-2)).is_err());
 
-        let mut r = Cursor::new(vec!(10));
+        let mut r = Cursor::new(vec![10]);
         assert!(r.seek(SeekFrom::End(-2)).is_err());
 
         let mut buf = [0];
         let mut r = Cursor::new(&mut buf[..]);
         assert!(r.seek(SeekFrom::End(-2)).is_err());
 
-        let mut r = Cursor::new(vec!(10).into_boxed_slice());
+        let mut r = Cursor::new(vec![10].into_boxed_slice());
         assert!(r.seek(SeekFrom::End(-2)).is_err());
     }
 
diff --git a/src/libstd/rand/mod.rs b/src/libstd/rand/mod.rs
index 69cd37651d5c2..f48325218fb49 100644
--- a/src/libstd/rand/mod.rs
+++ b/src/libstd/rand/mod.rs
@@ -245,7 +245,7 @@ mod tests {
     #[cfg_attr(target_os = "emscripten", ignore)]
     fn test_os_rng_tasks() {
 
-        let mut txs = vec!();
+        let mut txs = vec![];
         for _ in 0..20 {
             let (tx, rx) = channel();
             txs.push(tx);
diff --git a/src/libsyntax/ast.rs b/src/libsyntax/ast.rs
index 8864694c932f3..f077ead1f8e07 100644
--- a/src/libsyntax/ast.rs
+++ b/src/libsyntax/ast.rs
@@ -161,12 +161,12 @@ impl Path {
         Path {
             span: s,
             global: false,
-            segments: vec!(
+            segments: vec![
                 PathSegment {
                     identifier: identifier,
                     parameters: PathParameters::none()
                 }
-            ),
+            ],
         }
     }
 }
diff --git a/src/libsyntax/ext/build.rs b/src/libsyntax/ext/build.rs
index 0ef47bd6daaa8..37bd83be7b4d4 100644
--- a/src/libsyntax/ext/build.rs
+++ b/src/libsyntax/ext/build.rs
@@ -312,7 +312,7 @@ impl<'a> AstBuilder for ExtCtxt<'a> {
         self.path_all(span, false, strs, Vec::new(), Vec::new(), Vec::new())
     }
     fn path_ident(&self, span: Span, id: ast::Ident) -> ast::Path {
-        self.path(span, vec!(id))
+        self.path(span, vec![id])
     }
     fn path_global(&self, span: Span, strs: Vec<ast::Ident> ) -> ast::Path {
         self.path_all(span, true, strs, Vec::new(), Vec::new(), Vec::new())
@@ -443,7 +443,7 @@ impl<'a> AstBuilder for ExtCtxt<'a> {
                           true,
                           self.std_path(&["option", "Option"]),
                           Vec::new(),
-                          vec!( ty ),
+                          vec![ ty ],
                           Vec::new()))
     }
 
@@ -477,7 +477,7 @@ impl<'a> AstBuilder for ExtCtxt<'a> {
     fn ty_vars_global(&self, ty_params: &P<[ast::TyParam]>) -> Vec<P<ast::Ty>> {
         ty_params
             .iter()
-            .map(|p| self.ty_path(self.path_global(DUMMY_SP, vec!(p.ident))))
+            .map(|p| self.ty_path(self.path_global(DUMMY_SP, vec![p.ident])))
             .collect()
     }
 
@@ -770,7 +770,7 @@ impl<'a> AstBuilder for ExtCtxt<'a> {
 
     fn expr_some(&self, sp: Span, expr: P<ast::Expr>) -> P<ast::Expr> {
         let some = self.std_path(&["option", "Option", "Some"]);
-        self.expr_call_global(sp, some, vec!(expr))
+        self.expr_call_global(sp, some, vec![expr])
     }
 
     fn expr_none(&self, sp: Span) -> P<ast::Expr> {
@@ -794,14 +794,14 @@ impl<'a> AstBuilder for ExtCtxt<'a> {
         let expr_file = self.expr_str(span,
                                       token::intern_and_get_ident(&loc.file.name));
         let expr_line = self.expr_u32(span, loc.line as u32);
-        let expr_file_line_tuple = self.expr_tuple(span, vec!(expr_file, expr_line));
+        let expr_file_line_tuple = self.expr_tuple(span, vec![expr_file, expr_line]);
         let expr_file_line_ptr = self.expr_addr_of(span, expr_file_line_tuple);
         self.expr_call_global(
             span,
             self.std_path(&["rt", "begin_panic"]),
-            vec!(
+            vec![
                 self.expr_str(span, msg),
-                expr_file_line_ptr))
+                expr_file_line_ptr])
     }
 
     fn expr_unreachable(&self, span: Span) -> P<ast::Expr> {
@@ -812,12 +812,12 @@ impl<'a> AstBuilder for ExtCtxt<'a> {
 
     fn expr_ok(&self, sp: Span, expr: P<ast::Expr>) -> P<ast::Expr> {
         let ok = self.std_path(&["result", "Result", "Ok"]);
-        self.expr_call_global(sp, ok, vec!(expr))
+        self.expr_call_global(sp, ok, vec![expr])
     }
 
     fn expr_err(&self, sp: Span, expr: P<ast::Expr>) -> P<ast::Expr> {
         let err = self.std_path(&["result", "Result", "Err"]);
-        self.expr_call_global(sp, err, vec!(expr))
+        self.expr_call_global(sp, err, vec![expr])
     }
 
     fn expr_try(&self, sp: Span, head: P<ast::Expr>) -> P<ast::Expr> {
@@ -836,17 +836,17 @@ impl<'a> AstBuilder for ExtCtxt<'a> {
         // Err(__try_var)  (pattern and expression resp.)
         let err_pat = self.pat_tuple_struct(sp, err_path.clone(), vec![binding_pat]);
         let err_inner_expr = self.expr_call(sp, self.expr_path(err_path),
-                                            vec!(binding_expr.clone()));
+                                            vec![binding_expr.clone()]);
         // return Err(__try_var)
         let err_expr = self.expr(sp, ast::ExprKind::Ret(Some(err_inner_expr)));
 
         // Ok(__try_var) => __try_var
-        let ok_arm = self.arm(sp, vec!(ok_pat), binding_expr);
+        let ok_arm = self.arm(sp, vec![ok_pat], binding_expr);
         // Err(__try_var) => return Err(__try_var)
-        let err_arm = self.arm(sp, vec!(err_pat), err_expr);
+        let err_arm = self.arm(sp, vec![err_pat], err_expr);
 
         // match head { Ok() => ..., Err() => ... }
-        self.expr_match(sp, head, vec!(ok_arm, err_arm))
+        self.expr_match(sp, head, vec![ok_arm, err_arm])
     }
 
 
@@ -912,7 +912,7 @@ impl<'a> AstBuilder for ExtCtxt<'a> {
 
     fn arm(&self, _span: Span, pats: Vec<P<ast::Pat>>, expr: P<ast::Expr>) -> ast::Arm {
         ast::Arm {
-            attrs: vec!(),
+            attrs: vec![],
             pats: pats,
             guard: None,
             body: expr
@@ -920,7 +920,7 @@ impl<'a> AstBuilder for ExtCtxt<'a> {
     }
 
     fn arm_unreachable(&self, span: Span) -> ast::Arm {
-        self.arm(span, vec!(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: P<ast::Expr>, arms: Vec<ast::Arm>) -> P<Expr> {
@@ -970,7 +970,7 @@ impl<'a> AstBuilder for ExtCtxt<'a> {
     }
 
     fn lambda1(&self, span: Span, blk: P<ast::Block>, ident: ast::Ident) -> P<ast::Expr> {
-        self.lambda(span, vec!(ident), blk)
+        self.lambda(span, vec![ident], blk)
     }
 
     fn lambda_expr(&self, span: Span, ids: Vec<ast::Ident>,
diff --git a/src/libsyntax/ext/quote.rs b/src/libsyntax/ext/quote.rs
index f3497c130bff4..f21360755bc26 100644
--- a/src/libsyntax/ext/quote.rs
+++ b/src/libsyntax/ext/quote.rs
@@ -46,7 +46,7 @@ pub mod rt {
 
     impl ToTokens for TokenTree {
         fn to_tokens(&self, _cx: &ExtCtxt) -> Vec<TokenTree> {
-            vec!(self.clone())
+            vec![self.clone()]
         }
     }
 
@@ -416,7 +416,7 @@ pub fn expand_quote_expr<'cx>(cx: &'cx mut ExtCtxt,
                               sp: Span,
                               tts: &[TokenTree])
                               -> Box<base::MacResult+'cx> {
-    let expanded = expand_parse_call(cx, sp, "parse_expr_panic", vec!(), tts);
+    let expanded = expand_parse_call(cx, sp, "parse_expr_panic", vec![], tts);
     base::MacEager::expr(expanded)
 }
 
@@ -424,7 +424,7 @@ pub fn expand_quote_item<'cx>(cx: &'cx mut ExtCtxt,
                               sp: Span,
                               tts: &[TokenTree])
                               -> Box<base::MacResult+'cx> {
-    let expanded = expand_parse_call(cx, sp, "parse_item_panic", vec!(), tts);
+    let expanded = expand_parse_call(cx, sp, "parse_item_panic", vec![], tts);
     base::MacEager::expr(expanded)
 }
 
@@ -432,7 +432,7 @@ pub fn expand_quote_pat<'cx>(cx: &'cx mut ExtCtxt,
                              sp: Span,
                              tts: &[TokenTree])
                              -> Box<base::MacResult+'cx> {
-    let expanded = expand_parse_call(cx, sp, "parse_pat_panic", vec!(), tts);
+    let expanded = expand_parse_call(cx, sp, "parse_pat_panic", vec![], tts);
     base::MacEager::expr(expanded)
 }
 
@@ -440,7 +440,7 @@ pub fn expand_quote_arm(cx: &mut ExtCtxt,
                         sp: Span,
                         tts: &[TokenTree])
                         -> Box<base::MacResult+'static> {
-    let expanded = expand_parse_call(cx, sp, "parse_arm_panic", vec!(), tts);
+    let expanded = expand_parse_call(cx, sp, "parse_arm_panic", vec![], tts);
     base::MacEager::expr(expanded)
 }
 
@@ -448,7 +448,7 @@ pub fn expand_quote_ty(cx: &mut ExtCtxt,
                        sp: Span,
                        tts: &[TokenTree])
                        -> Box<base::MacResult+'static> {
-    let expanded = expand_parse_call(cx, sp, "parse_ty_panic", vec!(), tts);
+    let expanded = expand_parse_call(cx, sp, "parse_ty_panic", vec![], tts);
     base::MacEager::expr(expanded)
 }
 
@@ -456,7 +456,7 @@ pub fn expand_quote_stmt(cx: &mut ExtCtxt,
                          sp: Span,
                          tts: &[TokenTree])
                          -> Box<base::MacResult+'static> {
-    let expanded = expand_parse_call(cx, sp, "parse_stmt_panic", vec!(), tts);
+    let expanded = expand_parse_call(cx, sp, "parse_stmt_panic", vec![], tts);
     base::MacEager::expr(expanded)
 }
 
@@ -465,7 +465,7 @@ pub fn expand_quote_attr(cx: &mut ExtCtxt,
                          tts: &[TokenTree])
                          -> Box<base::MacResult+'static> {
     let expanded = expand_parse_call(cx, sp, "parse_attribute_panic",
-                                    vec!(cx.expr_bool(sp, true)), tts);
+                                    vec![cx.expr_bool(sp, true)], tts);
 
     base::MacEager::expr(expanded)
 }
@@ -474,7 +474,7 @@ pub fn expand_quote_arg(cx: &mut ExtCtxt,
                         sp: Span,
                         tts: &[TokenTree])
                         -> Box<base::MacResult+'static> {
-    let expanded = expand_parse_call(cx, sp, "parse_arg_panic", vec!(), tts);
+    let expanded = expand_parse_call(cx, sp, "parse_arg_panic", vec![], tts);
     base::MacEager::expr(expanded)
 }
 
@@ -482,7 +482,7 @@ pub fn expand_quote_block(cx: &mut ExtCtxt,
                         sp: Span,
                         tts: &[TokenTree])
                         -> Box<base::MacResult+'static> {
-    let expanded = expand_parse_call(cx, sp, "parse_block_panic", vec!(), tts);
+    let expanded = expand_parse_call(cx, sp, "parse_block_panic", vec![], tts);
     base::MacEager::expr(expanded)
 }
 
@@ -490,7 +490,7 @@ pub fn expand_quote_meta_item(cx: &mut ExtCtxt,
                         sp: Span,
                         tts: &[TokenTree])
                         -> Box<base::MacResult+'static> {
-    let expanded = expand_parse_call(cx, sp, "parse_meta_item_panic", vec!(), tts);
+    let expanded = expand_parse_call(cx, sp, "parse_meta_item_panic", vec![], tts);
     base::MacEager::expr(expanded)
 }
 
@@ -499,7 +499,7 @@ pub fn expand_quote_path(cx: &mut ExtCtxt,
                         tts: &[TokenTree])
                         -> Box<base::MacResult+'static> {
     let mode = mk_parser_path(cx, sp, &["PathStyle", "Type"]);
-    let expanded = expand_parse_call(cx, sp, "parse_path_panic", vec!(mode), tts);
+    let expanded = expand_parse_call(cx, sp, "parse_path_panic", vec![mode], tts);
     base::MacEager::expr(expanded)
 }
 
@@ -531,7 +531,7 @@ fn mk_ident(cx: &ExtCtxt, sp: Span, ident: ast::Ident) -> P<ast::Expr> {
     cx.expr_method_call(sp,
                         cx.expr_ident(sp, id_ext("ext_cx")),
                         id_ext("ident_of"),
-                        vec!(e_str))
+                        vec![e_str])
 }
 
 // Lift a name to the expr that evaluates to that name
@@ -540,16 +540,16 @@ fn mk_name(cx: &ExtCtxt, sp: Span, ident: ast::Ident) -> P<ast::Expr> {
     cx.expr_method_call(sp,
                         cx.expr_ident(sp, id_ext("ext_cx")),
                         id_ext("name_of"),
-                        vec!(e_str))
+                        vec![e_str])
 }
 
 fn mk_tt_path(cx: &ExtCtxt, sp: Span, name: &str) -> P<ast::Expr> {
-    let idents = vec!(id_ext("syntax"), id_ext("tokenstream"), id_ext("TokenTree"), id_ext(name));
+    let idents = vec![id_ext("syntax"), id_ext("tokenstream"), id_ext("TokenTree"), id_ext(name)];
     cx.expr_path(cx.path_global(sp, idents))
 }
 
 fn mk_token_path(cx: &ExtCtxt, sp: Span, name: &str) -> P<ast::Expr> {
-    let idents = vec!(id_ext("syntax"), id_ext("parse"), id_ext("token"), id_ext(name));
+    let idents = vec![id_ext("syntax"), id_ext("parse"), id_ext("token"), id_ext(name)];
     cx.expr_path(cx.path_global(sp, idents))
 }
 
@@ -599,11 +599,11 @@ fn expr_mk_token(cx: &ExtCtxt, sp: Span, tok: &token::Token) -> P<ast::Expr> {
     }
     match *tok {
         token::BinOp(binop) => {
-            return cx.expr_call(sp, mk_token_path(cx, sp, "BinOp"), vec!(mk_binop(cx, sp, binop)));
+            return cx.expr_call(sp, mk_token_path(cx, sp, "BinOp"), vec![mk_binop(cx, sp, binop)]);
         }
         token::BinOpEq(binop) => {
             return cx.expr_call(sp, mk_token_path(cx, sp, "BinOpEq"),
-                                vec!(mk_binop(cx, sp, binop)));
+                                vec![mk_binop(cx, sp, binop)]);
         }
 
         token::OpenDelim(delim) => {
@@ -653,13 +653,13 @@ fn expr_mk_token(cx: &ExtCtxt, sp: Span, tok: &token::Token) -> P<ast::Expr> {
         token::Lifetime(ident) => {
             return cx.expr_call(sp,
                                 mk_token_path(cx, sp, "Lifetime"),
-                                vec!(mk_ident(cx, sp, ident)));
+                                vec![mk_ident(cx, sp, ident)]);
         }
 
         token::DocComment(ident) => {
             return cx.expr_call(sp,
                                 mk_token_path(cx, sp, "DocComment"),
-                                vec!(mk_name(cx, sp, ast::Ident::with_empty_ctxt(ident))));
+                                vec![mk_name(cx, sp, ast::Ident::with_empty_ctxt(ident))]);
         }
 
         token::MatchNt(name, kind) => {
@@ -714,7 +714,7 @@ fn statements_mk_tt(cx: &ExtCtxt, tt: &TokenTree, matcher: bool) -> Vec<ast::Stm
                 cx.expr_method_call(sp,
                                     cx.expr_ident(sp, ident),
                                     id_ext("to_tokens"),
-                                    vec!(cx.expr_ident(sp, id_ext("ext_cx"))));
+                                    vec![cx.expr_ident(sp, id_ext("ext_cx"))]);
             let e_to_toks =
                 cx.expr_method_call(sp, e_to_toks, id_ext("into_iter"), vec![]);
 
@@ -722,9 +722,9 @@ fn statements_mk_tt(cx: &ExtCtxt, tt: &TokenTree, matcher: bool) -> Vec<ast::Stm
                 cx.expr_method_call(sp,
                                     cx.expr_ident(sp, id_ext("tt")),
                                     id_ext("extend"),
-                                    vec!(e_to_toks));
+                                    vec![e_to_toks]);
 
-            vec!(cx.stmt_expr(e_push))
+            vec![cx.stmt_expr(e_push)]
         }
         ref tt @ TokenTree::Token(_, MatchNt(..)) if !matcher => {
             let mut seq = vec![];
@@ -737,13 +737,13 @@ fn statements_mk_tt(cx: &ExtCtxt, tt: &TokenTree, matcher: bool) -> Vec<ast::Stm
             let e_sp = cx.expr_ident(sp, id_ext("_sp"));
             let e_tok = cx.expr_call(sp,
                                      mk_tt_path(cx, sp, "Token"),
-                                     vec!(e_sp, expr_mk_token(cx, sp, tok)));
+                                     vec![e_sp, expr_mk_token(cx, sp, tok)]);
             let e_push =
                 cx.expr_method_call(sp,
                                     cx.expr_ident(sp, id_ext("tt")),
                                     id_ext("push"),
-                                    vec!(e_tok));
-            vec!(cx.stmt_expr(e_push))
+                                    vec![e_tok]);
+            vec![cx.stmt_expr(e_push)]
         },
         TokenTree::Delimited(_, ref delimed) => {
             statements_mk_tt(cx, &delimed.open_tt(), matcher).into_iter()
@@ -796,13 +796,13 @@ fn statements_mk_tt(cx: &ExtCtxt, tt: &TokenTree, matcher: bool) -> Vec<ast::Stm
                                                    vec![e_seq_struct]);
             let e_tok = cx.expr_call(sp,
                                      mk_tt_path(cx, sp, "Sequence"),
-                                     vec!(e_sp, e_rc_new));
+                                     vec![e_sp, e_rc_new]);
             let e_push =
                 cx.expr_method_call(sp,
                                     cx.expr_ident(sp, id_ext("tt")),
                                     id_ext("push"),
-                                    vec!(e_tok));
-            vec!(cx.stmt_expr(e_push))
+                                    vec![e_tok]);
+            vec![cx.stmt_expr(e_push)]
         }
     }
 }
@@ -867,7 +867,7 @@ fn mk_stmts_let(cx: &ExtCtxt, sp: Span) -> Vec<ast::Stmt> {
 
     let stmt_let_tt = cx.stmt_let(sp, true, id_ext("tt"), cx.expr_vec_ng(sp));
 
-    vec!(stmt_let_sp, stmt_let_tt)
+    vec![stmt_let_sp, stmt_let_tt]
 }
 
 fn statements_mk_tts(cx: &ExtCtxt, tts: &[TokenTree], matcher: bool) -> Vec<ast::Stmt> {
@@ -923,7 +923,7 @@ fn expand_parse_call(cx: &ExtCtxt,
     let new_parser_call =
         cx.expr_call(sp,
                      cx.expr_ident(sp, id_ext("new_parser_from_tts")),
-                     vec!(parse_sess_call(), tts_expr));
+                     vec![parse_sess_call(), tts_expr]);
 
     let path = vec![id_ext("syntax"), id_ext("ext"), id_ext("quote"), id_ext(parse_method)];
     let mut args = vec![cx.expr_mut_addr_of(sp, new_parser_call)];
diff --git a/src/libsyntax/parse/mod.rs b/src/libsyntax/parse/mod.rs
index 7b67c23e10231..12408c7d3c95b 100644
--- a/src/libsyntax/parse/mod.rs
+++ b/src/libsyntax/parse/mod.rs
@@ -624,12 +624,12 @@ mod tests {
                     node: ast::ExprKind::Path(None, ast::Path {
                         span: sp(0, 1),
                         global: false,
-                        segments: vec!(
+                        segments: vec![
                             ast::PathSegment {
                                 identifier: str_to_ident("a"),
                                 parameters: ast::PathParameters::none(),
                             }
-                        ),
+                        ],
                     }),
                     span: sp(0, 1),
                     attrs: ThinVec::new(),
@@ -643,7 +643,7 @@ mod tests {
                     node: ast::ExprKind::Path(None, ast::Path {
                             span: sp(0, 6),
                             global: true,
-                            segments: vec!(
+                            segments: vec![
                                 ast::PathSegment {
                                     identifier: str_to_ident("a"),
                                     parameters: ast::PathParameters::none(),
@@ -652,7 +652,7 @@ mod tests {
                                     identifier: str_to_ident("b"),
                                     parameters: ast::PathParameters::none(),
                                 }
-                            )
+                            ]
                         }),
                     span: sp(0, 6),
                     attrs: ThinVec::new(),
@@ -763,12 +763,12 @@ mod tests {
                         node:ast::ExprKind::Path(None, ast::Path{
                             span: sp(7, 8),
                             global: false,
-                            segments: vec!(
+                            segments: vec![
                                 ast::PathSegment {
                                     identifier: str_to_ident("d"),
                                     parameters: ast::PathParameters::none(),
                                 }
-                            ),
+                            ],
                         }),
                         span:sp(7,8),
                         attrs: ThinVec::new(),
@@ -786,12 +786,12 @@ mod tests {
                            node: ast::ExprKind::Path(None, ast::Path {
                                span:sp(0,1),
                                global:false,
-                               segments: vec!(
+                               segments: vec![
                                 ast::PathSegment {
                                     identifier: str_to_ident("b"),
                                     parameters: ast::PathParameters::none(),
                                 }
-                               ),
+                               ],
                             }),
                            span: sp(0,1),
                            attrs: ThinVec::new()})),
@@ -828,18 +828,18 @@ mod tests {
                             attrs:Vec::new(),
                             id: ast::DUMMY_NODE_ID,
                             node: ast::ItemKind::Fn(P(ast::FnDecl {
-                                inputs: vec!(ast::Arg{
+                                inputs: vec![ast::Arg{
                                     ty: P(ast::Ty{id: ast::DUMMY_NODE_ID,
                                                   node: ast::TyKind::Path(None, ast::Path{
                                         span:sp(10,13),
                                         global:false,
-                                        segments: vec!(
+                                        segments: vec![
                                             ast::PathSegment {
                                                 identifier:
                                                     str_to_ident("i32"),
                                                 parameters: ast::PathParameters::none(),
                                             }
-                                        ),
+                                        ],
                                         }),
                                         span:sp(10,13)
                                     }),
@@ -855,7 +855,7 @@ mod tests {
                                             span: sp(6,7)
                                     }),
                                         id: ast::DUMMY_NODE_ID
-                                    }),
+                                    }],
                                 output: ast::FunctionRetTy::Default(sp(15, 15)),
                                 variadic: false
                             }),
@@ -875,14 +875,14 @@ mod tests {
                                         span: syntax_pos::DUMMY_SP,
                                     },
                                     P(ast::Block {
-                                        stmts: vec!(ast::Stmt {
+                                        stmts: vec![ast::Stmt {
                                             node: ast::StmtKind::Semi(P(ast::Expr{
                                                 id: ast::DUMMY_NODE_ID,
                                                 node: ast::ExprKind::Path(None,
                                                       ast::Path{
                                                         span:sp(17,18),
                                                         global:false,
-                                                        segments: vec!(
+                                                        segments: vec![
                                                             ast::PathSegment {
                                                                 identifier:
                                                                 str_to_ident(
@@ -890,12 +890,12 @@ mod tests {
                                                                 parameters:
                                                                 ast::PathParameters::none(),
                                                             }
-                                                        ),
+                                                        ],
                                                       }),
                                                 span: sp(17,18),
                                                 attrs: ThinVec::new()})),
                                             id: ast::DUMMY_NODE_ID,
-                                            span: sp(17,19)}),
+                                            span: sp(17,19)}],
                                         id: ast::DUMMY_NODE_ID,
                                         rules: ast::BlockCheckMode::Default, // no idea
                                         span: sp(15,21),
diff --git a/src/libsyntax/parse/parser.rs b/src/libsyntax/parse/parser.rs
index a75937759a2a5..b80aa667be6a1 100644
--- a/src/libsyntax/parse/parser.rs
+++ b/src/libsyntax/parse/parser.rs
@@ -848,7 +848,7 @@ impl<'a> Parser<'a> {
               Fe: FnMut(DiagnosticBuilder)
     {
         let mut first: bool = true;
-        let mut v = vec!();
+        let mut v = vec![];
         while !kets.contains(&&self.token) {
             match sep.sep {
                 Some(ref t) => {
@@ -2224,13 +2224,13 @@ impl<'a> Parser<'a> {
                             SeqSep::trailing_allowed(token::Comma),
                             |p| Ok(p.parse_expr()?)
                         )?;
-                        let mut exprs = vec!(first_expr);
+                        let mut exprs = vec![first_expr];
                         exprs.extend(remaining_exprs);
                         ex = ExprKind::Vec(exprs);
                     } else {
                         // Vector with one element.
                         self.expect(&token::CloseDelim(token::Bracket))?;
-                        ex = ExprKind::Vec(vec!(first_expr));
+                        ex = ExprKind::Vec(vec![first_expr]);
                     }
                 }
                 hi = self.prev_span.hi;
@@ -4224,7 +4224,7 @@ impl<'a> Parser<'a> {
                              mode: BoundParsingMode)
                              -> PResult<'a, TyParamBounds>
     {
-        let mut result = vec!();
+        let mut result = vec![];
         loop {
             let question_span = self.span;
             let ate_question = self.eat(&token::Question);
diff --git a/src/libsyntax/print/pprust.rs b/src/libsyntax/print/pprust.rs
index 149112133b234..b0bd644674300 100644
--- a/src/libsyntax/print/pprust.rs
+++ b/src/libsyntax/print/pprust.rs
@@ -2277,7 +2277,7 @@ impl<'a> State<'a> {
                     Ok(())
                 }));
 
-                let mut options = vec!();
+                let mut options = vec![];
                 if a.volatile {
                     options.push("volatile");
                 }
diff --git a/src/libsyntax/test.rs b/src/libsyntax/test.rs
index fdc1f45623d9c..618878c1f7980 100644
--- a/src/libsyntax/test.rs
+++ b/src/libsyntax/test.rs
@@ -430,7 +430,7 @@ fn mk_std(cx: &TestCtxt) -> P<ast::Item> {
     let (vi, vis, ident) = if cx.is_test_crate {
         (ast::ItemKind::Use(
             P(nospan(ast::ViewPathSimple(id_test,
-                                         path_node(vec!(id_test)))))),
+                                         path_node(vec![id_test]))))),
          ast::Visibility::Public, keywords::Invalid.ident())
     } else {
         (ast::ItemKind::ExternCrate(None), ast::Visibility::Inherited, id_test)
diff --git a/src/libsyntax/util/small_vector.rs b/src/libsyntax/util/small_vector.rs
index 57258c76335a1..9be7dbd68174e 100644
--- a/src/libsyntax/util/small_vector.rs
+++ b/src/libsyntax/util/small_vector.rs
@@ -105,7 +105,7 @@ impl<T> SmallVector<T> {
             One(..) => {
                 let one = mem::replace(&mut self.repr, Zero);
                 match one {
-                    One(v1) => mem::replace(&mut self.repr, Many(vec!(v1, v))),
+                    One(v1) => mem::replace(&mut self.repr, Many(vec![v1, v])),
                     _ => unreachable!()
                 };
             }
@@ -314,12 +314,12 @@ mod tests {
     #[test]
     #[should_panic]
     fn test_expect_one_many() {
-        SmallVector::many(vec!(1, 2)).expect_one("");
+        SmallVector::many(vec![1, 2]).expect_one("");
     }
 
     #[test]
     fn test_expect_one_one() {
         assert_eq!(1, SmallVector::one(1).expect_one(""));
-        assert_eq!(1, SmallVector::many(vec!(1)).expect_one(""));
+        assert_eq!(1, SmallVector::many(vec![1]).expect_one(""));
     }
 }
diff --git a/src/libsyntax_ext/deriving/cmp/partial_eq.rs b/src/libsyntax_ext/deriving/cmp/partial_eq.rs
index 64b8829dad7b1..c46d4b34173f6 100644
--- a/src/libsyntax_ext/deriving/cmp/partial_eq.rs
+++ b/src/libsyntax_ext/deriving/cmp/partial_eq.rs
@@ -65,12 +65,12 @@ pub fn expand_deriving_partial_eq(cx: &mut ExtCtxt,
     macro_rules! md {
         ($name:expr, $f:ident) => { {
             let inline = cx.meta_word(span, InternedString::new("inline"));
-            let attrs = vec!(cx.attribute(span, inline));
+            let attrs = vec![cx.attribute(span, inline)];
             MethodDef {
                 name: $name,
                 generics: LifetimeBounds::empty(),
                 explicit_self: borrowed_explicit_self(),
-                args: vec!(borrowed_self()),
+                args: vec![borrowed_self()],
                 ret_ty: Literal(path_local!(bool)),
                 attributes: attrs,
                 is_unsafe: false,
diff --git a/src/libsyntax_ext/deriving/cmp/partial_ord.rs b/src/libsyntax_ext/deriving/cmp/partial_ord.rs
index 99d60c43c5457..597ff306b3dd8 100644
--- a/src/libsyntax_ext/deriving/cmp/partial_ord.rs
+++ b/src/libsyntax_ext/deriving/cmp/partial_ord.rs
@@ -28,12 +28,12 @@ pub fn expand_deriving_partial_ord(cx: &mut ExtCtxt,
     macro_rules! md {
         ($name:expr, $op:expr, $equal:expr) => { {
             let inline = cx.meta_word(span, InternedString::new("inline"));
-            let attrs = vec!(cx.attribute(span, inline));
+            let attrs = vec![cx.attribute(span, inline)];
             MethodDef {
                 name: $name,
                 generics: LifetimeBounds::empty(),
                 explicit_self: borrowed_explicit_self(),
-                args: vec!(borrowed_self()),
+                args: vec![borrowed_self()],
                 ret_ty: Literal(path_local!(bool)),
                 attributes: attrs,
                 is_unsafe: false,
diff --git a/src/libsyntax_ext/deriving/decodable.rs b/src/libsyntax_ext/deriving/decodable.rs
index 22b9eb8e75445..10db56d46f6df 100644
--- a/src/libsyntax_ext/deriving/decodable.rs
+++ b/src/libsyntax_ext/deriving/decodable.rs
@@ -79,9 +79,9 @@ fn expand_deriving_decodable_imp(cx: &mut ExtCtxt,
                           ret_ty:
                               Literal(Path::new_(pathvec_std!(cx, core::result::Result),
                                                  None,
-                                                 vec!(Box::new(Self_), Box::new(Literal(Path::new_(
+                                                 vec![Box::new(Self_), Box::new(Literal(Path::new_(
                         vec![typaram, "Error"], None, vec![], false
-                    )))),
+                    )))],
                                                  true)),
                           attributes: Vec::new(),
                           is_unsafe: false,
diff --git a/src/libsyntax_ext/deriving/encodable.rs b/src/libsyntax_ext/deriving/encodable.rs
index a4074184b6e81..640296d7f06fc 100644
--- a/src/libsyntax_ext/deriving/encodable.rs
+++ b/src/libsyntax_ext/deriving/encodable.rs
@@ -139,23 +139,23 @@ fn expand_deriving_encodable_imp(cx: &mut ExtCtxt,
         generics: LifetimeBounds::empty(),
         is_unsafe: false,
         supports_unions: false,
-        methods: vec!(
+        methods: vec![
             MethodDef {
                 name: "encode",
                 generics: LifetimeBounds {
                     lifetimes: Vec::new(),
                     bounds: vec![(typaram,
-                                  vec![Path::new_(vec![krate, "Encoder"], None, vec!(), true)])]
+                                  vec![Path::new_(vec![krate, "Encoder"], None, vec![], true)])]
                 },
                 explicit_self: borrowed_explicit_self(),
-                args: vec!(Ptr(Box::new(Literal(Path::new_local(typaram))),
-                           Borrowed(None, Mutability::Mutable))),
+                args: vec![Ptr(Box::new(Literal(Path::new_local(typaram))),
+                           Borrowed(None, Mutability::Mutable))],
                 ret_ty: Literal(Path::new_(
                     pathvec_std!(cx, core::result::Result),
                     None,
-                    vec!(Box::new(Tuple(Vec::new())), Box::new(Literal(Path::new_(
+                    vec![Box::new(Tuple(Vec::new())), Box::new(Literal(Path::new_(
                         vec![typaram, "Error"], None, vec![], false
-                    )))),
+                    )))],
                     true
                 )),
                 attributes: Vec::new(),
@@ -165,7 +165,7 @@ fn expand_deriving_encodable_imp(cx: &mut ExtCtxt,
                     encodable_substructure(a, b, c, krate)
                 })),
             }
-        ),
+        ],
         associated_types: Vec::new(),
     };
 
diff --git a/src/libsyntax_ext/deriving/mod.rs b/src/libsyntax_ext/deriving/mod.rs
index 67747173353da..c2bfead568612 100644
--- a/src/libsyntax_ext/deriving/mod.rs
+++ b/src/libsyntax_ext/deriving/mod.rs
@@ -28,7 +28,7 @@ macro_rules! pathvec {
 
 macro_rules! path {
     ($($x:tt)*) => (
-        ::ext::deriving::generic::ty::Path::new( pathvec!( $($x)* ) )
+        ::ext::deriving::generic::ty::Path::new( pathvec![ $($x)* ] )
     )
 }
 
@@ -40,7 +40,7 @@ macro_rules! path_local {
 
 macro_rules! pathvec_std {
     ($cx:expr, $first:ident :: $($rest:ident)::+) => ({
-        let mut v = pathvec!($($rest)::+);
+        let mut v = pathvec![$($rest)::+];
         if let Some(s) = $cx.crate_root {
             v.insert(0, s);
         }
diff --git a/src/libtest/lib.rs b/src/libtest/lib.rs
index 8b0fd1ca0cbfa..95ae6eb2efe8e 100644
--- a/src/libtest/lib.rs
+++ b/src/libtest/lib.rs
@@ -336,7 +336,7 @@ pub type OptRes = Result<TestOpts, String>;
 
 #[cfg_attr(rustfmt, rustfmt_skip)]
 fn optgroups() -> Vec<getopts::OptGroup> {
-    vec!(getopts::optflag("", "ignored", "Run ignored tests"),
+    vec![getopts::optflag("", "ignored", "Run ignored tests"),
       getopts::optflag("", "test", "Run tests and not benchmarks"),
       getopts::optflag("", "bench", "Run benchmarks instead of tests"),
       getopts::optflag("h", "help", "Display this message (longer with --help)"),
@@ -352,7 +352,7 @@ fn optgroups() -> Vec<getopts::OptGroup> {
       getopts::optopt("", "color", "Configure coloring of output:
             auto   = colorize if stdout is a tty and tests are run on serially (default);
             always = always colorize output;
-            never  = never colorize output;", "auto|always|never"))
+            never  = never colorize output;", "auto|always|never")]
 }
 
 fn usage(binary: &str) {
diff --git a/src/test/compile-fail/E0297.rs b/src/test/compile-fail/E0297.rs
index 32c129b22a166..5792ba06eb0ce 100644
--- a/src/test/compile-fail/E0297.rs
+++ b/src/test/compile-fail/E0297.rs
@@ -9,7 +9,7 @@
 // except according to those terms.
 
 fn main() {
-    let xs : Vec<Option<i32>> = vec!(Some(1), None);
+    let xs : Vec<Option<i32>> = vec![Some(1), None];
 
     for Some(x) in xs {}
     //~^ ERROR E0297
diff --git a/src/test/compile-fail/auto-ref-slice-plus-ref.rs b/src/test/compile-fail/auto-ref-slice-plus-ref.rs
index f0f0bdfb38ee3..324e925964779 100644
--- a/src/test/compile-fail/auto-ref-slice-plus-ref.rs
+++ b/src/test/compile-fail/auto-ref-slice-plus-ref.rs
@@ -14,7 +14,7 @@ fn main() {
     // Testing that method lookup does not automatically borrow
     // vectors to slices then automatically create a self reference.
 
-    let mut a = vec!(0);
+    let mut a = vec![0];
     a.test_mut(); //~ ERROR no method named `test_mut` found
     a.test(); //~ ERROR no method named `test` found
 
diff --git a/src/test/compile-fail/borrowck/borrowck-assign-comp-idx.rs b/src/test/compile-fail/borrowck/borrowck-assign-comp-idx.rs
index b18df7f3db608..1e665a12a195b 100644
--- a/src/test/compile-fail/borrowck/borrowck-assign-comp-idx.rs
+++ b/src/test/compile-fail/borrowck/borrowck-assign-comp-idx.rs
@@ -14,7 +14,7 @@ struct Point {
 }
 
 fn a() {
-    let mut p = vec!(1);
+    let mut p = vec![1];
 
     // Create an immutable pointer into p's contents:
     let q: &isize = &p[0];
@@ -30,7 +30,7 @@ fn b() {
     // here we alias the mutable vector into an imm slice and try to
     // modify the original:
 
-    let mut p = vec!(1);
+    let mut p = vec![1];
 
     borrow(
         &p,
@@ -40,7 +40,7 @@ fn b() {
 fn c() {
     // Legal because the scope of the borrow does not include the
     // modification:
-    let mut p = vec!(1);
+    let mut p = vec![1];
     borrow(&p, ||{});
     p[0] = 5;
 }
diff --git a/src/test/compile-fail/borrowck/borrowck-borrowed-uniq-rvalue-2.rs b/src/test/compile-fail/borrowck/borrowck-borrowed-uniq-rvalue-2.rs
index 7b811f581c1a7..9178aadeeebe1 100644
--- a/src/test/compile-fail/borrowck/borrowck-borrowed-uniq-rvalue-2.rs
+++ b/src/test/compile-fail/borrowck/borrowck-borrowed-uniq-rvalue-2.rs
@@ -29,6 +29,6 @@ fn defer<'r>(x: &'r [&'r str]) -> defer<'r> {
 }
 
 fn main() {
-    let x = defer(&vec!("Goodbye", "world!"));
+    let x = defer(&vec!["Goodbye", "world!"]);
     x.x[0];
 }
diff --git a/src/test/compile-fail/borrowck/borrowck-loan-vec-content.rs b/src/test/compile-fail/borrowck/borrowck-loan-vec-content.rs
index 21d9dea77b26a..c5de95f8fc042 100644
--- a/src/test/compile-fail/borrowck/borrowck-loan-vec-content.rs
+++ b/src/test/compile-fail/borrowck/borrowck-loan-vec-content.rs
@@ -17,12 +17,12 @@ fn takes_imm_elt<F>(_v: &isize, f: F) where F: FnOnce() {
 }
 
 fn has_mut_vec_and_does_not_try_to_change_it() {
-    let mut v: Vec<isize> = vec!(1, 2, 3);
+    let mut v: Vec<isize> = vec![1, 2, 3];
     takes_imm_elt(&v[0], || {})
 }
 
 fn has_mut_vec_but_tries_to_change_it() {
-    let mut v: Vec<isize> = vec!(1, 2, 3);
+    let mut v: Vec<isize> = vec![1, 2, 3];
     takes_imm_elt(
         &v[0],
         || { //~ ERROR cannot borrow `v` as mutable
diff --git a/src/test/compile-fail/borrowck/borrowck-move-out-of-overloaded-auto-deref.rs b/src/test/compile-fail/borrowck/borrowck-move-out-of-overloaded-auto-deref.rs
index 27cef1f3c6068..bf4c74741368c 100644
--- a/src/test/compile-fail/borrowck/borrowck-move-out-of-overloaded-auto-deref.rs
+++ b/src/test/compile-fail/borrowck/borrowck-move-out-of-overloaded-auto-deref.rs
@@ -11,6 +11,6 @@
 use std::rc::Rc;
 
 pub fn main() {
-    let _x = Rc::new(vec!(1, 2)).into_iter();
+    let _x = Rc::new(vec![1, 2]).into_iter();
     //~^ ERROR cannot move out of borrowed content
 }
diff --git a/src/test/compile-fail/borrowck/borrowck-move-out-of-vec-tail.rs b/src/test/compile-fail/borrowck/borrowck-move-out-of-vec-tail.rs
index 51e00a0ad2c3a..311208f07b88d 100644
--- a/src/test/compile-fail/borrowck/borrowck-move-out-of-vec-tail.rs
+++ b/src/test/compile-fail/borrowck/borrowck-move-out-of-vec-tail.rs
@@ -18,11 +18,11 @@ struct Foo {
 }
 
 pub fn main() {
-    let x = vec!(
+    let x = vec![
         Foo { string: "foo".to_string() },
         Foo { string: "bar".to_string() },
         Foo { string: "baz".to_string() }
-    );
+    ];
     let x: &[Foo] = &x;
     match *x {
         [_, ref tail..] => {
diff --git a/src/test/compile-fail/borrowck/borrowck-mut-slice-of-imm-vec.rs b/src/test/compile-fail/borrowck/borrowck-mut-slice-of-imm-vec.rs
index 9341758afd82e..4e0304e20c00d 100644
--- a/src/test/compile-fail/borrowck/borrowck-mut-slice-of-imm-vec.rs
+++ b/src/test/compile-fail/borrowck/borrowck-mut-slice-of-imm-vec.rs
@@ -13,6 +13,6 @@ fn write(v: &mut [isize]) {
 }
 
 fn main() {
-    let v = vec!(1, 2, 3);
+    let v = vec![1, 2, 3];
     write(&mut v); //~ ERROR cannot borrow
 }
diff --git a/src/test/compile-fail/borrowck/borrowck-overloaded-index-move-from-vec.rs b/src/test/compile-fail/borrowck/borrowck-overloaded-index-move-from-vec.rs
index 1b62d9c326d77..df72c2b0af72a 100644
--- a/src/test/compile-fail/borrowck/borrowck-overloaded-index-move-from-vec.rs
+++ b/src/test/compile-fail/borrowck/borrowck-overloaded-index-move-from-vec.rs
@@ -25,7 +25,7 @@ impl<T> Index<usize> for MyVec<T> {
 }
 
 fn main() {
-    let v = MyVec::<Box<_>> { data: vec!(box 1, box 2, box 3) };
+    let v = MyVec::<Box<_>> { data: vec![box 1, box 2, box 3] };
     let good = &v[0]; // Shouldn't fail here
     let bad = v[0];
     //~^ ERROR cannot move out of indexed content
diff --git a/src/test/compile-fail/borrowck/borrowck-vec-pattern-element-loan.rs b/src/test/compile-fail/borrowck/borrowck-vec-pattern-element-loan.rs
index 63e80b90ac81e..eb5d69d49bd6a 100644
--- a/src/test/compile-fail/borrowck/borrowck-vec-pattern-element-loan.rs
+++ b/src/test/compile-fail/borrowck/borrowck-vec-pattern-element-loan.rs
@@ -12,7 +12,7 @@
 #![feature(slice_patterns)]
 
 fn a<'a>() -> &'a [isize] {
-    let vec = vec!(1, 2, 3, 4);
+    let vec = vec![1, 2, 3, 4];
     let vec: &[isize] = &vec; //~ ERROR does not live long enough
     let tail = match vec {
         &[_, ref tail..] => tail,
@@ -22,7 +22,7 @@ fn a<'a>() -> &'a [isize] {
 }
 
 fn b<'a>() -> &'a [isize] {
-    let vec = vec!(1, 2, 3, 4);
+    let vec = vec![1, 2, 3, 4];
     let vec: &[isize] = &vec; //~ ERROR does not live long enough
     let init = match vec {
         &[ref init.., _] => init,
@@ -32,7 +32,7 @@ fn b<'a>() -> &'a [isize] {
 }
 
 fn c<'a>() -> &'a [isize] {
-    let vec = vec!(1, 2, 3, 4);
+    let vec = vec![1, 2, 3, 4];
     let vec: &[isize] = &vec; //~ ERROR does not live long enough
     let slice = match vec {
         &[_, ref slice.., _] => slice,
diff --git a/src/test/compile-fail/borrowck/borrowck-vec-pattern-loan-from-mut.rs b/src/test/compile-fail/borrowck/borrowck-vec-pattern-loan-from-mut.rs
index 9dfd4d7792843..505c8c6d53581 100644
--- a/src/test/compile-fail/borrowck/borrowck-vec-pattern-loan-from-mut.rs
+++ b/src/test/compile-fail/borrowck/borrowck-vec-pattern-loan-from-mut.rs
@@ -11,7 +11,7 @@
 #![feature(slice_patterns)]
 
 fn a() {
-    let mut v = vec!(1, 2, 3);
+    let mut v = vec![1, 2, 3];
     let vb: &mut [isize] = &mut v;
     match vb {
         &mut [_a, ref tail..] => {
diff --git a/src/test/compile-fail/borrowck/borrowck-vec-pattern-nesting.rs b/src/test/compile-fail/borrowck/borrowck-vec-pattern-nesting.rs
index ae001e4e34d16..d26364efdbc5d 100644
--- a/src/test/compile-fail/borrowck/borrowck-vec-pattern-nesting.rs
+++ b/src/test/compile-fail/borrowck/borrowck-vec-pattern-nesting.rs
@@ -25,7 +25,7 @@ fn a() {
 }
 
 fn b() {
-    let mut vec = vec!(box 1, box 2, box 3);
+    let mut vec = vec![box 1, box 2, box 3];
     let vec: &mut [Box<isize>] = &mut vec;
     match vec {
         &mut [ref _b..] => {
@@ -37,7 +37,7 @@ fn b() {
 }
 
 fn c() {
-    let mut vec = vec!(box 1, box 2, box 3);
+    let mut vec = vec![box 1, box 2, box 3];
     let vec: &mut [Box<isize>] = &mut vec;
     match vec {
         &mut [_a, //~ ERROR cannot move out
@@ -59,7 +59,7 @@ fn c() {
 }
 
 fn d() {
-    let mut vec = vec!(box 1, box 2, box 3);
+    let mut vec = vec![box 1, box 2, box 3];
     let vec: &mut [Box<isize>] = &mut vec;
     match vec {
         &mut [ //~ ERROR cannot move out
@@ -73,7 +73,7 @@ fn d() {
 }
 
 fn e() {
-    let mut vec = vec!(box 1, box 2, box 3);
+    let mut vec = vec![box 1, box 2, box 3];
     let vec: &mut [Box<isize>] = &mut vec;
     match vec {
         &mut [_a, _b, _c] => {}  //~ ERROR cannot move out
diff --git a/src/test/compile-fail/borrowck/borrowck-vec-pattern-tail-element-loan.rs b/src/test/compile-fail/borrowck/borrowck-vec-pattern-tail-element-loan.rs
index a849e4e2faf3b..cd8f3ebefe628 100644
--- a/src/test/compile-fail/borrowck/borrowck-vec-pattern-tail-element-loan.rs
+++ b/src/test/compile-fail/borrowck/borrowck-vec-pattern-tail-element-loan.rs
@@ -11,7 +11,7 @@
 #![feature(slice_patterns)]
 
 fn a<'a>() -> &'a isize {
-    let vec = vec!(1, 2, 3, 4);
+    let vec = vec![1, 2, 3, 4];
     let vec: &[isize] = &vec; //~ ERROR `vec` does not live long enough
     let tail = match vec {
         &[_a, ref tail..] => &tail[0],
diff --git a/src/test/compile-fail/drop-with-active-borrows-2.rs b/src/test/compile-fail/drop-with-active-borrows-2.rs
index e6e1364dd2ca7..33e4d3e62c418 100644
--- a/src/test/compile-fail/drop-with-active-borrows-2.rs
+++ b/src/test/compile-fail/drop-with-active-borrows-2.rs
@@ -9,7 +9,7 @@
 // except according to those terms.
 
 fn read_lines_borrowed<'a>() -> Vec<&'a str> {
-    let raw_lines: Vec<String> = vec!("foo  ".to_string(), "  bar".to_string());
+    let raw_lines: Vec<String> = vec!["foo  ".to_string(), "  bar".to_string()];
     raw_lines.iter().map(|l| l.trim()).collect()
     //~^ ERROR `raw_lines` does not live long enough
 }
diff --git a/src/test/compile-fail/integral-indexing.rs b/src/test/compile-fail/integral-indexing.rs
index 897aca66cbfd4..c8f33c3caf8d3 100644
--- a/src/test/compile-fail/integral-indexing.rs
+++ b/src/test/compile-fail/integral-indexing.rs
@@ -9,7 +9,7 @@
 // except according to those terms.
 
 pub fn main() {
-    let v: Vec<isize> = vec!(0, 1, 2, 3, 4, 5);
+    let v: Vec<isize> = vec![0, 1, 2, 3, 4, 5];
     let s: String = "abcdef".to_string();
     v[3_usize];
     v[3];
diff --git a/src/test/compile-fail/issue-11873.rs b/src/test/compile-fail/issue-11873.rs
index 38956944f63e6..4618851529a15 100644
--- a/src/test/compile-fail/issue-11873.rs
+++ b/src/test/compile-fail/issue-11873.rs
@@ -9,7 +9,7 @@
 // except according to those terms.
 
 fn main() {
-    let mut v = vec!(1);
+    let mut v = vec![1];
     let mut f = || v.push(2);
     let _w = v; //~ ERROR: cannot move out of `v`
 
diff --git a/src/test/compile-fail/issue-13446.rs b/src/test/compile-fail/issue-13446.rs
index 53d1486288984..6ad3ec67b2964 100644
--- a/src/test/compile-fail/issue-13446.rs
+++ b/src/test/compile-fail/issue-13446.rs
@@ -13,6 +13,6 @@
 
 // error-pattern: mismatched types
 
-static VEC: [u32; 256] = vec!();
+static VEC: [u32; 256] = vec![];
 
 fn main() {}
diff --git a/src/test/compile-fail/issue-3044.rs b/src/test/compile-fail/issue-3044.rs
index b934cbe4b5d87..c7b276da57376 100644
--- a/src/test/compile-fail/issue-3044.rs
+++ b/src/test/compile-fail/issue-3044.rs
@@ -10,7 +10,7 @@
 
 
 fn main() {
-    let needlesArr: Vec<char> = vec!('a', 'f');
+    let needlesArr: Vec<char> = vec!['a', 'f'];
     needlesArr.iter().fold(|x, y| {
     });
     //~^^ ERROR this function takes 2 parameters but 1 parameter was supplied
diff --git a/src/test/compile-fail/issue-5067.rs b/src/test/compile-fail/issue-5067.rs
index b7b5553dc74e4..1c543a5fdacbb 100644
--- a/src/test/compile-fail/issue-5067.rs
+++ b/src/test/compile-fail/issue-5067.rs
@@ -48,7 +48,7 @@ macro_rules! make_vec {
 }
 
 fn main() {
-    let _ = make_vec!(a 1, a 2, a 3);
+    let _ = make_vec![a 1, a 2, a 3];
 }
 
 
diff --git a/src/test/compile-fail/lint-unused-mut-variables.rs b/src/test/compile-fail/lint-unused-mut-variables.rs
index 8165dd0fa29c0..21cfadb9c7992 100644
--- a/src/test/compile-fail/lint-unused-mut-variables.rs
+++ b/src/test/compile-fail/lint-unused-mut-variables.rs
@@ -21,7 +21,7 @@ fn main() {
     let mut a = 3; //~ ERROR: variable does not need to be mutable
     let mut a = 2; //~ ERROR: variable does not need to be mutable
     let mut b = 3; //~ ERROR: variable does not need to be mutable
-    let mut a = vec!(3); //~ ERROR: variable does not need to be mutable
+    let mut a = vec![3]; //~ ERROR: variable does not need to be mutable
     let (mut a, b) = (1, 2); //~ ERROR: variable does not need to be mutable
     let mut a; //~ ERROR: variable does not need to be mutable
     a = 3;
@@ -88,5 +88,5 @@ fn callback<F>(f: F) where F: FnOnce() {}
 #[allow(unused_mut)]
 fn foo(mut a: isize) {
     let mut a = 3;
-    let mut b = vec!(2);
+    let mut b = vec![2];
 }
diff --git a/src/test/compile-fail/match-vec-unreachable.rs b/src/test/compile-fail/match-vec-unreachable.rs
index 57e3a58b5660e..4d9b3aea1124b 100644
--- a/src/test/compile-fail/match-vec-unreachable.rs
+++ b/src/test/compile-fail/match-vec-unreachable.rs
@@ -29,7 +29,7 @@ fn main() {
         _ => { }
     }
 
-    let x: Vec<char> = vec!('a', 'b', 'c');
+    let x: Vec<char> = vec!['a', 'b', 'c'];
     let x: &[char] = &x;
     match *x {
         ['a', 'b', 'c', ref _tail..] => {}
diff --git a/src/test/compile-fail/moves-based-on-type-access-to-field.rs b/src/test/compile-fail/moves-based-on-type-access-to-field.rs
index b8572fbd2150d..63fb4ff02a4ea 100644
--- a/src/test/compile-fail/moves-based-on-type-access-to-field.rs
+++ b/src/test/compile-fail/moves-based-on-type-access-to-field.rs
@@ -16,7 +16,7 @@ fn consume(_s: String) {}
 fn touch<A>(_a: &A) {}
 
 fn f20() {
-    let x = vec!("hi".to_string());
+    let x = vec!["hi".to_string()];
     consume(x.into_iter().next().unwrap());
     touch(&x[0]); //~ ERROR use of moved value: `x`
 }
diff --git a/src/test/compile-fail/moves-based-on-type-exprs.rs b/src/test/compile-fail/moves-based-on-type-exprs.rs
index 9ad44567a41f2..194f278259b6b 100644
--- a/src/test/compile-fail/moves-based-on-type-exprs.rs
+++ b/src/test/compile-fail/moves-based-on-type-exprs.rs
@@ -29,7 +29,7 @@ fn f20() {
 }
 
 fn f21() {
-    let x = vec!(1, 2, 3);
+    let x = vec![1, 2, 3];
     let _y = (x[0], 3);
     touch(&x);
 }
@@ -77,24 +77,24 @@ fn f70() {
 
 fn f80() {
     let x = "hi".to_string();
-    let _y = vec!(x);
+    let _y = vec![x];
     touch(&x); //~ ERROR use of moved value: `x`
 }
 
 fn f100() {
-    let x = vec!("hi".to_string());
+    let x = vec!["hi".to_string()];
     let _y = x.into_iter().next().unwrap();
     touch(&x); //~ ERROR use of moved value: `x`
 }
 
 fn f110() {
-    let x = vec!("hi".to_string());
+    let x = vec!["hi".to_string()];
     let _y = [x.into_iter().next().unwrap(); 1];
     touch(&x); //~ ERROR use of moved value: `x`
 }
 
 fn f120() {
-    let mut x = vec!("hi".to_string(), "ho".to_string());
+    let mut x = vec!["hi".to_string(), "ho".to_string()];
     x.swap(0, 1);
     touch(&x[0]);
     touch(&x[1]);
diff --git a/src/test/compile-fail/no-capture-arc.rs b/src/test/compile-fail/no-capture-arc.rs
index 7b7b3c414dded..5e1d22bf63b89 100644
--- a/src/test/compile-fail/no-capture-arc.rs
+++ b/src/test/compile-fail/no-capture-arc.rs
@@ -14,7 +14,7 @@ use std::sync::Arc;
 use std::thread;
 
 fn main() {
-    let v = vec!(1, 2, 3, 4, 5, 6, 7, 8, 9, 10);
+    let v = vec![1, 2, 3, 4, 5, 6, 7, 8, 9, 10];
     let arc_v = Arc::new(v);
 
     thread::spawn(move|| {
diff --git a/src/test/compile-fail/no-reuse-move-arc.rs b/src/test/compile-fail/no-reuse-move-arc.rs
index 1720b40c83bbd..76c8a444320d3 100644
--- a/src/test/compile-fail/no-reuse-move-arc.rs
+++ b/src/test/compile-fail/no-reuse-move-arc.rs
@@ -12,7 +12,7 @@ use std::sync::Arc;
 use std::thread;
 
 fn main() {
-    let v = vec!(1, 2, 3, 4, 5, 6, 7, 8, 9, 10);
+    let v = vec![1, 2, 3, 4, 5, 6, 7, 8, 9, 10];
     let arc_v = Arc::new(v);
 
     thread::spawn(move|| {
diff --git a/src/test/compile-fail/non-copyable-void.rs b/src/test/compile-fail/non-copyable-void.rs
index fd245f38a0c92..6067b71280cef 100644
--- a/src/test/compile-fail/non-copyable-void.rs
+++ b/src/test/compile-fail/non-copyable-void.rs
@@ -11,7 +11,7 @@
 extern crate libc;
 
 fn main() {
-    let x : *const Vec<isize> = &vec!(1,2,3);
+    let x : *const Vec<isize> = &vec![1,2,3];
     let y : *const libc::c_void = x as *const libc::c_void;
     unsafe {
         let _z = (*y).clone();
diff --git a/src/test/compile-fail/non-exhaustive-match.rs b/src/test/compile-fail/non-exhaustive-match.rs
index 017baacc9d329..74e728d713b1d 100644
--- a/src/test/compile-fail/non-exhaustive-match.rs
+++ b/src/test/compile-fail/non-exhaustive-match.rs
@@ -37,20 +37,20 @@ fn main() {
       (_, t::a) => {}
       (t::b, t::b) => {}
     }
-    let vec = vec!(Some(42), None, Some(21));
+    let vec = vec![Some(42), None, Some(21)];
     let vec: &[Option<isize>] = &vec;
     match *vec { //~ ERROR non-exhaustive patterns: `[]` not covered
         [Some(..), None, ref tail..] => {}
         [Some(..), Some(..), ref tail..] => {}
         [None] => {}
     }
-    let vec = vec!(1);
+    let vec = vec![1];
     let vec: &[isize] = &vec;
     match *vec {
         [_, ref tail..] => (),
         [] => ()
     }
-    let vec = vec!(0.5f32);
+    let vec = vec![0.5f32];
     let vec: &[f32] = &vec;
     match *vec { //~ ERROR non-exhaustive patterns: `[_, _, _, _]` not covered
         [0.1, 0.2, 0.3] => (),
@@ -58,7 +58,7 @@ fn main() {
         [0.1] => (),
         [] => ()
     }
-    let vec = vec!(Some(42), None, Some(21));
+    let vec = vec![Some(42), None, Some(21)];
     let vec: &[Option<isize>] = &vec;
     match *vec {
         [Some(..), None, ref tail..] => {}
diff --git a/src/test/compile-fail/on-unimplemented/on-trait.rs b/src/test/compile-fail/on-unimplemented/on-trait.rs
index ef7695af3e12e..3a789f3faeb2a 100644
--- a/src/test/compile-fail/on-unimplemented/on-trait.rs
+++ b/src/test/compile-fail/on-unimplemented/on-trait.rs
@@ -30,7 +30,7 @@ fn collect<A, I: Iterator<Item=A>, B: MyFromIterator<A>>(it: I) -> B {
 }
 
 pub fn main() {
-    let x = vec!(1u8, 2, 3, 4);
+    let x = vec![1u8, 2, 3, 4];
     let y: Option<Vec<u8>> = collect(x.iter()); // this should give approximately the same error for x.iter().collect()
     //~^ ERROR
     //~^^ NOTE a collection of type `std::option::Option<std::vec::Vec<u8>>` cannot be built from an iterator over elements of type `&u8`
diff --git a/src/test/compile-fail/regions-escape-loop-via-vec.rs b/src/test/compile-fail/regions-escape-loop-via-vec.rs
index f5ea7a2108e79..8982b5cd98de4 100644
--- a/src/test/compile-fail/regions-escape-loop-via-vec.rs
+++ b/src/test/compile-fail/regions-escape-loop-via-vec.rs
@@ -11,7 +11,7 @@
 // The type of `y` ends up getting inferred to the type of the block.
 fn broken() {
     let mut x = 3;
-    let mut _y = vec!(&mut x);
+    let mut _y = vec![&mut x];
     //~^ NOTE borrow of `x` occurs here
     //~| NOTE borrow of `x` occurs here
     //~| NOTE borrow of `x` occurs here
diff --git a/src/test/compile-fail/unboxed-closures-failed-recursive-fn-2.rs b/src/test/compile-fail/unboxed-closures-failed-recursive-fn-2.rs
index f40c8fc747494..12b48b2a6c8aa 100644
--- a/src/test/compile-fail/unboxed-closures-failed-recursive-fn-2.rs
+++ b/src/test/compile-fail/unboxed-closures-failed-recursive-fn-2.rs
@@ -16,7 +16,7 @@
 
 fn a() {
     let mut closure0 = None;
-    let vec = vec!(1, 2, 3);
+    let vec = vec![1, 2, 3];
 
     loop {
         {
diff --git a/src/test/compile-fail/unboxed-closures-move-upvar-from-non-once-ref-closure.rs b/src/test/compile-fail/unboxed-closures-move-upvar-from-non-once-ref-closure.rs
index e66610c149607..cd9f1636c3f4d 100644
--- a/src/test/compile-fail/unboxed-closures-move-upvar-from-non-once-ref-closure.rs
+++ b/src/test/compile-fail/unboxed-closures-move-upvar-from-non-once-ref-closure.rs
@@ -16,7 +16,7 @@ fn call<F>(f: F) where F : Fn() {
 }
 
 fn main() {
-    let y = vec!(format!("World"));
+    let y = vec![format!("World")];
     call(|| {
         y.into_iter();
         //~^ ERROR cannot move out of captured outer variable in an `Fn` closure
diff --git a/src/test/compile-fail/vec-macro-with-comma-only.rs b/src/test/compile-fail/vec-macro-with-comma-only.rs
index 346cf1ec555d3..96f58666fdff3 100644
--- a/src/test/compile-fail/vec-macro-with-comma-only.rs
+++ b/src/test/compile-fail/vec-macro-with-comma-only.rs
@@ -9,5 +9,5 @@
 // except according to those terms.
 
 pub fn main() {
-    vec!(,); //~ ERROR expected expression, found `,`
+    vec![,]; //~ ERROR expected expression, found `,`
 }
diff --git a/src/test/compile-fail/vec-mut-iter-borrow.rs b/src/test/compile-fail/vec-mut-iter-borrow.rs
index 023ef72c453bb..571634e399261 100644
--- a/src/test/compile-fail/vec-mut-iter-borrow.rs
+++ b/src/test/compile-fail/vec-mut-iter-borrow.rs
@@ -9,7 +9,7 @@
 // except according to those terms.
 
 fn main() {
-    let mut xs: Vec<isize> = vec!();
+    let mut xs: Vec<isize> = vec![];
 
     for x in &mut xs {
         xs.push(1) //~ ERROR cannot borrow `xs`
diff --git a/src/test/compile-fail/vec-res-add.rs b/src/test/compile-fail/vec-res-add.rs
index cf64486c9c7bf..27f6fc51164ad 100644
--- a/src/test/compile-fail/vec-res-add.rs
+++ b/src/test/compile-fail/vec-res-add.rs
@@ -21,8 +21,8 @@ impl Drop for r {
 
 fn main() {
     // This can't make sense as it would copy the classes
-    let i = vec!(r(0));
-    let j = vec!(r(1));
+    let i = vec![r(0)];
+    let j = vec![r(1)];
     let k = i + j;
     //~^ ERROR binary operation `+` cannot be applied to type
     println!("{:?}", j);
diff --git a/src/test/compile-fail/writing-to-immutable-vec.rs b/src/test/compile-fail/writing-to-immutable-vec.rs
index 09c9439b464ec..f289b85992ee8 100644
--- a/src/test/compile-fail/writing-to-immutable-vec.rs
+++ b/src/test/compile-fail/writing-to-immutable-vec.rs
@@ -10,6 +10,6 @@
 
 
 fn main() {
-    let v: Vec<isize> = vec!(1, 2, 3);
+    let v: Vec<isize> = vec![1, 2, 3];
     v[1] = 4; //~ ERROR cannot borrow immutable local variable `v` as mutable
 }
diff --git a/src/test/debuginfo/issue14411.rs b/src/test/debuginfo/issue14411.rs
index 3b2d372117d00..d334e33f887b8 100644
--- a/src/test/debuginfo/issue14411.rs
+++ b/src/test/debuginfo/issue14411.rs
@@ -20,6 +20,6 @@ fn test(a: &Vec<u8>) {
 }
 
 pub fn main() {
-  let data = vec!();
+  let data = vec![];
   test(&data);
 }
diff --git a/src/test/parse-fail/issue-10412.rs b/src/test/parse-fail/issue-10412.rs
index fc2598d1e9d2f..d723d94c02cc3 100644
--- a/src/test/parse-fail/issue-10412.rs
+++ b/src/test/parse-fail/issue-10412.rs
@@ -19,7 +19,7 @@ trait Serializable<'self, T> { //~ ERROR lifetimes cannot use keyword names
 impl<'self> Serializable<str> for &'self str { //~ ERROR lifetimes cannot use keyword names
     //~^ ERROR lifetimes cannot use keyword names
     fn serialize(val : &'self str) -> Vec<u8> { //~ ERROR lifetimes cannot use keyword names
-        vec!(1)
+        vec![1]
     }
     fn deserialize(repr: &[u8]) -> &'self str { //~ ERROR lifetimes cannot use keyword names
         "hi"
diff --git a/src/test/pretty/block-disambig.rs b/src/test/pretty/block-disambig.rs
index 5f88f9036780b..c645a66b70efc 100644
--- a/src/test/pretty/block-disambig.rs
+++ b/src/test/pretty/block-disambig.rs
@@ -61,9 +61,9 @@ fn test9() {
 }
 
 fn test10() -> isize {
-    let regs = vec!(0);
+    let regs = vec![0];
     match true { true => { } _ => { } }
     regs[0]
 }
 
-fn test11() -> Vec<isize> { if true { } vec!(1, 2) }
+fn test11() -> Vec<isize> { if true { } vec![1, 2] }
diff --git a/src/test/pretty/stmt_expr_attributes.rs b/src/test/pretty/stmt_expr_attributes.rs
index e52932cd7befa..476fb33e9b3e3 100644
--- a/src/test/pretty/stmt_expr_attributes.rs
+++ b/src/test/pretty/stmt_expr_attributes.rs
@@ -230,7 +230,7 @@ fn _11() {
     let t = Bar(());
     let _ = #[attr] t.0;
     let _ = (#[attr] t).0;
-    let v = vec!(0);
+    let v = vec![0];
     let _ = #[attr] v[0];
     let _ = (#[attr] v)[0];
     let _ = #[attr] 0..#[attr] 0;
diff --git a/src/test/run-pass-fulldeps/auxiliary/custom_derive_partial_eq.rs b/src/test/run-pass-fulldeps/auxiliary/custom_derive_partial_eq.rs
index 956f789dab839..e750d1fb1e3e6 100644
--- a/src/test/run-pass-fulldeps/auxiliary/custom_derive_partial_eq.rs
+++ b/src/test/run-pass-fulldeps/auxiliary/custom_derive_partial_eq.rs
@@ -53,12 +53,12 @@ fn expand_deriving_partial_eq(cx: &mut ExtCtxt, span: Span, mitem: &MetaItem, it
     }
 
     let inline = cx.meta_word(span, InternedString::new("inline"));
-    let attrs = vec!(cx.attribute(span, inline));
+    let attrs = vec![cx.attribute(span, inline)];
     let methods = vec![MethodDef {
         name: "eq",
         generics: LifetimeBounds::empty(),
         explicit_self: borrowed_explicit_self(),
-        args: vec!(borrowed_self()),
+        args: vec![borrowed_self()],
         ret_ty: Literal(deriving::generic::ty::Path::new_local("bool")),
         attributes: attrs,
         is_unsafe: false,
diff --git a/src/test/run-pass/assignability-trait.rs b/src/test/run-pass/assignability-trait.rs
index c364240f4ad69..bc95d96a8cc9d 100644
--- a/src/test/run-pass/assignability-trait.rs
+++ b/src/test/run-pass/assignability-trait.rs
@@ -38,7 +38,7 @@ fn length<A, T: iterable<A>>(x: T) -> usize {
 }
 
 pub fn main() {
-    let x: Vec<isize> = vec!(0,1,2,3);
+    let x: Vec<isize> = vec![0,1,2,3];
     // Call a method
     x.iterate(|y| { assert_eq!(x[*y as usize], *y); true });
     // Call a parameterized function
diff --git a/src/test/run-pass/associated-types-doubleendediterator-object.rs b/src/test/run-pass/associated-types-doubleendediterator-object.rs
index 1661812520b3e..dd194447740b7 100644
--- a/src/test/run-pass/associated-types-doubleendediterator-object.rs
+++ b/src/test/run-pass/associated-types-doubleendediterator-object.rs
@@ -25,7 +25,7 @@ fn pairwise_sub(mut t: Box<DoubleEndedIterator<Item=isize>>) -> isize {
 }
 
 fn main() {
-    let v = vec!(1, 2, 3, 4, 5, 6);
+    let v = vec![1, 2, 3, 4, 5, 6];
     // FIXME (#22405): Replace `Box::new` with `box` here when/if possible.
     let r = pairwise_sub(Box::new(v.into_iter()));
     assert_eq!(r, 9);
diff --git a/src/test/run-pass/associated-types-iterator-binding.rs b/src/test/run-pass/associated-types-iterator-binding.rs
index be854f820d4d6..abd4917cae87f 100644
--- a/src/test/run-pass/associated-types-iterator-binding.rs
+++ b/src/test/run-pass/associated-types-iterator-binding.rs
@@ -22,7 +22,7 @@ fn pairwise_sub<T:DoubleEndedIterator<Item=isize>>(mut t: T) -> isize {
 }
 
 fn main() {
-    let v = vec!(1, 2, 3, 4, 5, 6);
+    let v = vec![1, 2, 3, 4, 5, 6];
     let r = pairwise_sub(v.into_iter());
     assert_eq!(r, 9);
 }
diff --git a/src/test/run-pass/auto-loop.rs b/src/test/run-pass/auto-loop.rs
index babc0db4c3190..b0afae79c3696 100644
--- a/src/test/run-pass/auto-loop.rs
+++ b/src/test/run-pass/auto-loop.rs
@@ -11,7 +11,7 @@
 
 pub fn main() {
     let mut sum = 0;
-    let xs = vec!(1, 2, 3, 4, 5);
+    let xs = vec![1, 2, 3, 4, 5];
     for x in &xs {
         sum += *x;
     }
diff --git a/src/test/run-pass/auto-ref-sliceable.rs b/src/test/run-pass/auto-ref-sliceable.rs
index 5b12edb427562..f6cb314d06e2d 100644
--- a/src/test/run-pass/auto-ref-sliceable.rs
+++ b/src/test/run-pass/auto-ref-sliceable.rs
@@ -21,7 +21,7 @@ impl<T> Pushable<T> for Vec<T> {
 }
 
 pub fn main() {
-    let mut v = vec!(1);
+    let mut v = vec![1];
     v.push_val(2);
     v.push_val(3);
     assert_eq!(v, [1, 2, 3]);
diff --git a/src/test/run-pass/autobind.rs b/src/test/run-pass/autobind.rs
index 1f3d17ad55c08..ed0b9eca0e058 100644
--- a/src/test/run-pass/autobind.rs
+++ b/src/test/run-pass/autobind.rs
@@ -12,7 +12,7 @@
 
 fn f<T>(x: Vec<T>) -> T { return x.into_iter().next().unwrap(); }
 
-fn g<F>(act: F) -> isize where F: FnOnce(Vec<isize>) -> isize { return act(vec!(1, 2, 3)); }
+fn g<F>(act: F) -> isize where F: FnOnce(Vec<isize>) -> isize { return act(vec![1, 2, 3]); }
 
 pub fn main() {
     assert_eq!(g(f), 1);
diff --git a/src/test/run-pass/block-arg.rs b/src/test/run-pass/block-arg.rs
index 2f530331a2bde..7fca4bccab3ff 100644
--- a/src/test/run-pass/block-arg.rs
+++ b/src/test/run-pass/block-arg.rs
@@ -10,7 +10,7 @@
 
 // Check usage and precedence of block arguments in expressions:
 pub fn main() {
-    let v = vec!(-1.0f64, 0.0, 1.0, 2.0, 3.0);
+    let v = vec![-1.0f64, 0.0, 1.0, 2.0, 3.0];
 
     // Statement form does not require parentheses:
     for i in &v {
diff --git a/src/test/run-pass/borrow-by-val-method-receiver.rs b/src/test/run-pass/borrow-by-val-method-receiver.rs
index 052b605393145..44f4a54610a9b 100644
--- a/src/test/run-pass/borrow-by-val-method-receiver.rs
+++ b/src/test/run-pass/borrow-by-val-method-receiver.rs
@@ -17,6 +17,6 @@ impl<'a> Foo for &'a [isize] {
 }
 
 pub fn main() {
-    let items = vec!( 3, 5, 1, 2, 4 );
+    let items = vec![ 3, 5, 1, 2, 4 ];
     items.foo();
 }
diff --git a/src/test/run-pass/borrowck/borrowck-binding-mutbl.rs b/src/test/run-pass/borrowck/borrowck-binding-mutbl.rs
index 187063968f7f9..b6c2a3a61ea4f 100644
--- a/src/test/run-pass/borrowck/borrowck-binding-mutbl.rs
+++ b/src/test/run-pass/borrowck/borrowck-binding-mutbl.rs
@@ -14,7 +14,7 @@ fn impure(_v: &[isize]) {
 }
 
 pub fn main() {
-    let mut x = F {f: vec!(3)};
+    let mut x = F {f: vec![3]};
 
     match x {
       F {f: ref mut v} => {
diff --git a/src/test/run-pass/borrowck/borrowck-mut-vec-as-imm-slice.rs b/src/test/run-pass/borrowck/borrowck-mut-vec-as-imm-slice.rs
index d55517c65d667..4699f376313ba 100644
--- a/src/test/run-pass/borrowck/borrowck-mut-vec-as-imm-slice.rs
+++ b/src/test/run-pass/borrowck/borrowck-mut-vec-as-imm-slice.rs
@@ -21,5 +21,5 @@ fn has_mut_vec(v: Vec<isize> ) -> isize {
 }
 
 pub fn main() {
-    assert_eq!(has_mut_vec(vec!(1, 2, 3)), 6);
+    assert_eq!(has_mut_vec(vec![1, 2, 3]), 6);
 }
diff --git a/src/test/run-pass/break.rs b/src/test/run-pass/break.rs
index ea136e2dc4854..9a32fbc103147 100644
--- a/src/test/run-pass/break.rs
+++ b/src/test/run-pass/break.rs
@@ -26,7 +26,7 @@ pub fn main() {
         i += 1; if i % 2 == 0 { continue; } assert!((i % 2 != 0));
         if i >= 10 { break; }
     }
-    let ys = vec!(1, 2, 3, 4, 5, 6);
+    let ys = vec![1, 2, 3, 4, 5, 6];
     for x in &ys {
         if *x % 2 == 0 { continue; }
         assert!((*x % 2 != 0));
diff --git a/src/test/run-pass/byte-literals.rs b/src/test/run-pass/byte-literals.rs
index 9f7b98a57fcec..ad779d26f9e46 100644
--- a/src/test/run-pass/byte-literals.rs
+++ b/src/test/run-pass/byte-literals.rs
@@ -57,7 +57,7 @@ pub fn main() {
         _ => panic!(),
     }
 
-    let buf = vec!(97u8, 98, 99, 100);
+    let buf = vec![97u8, 98, 99, 100];
     assert_eq!(match &buf[0..3] {
          b"def" => 1,
          b"abc" => 2,
diff --git a/src/test/run-pass/cci_no_inline_exe.rs b/src/test/run-pass/cci_no_inline_exe.rs
index cc76ed530c4b5..b105411c284a7 100644
--- a/src/test/run-pass/cci_no_inline_exe.rs
+++ b/src/test/run-pass/cci_no_inline_exe.rs
@@ -21,7 +21,7 @@ pub fn main() {
     // actually working.
     //let bt0 = sys::frame_address();
     //println!("%?", bt0);
-    iter(vec!(1, 2, 3), |i| {
+    iter(vec![1, 2, 3], |i| {
         println!("{}", i);
 
         //let bt1 = sys::frame_address();
diff --git a/src/test/run-pass/class-poly-methods-cross-crate.rs b/src/test/run-pass/class-poly-methods-cross-crate.rs
index 4d247bde190de..7d266181c9eb1 100644
--- a/src/test/run-pass/class-poly-methods-cross-crate.rs
+++ b/src/test/run-pass/class-poly-methods-cross-crate.rs
@@ -14,12 +14,12 @@ extern crate cci_class_6;
 use cci_class_6::kitties::cat;
 
 pub fn main() {
-  let mut nyan : cat<char> = cat::<char>(52_usize, 99, vec!('p'));
-  let mut kitty = cat(1000_usize, 2, vec!("tabby".to_string()));
+  let mut nyan : cat<char> = cat::<char>(52_usize, 99, vec!['p']);
+  let mut kitty = cat(1000_usize, 2, vec!["tabby".to_string()]);
   assert_eq!(nyan.how_hungry, 99);
   assert_eq!(kitty.how_hungry, 2);
-  nyan.speak(vec!(1_usize,2_usize,3_usize));
+  nyan.speak(vec![1_usize,2_usize,3_usize]);
   assert_eq!(nyan.meow_count(), 55_usize);
-  kitty.speak(vec!("meow".to_string(), "mew".to_string(), "purr".to_string(), "chirp".to_string()));
+  kitty.speak(vec!["meow".to_string(), "mew".to_string(), "purr".to_string(), "chirp".to_string()]);
   assert_eq!(kitty.meow_count(), 1004_usize);
 }
diff --git a/src/test/run-pass/class-poly-methods.rs b/src/test/run-pass/class-poly-methods.rs
index 2528ff5128f9c..5da858e3c4097 100644
--- a/src/test/run-pass/class-poly-methods.rs
+++ b/src/test/run-pass/class-poly-methods.rs
@@ -33,12 +33,12 @@ fn cat<U>(in_x : usize, in_y : isize, in_info: Vec<U> ) -> cat<U> {
 }
 
 pub fn main() {
-  let mut nyan : cat<isize> = cat::<isize>(52, 99, vec!(9));
-  let mut kitty = cat(1000, 2, vec!("tabby".to_string()));
+  let mut nyan : cat<isize> = cat::<isize>(52, 99, vec![9]);
+  let mut kitty = cat(1000, 2, vec!["tabby".to_string()]);
   assert_eq!(nyan.how_hungry, 99);
   assert_eq!(kitty.how_hungry, 2);
-  nyan.speak(vec!(1,2,3));
+  nyan.speak(vec![1,2,3]);
   assert_eq!(nyan.meow_count(), 55);
-  kitty.speak(vec!("meow".to_string(), "mew".to_string(), "purr".to_string(), "chirp".to_string()));
+  kitty.speak(vec!["meow".to_string(), "mew".to_string(), "purr".to_string(), "chirp".to_string()]);
   assert_eq!(kitty.meow_count(), 1004);
 }
diff --git a/src/test/run-pass/cleanup-rvalue-temp-during-incomplete-alloc.rs b/src/test/run-pass/cleanup-rvalue-temp-during-incomplete-alloc.rs
index 25d3eb3bbe28c..c401b529c30d9 100644
--- a/src/test/run-pass/cleanup-rvalue-temp-during-incomplete-alloc.rs
+++ b/src/test/run-pass/cleanup-rvalue-temp-during-incomplete-alloc.rs
@@ -41,7 +41,7 @@ fn do_it(x: &[usize]) -> Foo {
     panic!()
 }
 
-fn get_bar(x: usize) -> Vec<usize> { vec!(x * 2) }
+fn get_bar(x: usize) -> Vec<usize> { vec![x * 2] }
 
 pub fn fails() {
     let x = 2;
diff --git a/src/test/run-pass/coerce-reborrow-imm-vec-rcvr.rs b/src/test/run-pass/coerce-reborrow-imm-vec-rcvr.rs
index 4e116ae146691..e86f20694e103 100644
--- a/src/test/run-pass/coerce-reborrow-imm-vec-rcvr.rs
+++ b/src/test/run-pass/coerce-reborrow-imm-vec-rcvr.rs
@@ -19,7 +19,7 @@ fn bip(v: &[usize]) -> Vec<usize> {
 }
 
 pub fn main() {
-    let mut the_vec = vec!(1, 2, 3, 100);
+    let mut the_vec = vec![1, 2, 3, 100];
     assert_eq!(the_vec.clone(), bar(&mut the_vec));
     assert_eq!(the_vec.clone(), bip(&the_vec));
 }
diff --git a/src/test/run-pass/coerce-reborrow-mut-vec-arg.rs b/src/test/run-pass/coerce-reborrow-mut-vec-arg.rs
index ce0bc33905fe5..ca4ee4a97d524 100644
--- a/src/test/run-pass/coerce-reborrow-mut-vec-arg.rs
+++ b/src/test/run-pass/coerce-reborrow-mut-vec-arg.rs
@@ -21,7 +21,7 @@ fn bar(v: &mut [usize]) {
 }
 
 pub fn main() {
-    let mut the_vec = vec!(1, 2, 3, 100);
+    let mut the_vec = vec![1, 2, 3, 100];
     bar(&mut the_vec);
     assert_eq!(the_vec, [100, 3, 2, 1]);
 }
diff --git a/src/test/run-pass/coerce-reborrow-mut-vec-rcvr.rs b/src/test/run-pass/coerce-reborrow-mut-vec-rcvr.rs
index 066b33e007b89..f35735adbcfe2 100644
--- a/src/test/run-pass/coerce-reborrow-mut-vec-rcvr.rs
+++ b/src/test/run-pass/coerce-reborrow-mut-vec-rcvr.rs
@@ -17,7 +17,7 @@ fn bar(v: &mut [usize]) {
 }
 
 pub fn main() {
-    let mut the_vec = vec!(1, 2, 3, 100);
+    let mut the_vec = vec![1, 2, 3, 100];
     bar(&mut the_vec);
     assert_eq!(the_vec, [100, 3, 2, 1]);
 }
diff --git a/src/test/run-pass/deriving-in-macro.rs b/src/test/run-pass/deriving-in-macro.rs
index b23075e6d0af4..adc3e3efd70df 100644
--- a/src/test/run-pass/deriving-in-macro.rs
+++ b/src/test/run-pass/deriving-in-macro.rs
@@ -19,6 +19,6 @@ macro_rules! define_vec {
     )
 }
 
-define_vec!();
+define_vec![];
 
 pub fn main() {}
diff --git a/src/test/run-pass/drop-with-type-ascription-2.rs b/src/test/run-pass/drop-with-type-ascription-2.rs
index cb3712dea3224..53005ea5291fd 100644
--- a/src/test/run-pass/drop-with-type-ascription-2.rs
+++ b/src/test/run-pass/drop-with-type-ascription-2.rs
@@ -12,7 +12,7 @@
 #![feature(collections)]
 
 fn main() {
-    let args = vec!("foobie", "asdf::asdf");
+    let args = vec!["foobie", "asdf::asdf"];
     let arr: Vec<&str> = args[1].split("::").collect();
     assert_eq!(arr[0], "asdf");
     assert_eq!(arr[0], "asdf");
diff --git a/src/test/run-pass/expr-fn.rs b/src/test/run-pass/expr-fn.rs
index aeca388d317b6..cc9a2e60decee 100644
--- a/src/test/run-pass/expr-fn.rs
+++ b/src/test/run-pass/expr-fn.rs
@@ -16,7 +16,7 @@ fn test_int() {
 }
 
 fn test_vec() {
-    fn f() -> Vec<isize> { vec!(10, 11) }
+    fn f() -> Vec<isize> { vec![10, 11] }
     let vect = f();
     assert_eq!(vect[1], 11);
 }
diff --git a/src/test/run-pass/expr-match-panic.rs b/src/test/run-pass/expr-match-panic.rs
index 89dc7b09c7b15..1a6466048d90d 100644
--- a/src/test/run-pass/expr-match-panic.rs
+++ b/src/test/run-pass/expr-match-panic.rs
@@ -16,7 +16,7 @@ fn test_simple() {
 }
 
 fn test_box() {
-    let r = match true { true => { vec!(10) } false => { panic!() } };
+    let r = match true { true => { vec![10] } false => { panic!() } };
     assert_eq!(r[0], 10);
 }
 
diff --git a/src/test/run-pass/for-destruct.rs b/src/test/run-pass/for-destruct.rs
index 963d34a2d2fbd..ba78ff4d53937 100644
--- a/src/test/run-pass/for-destruct.rs
+++ b/src/test/run-pass/for-destruct.rs
@@ -12,7 +12,7 @@
 struct Pair { x: isize, y: isize }
 
 pub fn main() {
-    for elt in &(vec!(Pair {x: 10, y: 20}, Pair {x: 30, y: 0})) {
+    for elt in &(vec![Pair {x: 10, y: 20}, Pair {x: 30, y: 0}]) {
         assert_eq!(elt.x + elt.y, 30);
     }
 }
diff --git a/src/test/run-pass/foreach-nested.rs b/src/test/run-pass/foreach-nested.rs
index 60068185f5a52..2c4d0cc7648ce 100644
--- a/src/test/run-pass/foreach-nested.rs
+++ b/src/test/run-pass/foreach-nested.rs
@@ -13,7 +13,7 @@
 fn two<F>(mut it: F) where F: FnMut(isize) { it(0); it(1); }
 
 pub fn main() {
-    let mut a: Vec<isize> = vec!(-1, -1, -1, -1);
+    let mut a: Vec<isize> = vec![-1, -1, -1, -1];
     let mut p: isize = 0;
     two(|i| {
         two(|j| { a[p as usize] = 10 * i + j; p += 1; })
diff --git a/src/test/run-pass/generic-ivec-leak.rs b/src/test/run-pass/generic-ivec-leak.rs
index eb0546063f715..d439c62380185 100644
--- a/src/test/run-pass/generic-ivec-leak.rs
+++ b/src/test/run-pass/generic-ivec-leak.rs
@@ -10,4 +10,4 @@
 
 enum wrapper<T> { wrapped(T), }
 
-pub fn main() { let _w = wrapper::wrapped(vec!(1, 2, 3, 4, 5)); }
+pub fn main() { let _w = wrapper::wrapped(vec![1, 2, 3, 4, 5]); }
diff --git a/src/test/run-pass/generic-static-methods.rs b/src/test/run-pass/generic-static-methods.rs
index 7a496ebf8ce34..ad501ec7e9ba1 100644
--- a/src/test/run-pass/generic-static-methods.rs
+++ b/src/test/run-pass/generic-static-methods.rs
@@ -25,5 +25,5 @@ impl<T> vec_utils<T> for Vec<T> {
 }
 
 pub fn main() {
-    assert_eq!(vec_utils::map_(&vec!(1,2,3), |&x| x+1), [2,3,4]);
+    assert_eq!(vec_utils::map_(&vec![1,2,3], |&x| x+1), [2,3,4]);
 }
diff --git a/src/test/run-pass/getopts_ref.rs b/src/test/run-pass/getopts_ref.rs
index c9595d09e21b2..90726c21fac47 100644
--- a/src/test/run-pass/getopts_ref.rs
+++ b/src/test/run-pass/getopts_ref.rs
@@ -17,7 +17,7 @@ use getopts::{optopt, getopts};
 
 pub fn main() {
     let args = Vec::new();
-    let opts = vec!(optopt("b", "", "something", "SMTHNG"));
+    let opts = vec![optopt("b", "", "something", "SMTHNG")];
 
     match getopts(&args, &opts) {
         Ok(ref m)  =>
diff --git a/src/test/run-pass/hashmap-memory.rs b/src/test/run-pass/hashmap-memory.rs
index 8efc4cb1b1725..2306fa9afa2ef 100644
--- a/src/test/run-pass/hashmap-memory.rs
+++ b/src/test/run-pass/hashmap-memory.rs
@@ -99,5 +99,5 @@ mod map_reduce {
 
 pub fn main() {
     map_reduce::map_reduce(
-        vec!("../src/test/run-pass/hashmap-memory.rs".to_string()));
+        vec!["../src/test/run-pass/hashmap-memory.rs".to_string()]);
 }
diff --git a/src/test/run-pass/html-literals.rs b/src/test/run-pass/html-literals.rs
index a9cfe7a380261..1e1fde4d1e2be 100644
--- a/src/test/run-pass/html-literals.rs
+++ b/src/test/run-pass/html-literals.rs
@@ -40,7 +40,7 @@ macro_rules! parse_node {
         parse_node!(
             [$(: $tags ($(:$tag_nodes),*))*];
             [$(:$head_nodes,)* :tag(stringify!($head).to_string(),
-                                    vec!($($nodes),*))];
+                                    vec![$($nodes),*])];
             $($rest)*
         )
     );
diff --git a/src/test/run-pass/ifmt.rs b/src/test/run-pass/ifmt.rs
index c9af2b190b21c..2a7a593d26800 100644
--- a/src/test/run-pass/ifmt.rs
+++ b/src/test/run-pass/ifmt.rs
@@ -237,7 +237,7 @@ fn test_write() {
 // can do with them just yet (to test the output)
 fn test_print() {
     print!("hi");
-    print!("{:?}", vec!(0u8));
+    print!("{:?}", vec![0u8]);
     println!("hello");
     println!("this is a {}", "test");
     println!("{foo}", foo="bar");
diff --git a/src/test/run-pass/issue-13204.rs b/src/test/run-pass/issue-13204.rs
index 36f606e5d73c9..13e8fe0e964c4 100644
--- a/src/test/run-pass/issue-13204.rs
+++ b/src/test/run-pass/issue-13204.rs
@@ -28,6 +28,6 @@ impl Foo for Baz {
 
 fn main() {
     let x = Baz;
-    let y = vec!((), (), ());
+    let y = vec![(), (), ()];
     assert_eq!(x.bar(y.iter()), 3);
 }
diff --git a/src/test/run-pass/issue-14936.rs b/src/test/run-pass/issue-14936.rs
index 428d4e4dbb12d..8a628b73c0067 100644
--- a/src/test/run-pass/issue-14936.rs
+++ b/src/test/run-pass/issue-14936.rs
@@ -24,7 +24,7 @@ macro_rules! demo {
             let mut x: isize = 0;
             let y: isize = 1;
 
-            let mut history: History = vec!();
+            let mut history: History = vec![];
             unsafe {
                 asm!("mov ($1), $0"
                      : $output_constraint (*wrap(&mut x, "out", &mut history))
diff --git a/src/test/run-pass/issue-15080.rs b/src/test/run-pass/issue-15080.rs
index cee0caeb465f5..14e0037884698 100644
--- a/src/test/run-pass/issue-15080.rs
+++ b/src/test/run-pass/issue-15080.rs
@@ -14,7 +14,7 @@
 fn main() {
     let mut x: &[_] = &[1, 2, 3, 4];
 
-    let mut result = vec!();
+    let mut result = vec![];
     loop {
         x = match *x {
             [1, n, 3, ref rest..] => {
diff --git a/src/test/run-pass/issue-15189.rs b/src/test/run-pass/issue-15189.rs
index 35faa5789a9c8..54b96d6630749 100644
--- a/src/test/run-pass/issue-15189.rs
+++ b/src/test/run-pass/issue-15189.rs
@@ -13,7 +13,7 @@ macro_rules! third {
 }
 
 fn main() {
-    let x = vec!(10_usize,11_usize,12_usize,13_usize);
+    let x = vec![10_usize,11_usize,12_usize,13_usize];
     let t = third!(x);
     assert_eq!(t,12_usize);
 }
diff --git a/src/test/run-pass/issue-15734.rs b/src/test/run-pass/issue-15734.rs
index 66b0aeeb988d7..daf14b4c2ffc4 100644
--- a/src/test/run-pass/issue-15734.rs
+++ b/src/test/run-pass/issue-15734.rs
@@ -54,7 +54,7 @@ impl<T, M: Index<(usize, usize), Output=T>> Index<usize> for Row<M> {
 }
 
 fn main() {
-    let m = Mat::new(vec!(1, 2, 3, 4, 5, 6), 3);
+    let m = Mat::new(vec![1, 2, 3, 4, 5, 6], 3);
     let r = m.row(1);
 
     assert_eq!(r.index(2), &6);
diff --git a/src/test/run-pass/issue-2631-b.rs b/src/test/run-pass/issue-2631-b.rs
index 365b594c99e36..913b07613e030 100644
--- a/src/test/run-pass/issue-2631-b.rs
+++ b/src/test/run-pass/issue-2631-b.rs
@@ -19,7 +19,7 @@ use std::collections::HashMap;
 use std::rc::Rc;
 
 pub fn main() {
-  let v = vec!(Rc::new("hi".to_string()));
+  let v = vec![Rc::new("hi".to_string())];
   let mut m: req::header_map = HashMap::new();
   m.insert("METHOD".to_string(), Rc::new(RefCell::new(v)));
   request::<isize>(&m);
diff --git a/src/test/run-pass/issue-2723-b.rs b/src/test/run-pass/issue-2723-b.rs
index bab7b0d24db70..a6ba957a1b110 100644
--- a/src/test/run-pass/issue-2723-b.rs
+++ b/src/test/run-pass/issue-2723-b.rs
@@ -15,6 +15,6 @@ use issue_2723_a::f;
 
 pub fn main() {
     unsafe {
-        f(vec!(2));
+        f(vec![2]);
     }
 }
diff --git a/src/test/run-pass/issue-28936.rs b/src/test/run-pass/issue-28936.rs
index 2a932cd7756d2..992fbdce26898 100644
--- a/src/test/run-pass/issue-28936.rs
+++ b/src/test/run-pass/issue-28936.rs
@@ -23,7 +23,7 @@ pub fn parse_stream<T: Iterator<Item=i32>, U, F>(
     where F: Fn(&mut StreamParser<T>) -> U { panic!(); }
 
 pub fn thing(session: &mut Session) {
-    let mut stream = vec!(1, 2, 3).into_iter();
+    let mut stream = vec![1, 2, 3].into_iter();
 
     let _b = parse_stream(session,
                           stream.by_ref(),
diff --git a/src/test/run-pass/issue-2989.rs b/src/test/run-pass/issue-2989.rs
index 8b6eb12f102ee..a4342f33402d3 100644
--- a/src/test/run-pass/issue-2989.rs
+++ b/src/test/run-pass/issue-2989.rs
@@ -32,8 +32,8 @@ fn to_bools(bitv: Storage) -> Vec<bool> {
 struct Storage { storage: Vec<u64> }
 
 pub fn main() {
-    let bools = vec!(false, false, true, false, false, true, true, false);
-    let bools2 = to_bools(Storage{storage: vec!(0b01100100)});
+    let bools = vec![false, false, true, false, false, true, true, false];
+    let bools2 = to_bools(Storage{storage: vec![0b01100100]});
 
     for i in 0..8 {
         println!("{} => {} vs {}", i, bools[i], bools2[i]);
diff --git a/src/test/run-pass/issue-3389.rs b/src/test/run-pass/issue-3389.rs
index 26558bdd30c3b..70e3484a0c57a 100644
--- a/src/test/run-pass/issue-3389.rs
+++ b/src/test/run-pass/issue-3389.rs
@@ -25,8 +25,8 @@ pub fn main() {
         content: Vec::new(),
         children: Vec::new()
     };
-    let v = vec!("123".to_string(), "abc".to_string());
-    node.content = vec!("123".to_string(), "abc".to_string());
+    let v = vec!["123".to_string(), "abc".to_string()];
+    node.content = vec!["123".to_string(), "abc".to_string()];
     print_str_vector(v);
     print_str_vector(node.content.clone());
 
diff --git a/src/test/run-pass/issue-6153.rs b/src/test/run-pass/issue-6153.rs
index 16e7060f4b9f1..1b16418ac4259 100644
--- a/src/test/run-pass/issue-6153.rs
+++ b/src/test/run-pass/issue-6153.rs
@@ -11,7 +11,7 @@
 
 
 fn swap<F>(f: F) -> Vec<isize> where F: FnOnce(Vec<isize>) -> Vec<isize> {
-    let x = vec!(1, 2, 3);
+    let x = vec![1, 2, 3];
     f(x)
 }
 
diff --git a/src/test/run-pass/ivec-pass-by-value.rs b/src/test/run-pass/ivec-pass-by-value.rs
index 5b40105a97916..e3b42e60645a3 100644
--- a/src/test/run-pass/ivec-pass-by-value.rs
+++ b/src/test/run-pass/ivec-pass-by-value.rs
@@ -9,4 +9,4 @@
 // except according to those terms.
 
 fn f(_a: Vec<isize> ) { }
-pub fn main() { f(vec!(1, 2, 3, 4, 5)); }
+pub fn main() { f(vec![1, 2, 3, 4, 5]); }
diff --git a/src/test/run-pass/ivec-tag.rs b/src/test/run-pass/ivec-tag.rs
index b8238774bc1e0..a511db8e9397d 100644
--- a/src/test/run-pass/ivec-tag.rs
+++ b/src/test/run-pass/ivec-tag.rs
@@ -17,8 +17,8 @@ use std::sync::mpsc::{channel, Sender};
 
 fn producer(tx: &Sender<Vec<u8>>) {
     tx.send(
-         vec!(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12,
-          13)).unwrap();
+         vec![1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12,
+          13]).unwrap();
 }
 
 pub fn main() {
diff --git a/src/test/run-pass/lambda-infer-unresolved.rs b/src/test/run-pass/lambda-infer-unresolved.rs
index fca700f6e4a84..5109c6fc77726 100644
--- a/src/test/run-pass/lambda-infer-unresolved.rs
+++ b/src/test/run-pass/lambda-infer-unresolved.rs
@@ -15,7 +15,7 @@
 struct Refs { refs: Vec<isize> , n: isize }
 
 pub fn main() {
-    let mut e = Refs{refs: vec!(), n: 0};
+    let mut e = Refs{refs: vec![], n: 0};
     let _f = || println!("{}", e.n);
     let x: &[isize] = &e.refs;
     assert_eq!(x.len(), 0);
diff --git a/src/test/run-pass/linear-for-loop.rs b/src/test/run-pass/linear-for-loop.rs
index 3da2fc8ceacf7..fc6d435b034be 100644
--- a/src/test/run-pass/linear-for-loop.rs
+++ b/src/test/run-pass/linear-for-loop.rs
@@ -9,7 +9,7 @@
 // except according to those terms.
 
 pub fn main() {
-    let x = vec!(1, 2, 3);
+    let x = vec![1, 2, 3];
     let mut y = 0;
     for i in &x { println!("{}", *i); y += *i; }
     println!("{}", y);
diff --git a/src/test/run-pass/log-poly.rs b/src/test/run-pass/log-poly.rs
index d8a69177cafcc..b54b4692a41bf 100644
--- a/src/test/run-pass/log-poly.rs
+++ b/src/test/run-pass/log-poly.rs
@@ -17,5 +17,5 @@ pub fn main() {
     println!("{:?}", 1);
     println!("{:?}", 2.0f64);
     println!("{:?}", Numbers::Three);
-    println!("{:?}", vec!(4));
+    println!("{:?}", vec![4]);
 }
diff --git a/src/test/run-pass/loop-scope.rs b/src/test/run-pass/loop-scope.rs
index 0c1e7916cdb18..6916bfb8c616a 100644
--- a/src/test/run-pass/loop-scope.rs
+++ b/src/test/run-pass/loop-scope.rs
@@ -10,7 +10,7 @@
 
 
 pub fn main() {
-    let x = vec!(10, 20, 30);
+    let x = vec![10, 20, 30];
     let mut sum = 0;
     for x in &x { sum += *x; }
     assert_eq!(sum, 60);
diff --git a/src/test/run-pass/match-vec-rvalue.rs b/src/test/run-pass/match-vec-rvalue.rs
index a10f9b1d7d61b..3d221927b96e1 100644
--- a/src/test/run-pass/match-vec-rvalue.rs
+++ b/src/test/run-pass/match-vec-rvalue.rs
@@ -13,7 +13,7 @@
 
 
 pub fn main() {
-    match vec!(1, 2, 3) {
+    match vec![1, 2, 3] {
         x => {
             assert_eq!(x.len(), 3);
             assert_eq!(x[0], 1);
diff --git a/src/test/run-pass/monad.rs b/src/test/run-pass/monad.rs
index b28e5ec64de34..211827f92222c 100644
--- a/src/test/run-pass/monad.rs
+++ b/src/test/run-pass/monad.rs
@@ -45,9 +45,9 @@ fn transform(x: Option<isize>) -> Option<String> {
 pub fn main() {
     assert_eq!(transform(Some(10)), Some("11".to_string()));
     assert_eq!(transform(None), None);
-    assert_eq!((vec!("hi".to_string()))
-        .bind(|x| vec!(x.clone(), format!("{}!", x)) )
-        .bind(|x| vec!(x.clone(), format!("{}?", x)) ),
+    assert_eq!((vec!["hi".to_string()])
+        .bind(|x| vec![x.clone(), format!("{}!", x)] )
+        .bind(|x| vec![x.clone(), format!("{}?", x)] ),
         ["hi".to_string(),
          "hi?".to_string(),
          "hi!".to_string(),
diff --git a/src/test/run-pass/move-arg-2-unique.rs b/src/test/run-pass/move-arg-2-unique.rs
index bed339e158637..0ff5a66adc269 100644
--- a/src/test/run-pass/move-arg-2-unique.rs
+++ b/src/test/run-pass/move-arg-2-unique.rs
@@ -15,10 +15,10 @@
 fn test(foo: Box<Vec<isize>> ) { assert_eq!((*foo)[0], 10); }
 
 pub fn main() {
-    let x = box vec!(10);
+    let x = box vec![10];
     // Test forgetting a local by move-in
     test(x);
 
     // Test forgetting a temporary by move-in.
-    test(box vec!(10));
+    test(box vec![10]);
 }
diff --git a/src/test/run-pass/move-arg-2.rs b/src/test/run-pass/move-arg-2.rs
index a6a26ab357876..8de487bc3631c 100644
--- a/src/test/run-pass/move-arg-2.rs
+++ b/src/test/run-pass/move-arg-2.rs
@@ -15,10 +15,10 @@
 fn test(foo: Box<Vec<isize>>) { assert_eq!((*foo)[0], 10); }
 
 pub fn main() {
-    let x = box vec!(10);
+    let x = box vec![10];
     // Test forgetting a local by move-in
     test(x);
 
     // Test forgetting a temporary by move-in.
-    test(box vec!(10));
+    test(box vec![10]);
 }
diff --git a/src/test/run-pass/newtype-polymorphic.rs b/src/test/run-pass/newtype-polymorphic.rs
index 91599608ceed6..e7da8d7bf93c7 100644
--- a/src/test/run-pass/newtype-polymorphic.rs
+++ b/src/test/run-pass/newtype-polymorphic.rs
@@ -24,7 +24,7 @@ fn myvec_elt<X>(mv: myvec<X>) -> X {
 }
 
 pub fn main() {
-    let mv = myvec(vec!(1, 2, 3));
+    let mv = myvec(vec![1, 2, 3]);
     let mv_clone = mv.clone();
     let mv_clone = myvec_deref(mv_clone);
     assert_eq!(mv_clone[1], 2);
diff --git a/src/test/run-pass/nullable-pointer-iotareduction.rs b/src/test/run-pass/nullable-pointer-iotareduction.rs
index dffdcfe0af562..7e8d082a286a8 100644
--- a/src/test/run-pass/nullable-pointer-iotareduction.rs
+++ b/src/test/run-pass/nullable-pointer-iotareduction.rs
@@ -76,7 +76,7 @@ pub fn main() {
     check_type!(&17, &isize);
     check_type!(box 18, Box<isize>);
     check_type!("foo".to_string(), String);
-    check_type!(vec!(20, 22), Vec<isize>);
+    check_type!(vec![20, 22], Vec<isize>);
     check_type!(main, fn(), |pthing| {
         assert_eq!(main as fn(), *pthing as fn())
     });
diff --git a/src/test/run-pass/objects-owned-object-borrowed-method-headerless.rs b/src/test/run-pass/objects-owned-object-borrowed-method-headerless.rs
index 176f67fd3a18a..768f126e4edfe 100644
--- a/src/test/run-pass/objects-owned-object-borrowed-method-headerless.rs
+++ b/src/test/run-pass/objects-owned-object-borrowed-method-headerless.rs
@@ -32,11 +32,11 @@ impl FooTrait for BarStruct {
 }
 
 pub fn main() {
-    let foos: Vec<Box<FooTrait>> = vec!(
+    let foos: Vec<Box<FooTrait>> = vec![
         box BarStruct{ x: 0 } as Box<FooTrait>,
         box BarStruct{ x: 1 } as Box<FooTrait>,
         box BarStruct{ x: 2 } as Box<FooTrait>
-    );
+    ];
 
     for i in 0..foos.len() {
         assert_eq!(i, foos[i].foo());
diff --git a/src/test/run-pass/overloaded-deref.rs b/src/test/run-pass/overloaded-deref.rs
index 8541c1c0a8986..e2ca880719a8e 100644
--- a/src/test/run-pass/overloaded-deref.rs
+++ b/src/test/run-pass/overloaded-deref.rs
@@ -45,7 +45,7 @@ pub fn main() {
     (*(*p).borrow_mut()).y += 3;
     assert_eq!(*(*p).borrow(), Point {x: 3, y: 5});
 
-    let v = Rc::new(RefCell::new(vec!(1, 2, 3)));
+    let v = Rc::new(RefCell::new(vec![1, 2, 3]));
     (*(*v).borrow_mut())[0] = 3;
     (*(*v).borrow_mut())[1] += 3;
     assert_eq!(((*(*v).borrow())[0],
diff --git a/src/test/run-pass/rcvr-borrowed-to-slice.rs b/src/test/run-pass/rcvr-borrowed-to-slice.rs
index 1ec16747181c2..efa73ad92ce83 100644
--- a/src/test/run-pass/rcvr-borrowed-to-slice.rs
+++ b/src/test/run-pass/rcvr-borrowed-to-slice.rs
@@ -23,17 +23,17 @@ impl<'a> sum for &'a [isize] {
 fn call_sum(x: &[isize]) -> isize { x.sum_() }
 
 pub fn main() {
-    let x = vec!(1, 2, 3);
+    let x = vec![1, 2, 3];
     let y = call_sum(&x);
     println!("y=={}", y);
     assert_eq!(y, 6);
 
-    let x = vec!(1, 2, 3);
+    let x = vec![1, 2, 3];
     let y = x.sum_();
     println!("y=={}", y);
     assert_eq!(y, 6);
 
-    let x = vec!(1, 2, 3);
+    let x = vec![1, 2, 3];
     let y = x.sum_();
     println!("y=={}", y);
     assert_eq!(y, 6);
diff --git a/src/test/run-pass/regions-borrow-evec-uniq.rs b/src/test/run-pass/regions-borrow-evec-uniq.rs
index ec1f4eda28cc5..e61a8d147757c 100644
--- a/src/test/run-pass/regions-borrow-evec-uniq.rs
+++ b/src/test/run-pass/regions-borrow-evec-uniq.rs
@@ -15,11 +15,11 @@ fn foo(x: &[isize]) -> isize {
 }
 
 pub fn main() {
-    let p = vec!(1,2,3,4,5);
+    let p = vec![1,2,3,4,5];
     let r = foo(&p);
     assert_eq!(r, 1);
 
-    let p = vec!(5,4,3,2,1);
+    let p = vec![5,4,3,2,1];
     let r = foo(&p);
     assert_eq!(r, 5);
 }
diff --git a/src/test/run-pass/regions-dependent-addr-of.rs b/src/test/run-pass/regions-dependent-addr-of.rs
index a6a179c432c3c..e9a3e16438f81 100644
--- a/src/test/run-pass/regions-dependent-addr-of.rs
+++ b/src/test/run-pass/regions-dependent-addr-of.rs
@@ -90,7 +90,7 @@ fn get_v5_ref(a: &A, _i: usize) -> &isize {
 pub fn main() {
     let a = A {value: B {v1: 22,
                          v2: [23, 24, 25],
-                         v3: vec!(26, 27, 28),
+                         v3: vec![26, 27, 28],
                          v4: C { f: 29 },
                          v5: box C { f: 30 },
                          v6: Some(C { f: 31 })}};
diff --git a/src/test/run-pass/regions-dependent-autoslice.rs b/src/test/run-pass/regions-dependent-autoslice.rs
index 7183937fe8035..cd140f7aa599b 100644
--- a/src/test/run-pass/regions-dependent-autoslice.rs
+++ b/src/test/run-pass/regions-dependent-autoslice.rs
@@ -18,6 +18,6 @@ fn both<'r>(v: &'r [usize]) -> &'r [usize] {
 }
 
 pub fn main() {
-    let v = vec!(1,2,3);
+    let v = vec![1,2,3];
     both(&v);
 }
diff --git a/src/test/run-pass/regions-infer-borrow-scope-view.rs b/src/test/run-pass/regions-infer-borrow-scope-view.rs
index f9ba8e82ef715..262e936826e51 100644
--- a/src/test/run-pass/regions-infer-borrow-scope-view.rs
+++ b/src/test/run-pass/regions-infer-borrow-scope-view.rs
@@ -13,7 +13,7 @@
 fn view<T>(x: &[T]) -> &[T] {x}
 
 pub fn main() {
-    let v = vec!(1, 2, 3);
+    let v = vec![1, 2, 3];
     let x = view(&v);
     let y = view(x);
     assert!((v[0] == x[0]) && (v[0] == y[0]));
diff --git a/src/test/run-pass/regions-relate-bound-regions-on-closures-to-inference-variables.rs b/src/test/run-pass/regions-relate-bound-regions-on-closures-to-inference-variables.rs
index 465f43e36b94f..8eee54b3fec66 100644
--- a/src/test/run-pass/regions-relate-bound-regions-on-closures-to-inference-variables.rs
+++ b/src/test/run-pass/regions-relate-bound-regions-on-closures-to-inference-variables.rs
@@ -63,7 +63,7 @@ impl<'a,'tcx> Foo<'a,'tcx> {
 }
 
 fn main() {
-    let v = vec!();
+    let v = vec![];
     let cx = Ctxt { x: &v };
     let mut foo = Foo { cx: &cx };
     assert_eq!(foo.bother(), 22); // just so the code is not dead, basically
diff --git a/src/test/run-pass/seq-compare.rs b/src/test/run-pass/seq-compare.rs
index f1a21d90ab2dc..43612f529772a 100644
--- a/src/test/run-pass/seq-compare.rs
+++ b/src/test/run-pass/seq-compare.rs
@@ -14,13 +14,13 @@ pub fn main() {
     assert!(("hello".to_string() < "hellr".to_string()));
     assert!(("hello ".to_string() > "hello".to_string()));
     assert!(("hello".to_string() != "there".to_string()));
-    assert!((vec!(1, 2, 3, 4) > vec!(1, 2, 3)));
-    assert!((vec!(1, 2, 3) < vec!(1, 2, 3, 4)));
-    assert!((vec!(1, 2, 4, 4) > vec!(1, 2, 3, 4)));
-    assert!((vec!(1, 2, 3, 4) < vec!(1, 2, 4, 4)));
-    assert!((vec!(1, 2, 3) <= vec!(1, 2, 3)));
-    assert!((vec!(1, 2, 3) <= vec!(1, 2, 3, 3)));
-    assert!((vec!(1, 2, 3, 4) > vec!(1, 2, 3)));
-    assert_eq!(vec!(1, 2, 3), vec!(1, 2, 3));
-    assert!((vec!(1, 2, 3) != vec!(1, 1, 3)));
+    assert!((vec![1, 2, 3, 4] > vec![1, 2, 3]));
+    assert!((vec![1, 2, 3] < vec![1, 2, 3, 4]));
+    assert!((vec![1, 2, 4, 4] > vec![1, 2, 3, 4]));
+    assert!((vec![1, 2, 3, 4] < vec![1, 2, 4, 4]));
+    assert!((vec![1, 2, 3] <= vec![1, 2, 3]));
+    assert!((vec![1, 2, 3] <= vec![1, 2, 3, 3]));
+    assert!((vec![1, 2, 3, 4] > vec![1, 2, 3]));
+    assert_eq!(vec![1, 2, 3], vec![1, 2, 3]);
+    assert!((vec![1, 2, 3] != vec![1, 1, 3]));
 }
diff --git a/src/test/run-pass/size-and-align.rs b/src/test/run-pass/size-and-align.rs
index 007ce52d7c455..13d55e0172e71 100644
--- a/src/test/run-pass/size-and-align.rs
+++ b/src/test/run-pass/size-and-align.rs
@@ -22,6 +22,6 @@ fn uhoh<T>(v: Vec<clam<T>> ) {
 }
 
 pub fn main() {
-    let v: Vec<clam<isize>> = vec!(clam::b::<isize>, clam::b::<isize>, clam::a::<isize>(42, 17));
+    let v: Vec<clam<isize>> = vec![clam::b::<isize>, clam::b::<isize>, clam::a::<isize>(42, 17)];
     uhoh::<isize>(v);
 }
diff --git a/src/test/run-pass/static-impl.rs b/src/test/run-pass/static-impl.rs
index 84bb1b871b97e..89fd83ced4c8c 100644
--- a/src/test/run-pass/static-impl.rs
+++ b/src/test/run-pass/static-impl.rs
@@ -62,10 +62,10 @@ pub fn main() {
     assert_eq!(10_usize.plus(), 30);
     assert_eq!(("hi".to_string()).plus(), 200);
 
-    assert_eq!((vec!(1)).length_().str(), "1".to_string());
-    let vect = vec!(3, 4).map_(|a| *a + 4);
+    assert_eq!((vec![1]).length_().str(), "1".to_string());
+    let vect = vec![3, 4].map_(|a| *a + 4);
     assert_eq!(vect[0], 7);
-    let vect = (vec!(3, 4)).map_::<usize, _>(|a| *a as usize + 4_usize);
+    let vect = (vec![3, 4]).map_::<usize, _>(|a| *a as usize + 4_usize);
     assert_eq!(vect[0], 7_usize);
     let mut x = 0_usize;
     10_usize.multi(|_n| x += 2_usize );
diff --git a/src/test/run-pass/swap-2.rs b/src/test/run-pass/swap-2.rs
index 3dbd7f1a60126..4601b7d7cf567 100644
--- a/src/test/run-pass/swap-2.rs
+++ b/src/test/run-pass/swap-2.rs
@@ -12,7 +12,7 @@
 use std::mem::swap;
 
 pub fn main() {
-    let mut a: Vec<isize> = vec!(0, 1, 2, 3, 4, 5, 6);
+    let mut a: Vec<isize> = vec![0, 1, 2, 3, 4, 5, 6];
     a.swap(2, 4);
     assert_eq!(a[2], 4);
     assert_eq!(a[4], 2);
diff --git a/src/test/run-pass/task-comm-16.rs b/src/test/run-pass/task-comm-16.rs
index c6d8f3c0d9b0b..0caf21ead3969 100644
--- a/src/test/run-pass/task-comm-16.rs
+++ b/src/test/run-pass/task-comm-16.rs
@@ -27,7 +27,7 @@ fn test_rec() {
 
 fn test_vec() {
     let (tx, rx) = channel();
-    let v0: Vec<isize> = vec!(0, 1, 2);
+    let v0: Vec<isize> = vec![0, 1, 2];
     tx.send(v0).unwrap();
     let v1 = rx.recv().unwrap();
     assert_eq!(v1[0], 0);
diff --git a/src/test/run-pass/trait-bounds-in-arc.rs b/src/test/run-pass/trait-bounds-in-arc.rs
index f7fd86c957070..9877dffe9df02 100644
--- a/src/test/run-pass/trait-bounds-in-arc.rs
+++ b/src/test/run-pass/trait-bounds-in-arc.rs
@@ -75,10 +75,10 @@ pub fn main() {
         swim_speed: 998,
         name: "alec_guinness".to_string(),
     };
-    let arc = Arc::new(vec!(box catte  as Box<Pet+Sync+Send>,
+    let arc = Arc::new(vec![box catte  as Box<Pet+Sync+Send>,
                             box dogge1 as Box<Pet+Sync+Send>,
                             box fishe  as Box<Pet+Sync+Send>,
-                            box dogge2 as Box<Pet+Sync+Send>));
+                            box dogge2 as Box<Pet+Sync+Send>]);
     let (tx1, rx1) = channel();
     let arc1 = arc.clone();
     let t1 = thread::spawn(move|| { check_legs(arc1); tx1.send(()); });
diff --git a/src/test/run-pass/trait-generic.rs b/src/test/run-pass/trait-generic.rs
index 4998236629153..eadda5dfe299c 100644
--- a/src/test/run-pass/trait-generic.rs
+++ b/src/test/run-pass/trait-generic.rs
@@ -45,9 +45,9 @@ fn bar<U:to_str,T:map<U>>(x: T) -> Vec<String> {
 }
 
 pub fn main() {
-    assert_eq!(foo(vec!(1)), ["hi".to_string()]);
-    assert_eq!(bar::<isize, Vec<isize> >(vec!(4, 5)), ["4".to_string(), "5".to_string()]);
-    assert_eq!(bar::<String, Vec<String> >(vec!("x".to_string(), "y".to_string())),
+    assert_eq!(foo(vec![1]), ["hi".to_string()]);
+    assert_eq!(bar::<isize, Vec<isize> >(vec![4, 5]), ["4".to_string(), "5".to_string()]);
+    assert_eq!(bar::<String, Vec<String> >(vec!["x".to_string(), "y".to_string()]),
                ["x".to_string(), "y".to_string()]);
-    assert_eq!(bar::<(), Vec<()>>(vec!(())), ["()".to_string()]);
+    assert_eq!(bar::<(), Vec<()>>(vec![()]), ["()".to_string()]);
 }
diff --git a/src/test/run-pass/trait-to-str.rs b/src/test/run-pass/trait-to-str.rs
index f5af05d872bd4..9671e31d7e48c 100644
--- a/src/test/run-pass/trait-to-str.rs
+++ b/src/test/run-pass/trait-to-str.rs
@@ -30,15 +30,15 @@ impl<T:to_str> to_str for Vec<T> {
 
 pub fn main() {
     assert_eq!(1.to_string_(), "1".to_string());
-    assert_eq!((vec!(2, 3, 4)).to_string_(), "[2, 3, 4]".to_string());
+    assert_eq!((vec![2, 3, 4]).to_string_(), "[2, 3, 4]".to_string());
 
     fn indirect<T:to_str>(x: T) -> String {
         format!("{}!", x.to_string_())
     }
-    assert_eq!(indirect(vec!(10, 20)), "[10, 20]!".to_string());
+    assert_eq!(indirect(vec![10, 20]), "[10, 20]!".to_string());
 
     fn indirect2<T:to_str>(x: T) -> String {
         indirect(x)
     }
-    assert_eq!(indirect2(vec!(1)), "[1]!".to_string());
+    assert_eq!(indirect2(vec![1]), "[1]!".to_string());
 }
diff --git a/src/test/run-pass/unboxed-closures-counter-not-moved.rs b/src/test/run-pass/unboxed-closures-counter-not-moved.rs
index 0b85916d22410..300a0ee63f817 100644
--- a/src/test/run-pass/unboxed-closures-counter-not-moved.rs
+++ b/src/test/run-pass/unboxed-closures-counter-not-moved.rs
@@ -15,7 +15,7 @@ fn call<F>(f: F) where F : FnOnce() {
 }
 
 fn main() {
-    let y = vec!(format!("Hello"), format!("World"));
+    let y = vec![format!("Hello"), format!("World")];
     let mut counter = 22_u32;
 
     call(|| {
diff --git a/src/test/run-pass/unboxed-closures-move-some-upvars-in-by-ref-closure.rs b/src/test/run-pass/unboxed-closures-move-some-upvars-in-by-ref-closure.rs
index 99663646254e7..b9a16535c420a 100644
--- a/src/test/run-pass/unboxed-closures-move-some-upvars-in-by-ref-closure.rs
+++ b/src/test/run-pass/unboxed-closures-move-some-upvars-in-by-ref-closure.rs
@@ -16,8 +16,8 @@ fn call<F>(f: F) where F : FnOnce() {
 }
 
 fn main() {
-    let mut x = vec!(format!("Hello"));
-    let y = vec!(format!("World"));
+    let mut x = vec![format!("Hello")];
+    let y = vec![format!("World")];
     call(|| {
         // Here: `x` must be captured with a mutable reference in
         // order for us to append on it, and `y` must be captured by
diff --git a/src/test/run-pass/unique-autoderef-index.rs b/src/test/run-pass/unique-autoderef-index.rs
index c68ff1f0612f5..1ef61008b3c2b 100644
--- a/src/test/run-pass/unique-autoderef-index.rs
+++ b/src/test/run-pass/unique-autoderef-index.rs
@@ -13,6 +13,6 @@
 #![feature(box_syntax)]
 
 pub fn main() {
-    let i: Box<_> = box vec!(100);
+    let i: Box<_> = box vec![100];
     assert_eq!((*i)[0], 100);
 }
diff --git a/src/test/run-pass/unique-create.rs b/src/test/run-pass/unique-create.rs
index 8469ae702009a..6d638bbf562c7 100644
--- a/src/test/run-pass/unique-create.rs
+++ b/src/test/run-pass/unique-create.rs
@@ -18,5 +18,5 @@ pub fn main() {
 }
 
 fn vec() {
-    vec!(0);
+    vec![0];
 }
diff --git a/src/test/run-pass/unique-drop-complex.rs b/src/test/run-pass/unique-drop-complex.rs
index 056acd162082b..1910d51bd0bcb 100644
--- a/src/test/run-pass/unique-drop-complex.rs
+++ b/src/test/run-pass/unique-drop-complex.rs
@@ -14,5 +14,5 @@
 #![feature(box_syntax)]
 
 pub fn main() {
-    let _x: Box<_> = box vec!(0,0,0,0,0);
+    let _x: Box<_> = box vec![0,0,0,0,0];
 }
diff --git a/src/test/run-pass/unique-in-vec-copy.rs b/src/test/run-pass/unique-in-vec-copy.rs
index ab0e3ee809dbd..ece206caa02e5 100644
--- a/src/test/run-pass/unique-in-vec-copy.rs
+++ b/src/test/run-pass/unique-in-vec-copy.rs
@@ -13,7 +13,7 @@
 #![feature(box_syntax)]
 
 pub fn main() {
-    let mut a: Vec<Box<_>> = vec!(box 10);
+    let mut a: Vec<Box<_>> = vec![box 10];
     let b = a.clone();
 
     assert_eq!(*a[0], 10);
diff --git a/src/test/run-pass/unique-in-vec.rs b/src/test/run-pass/unique-in-vec.rs
index 026bc0435d91c..bd965d41eea2c 100644
--- a/src/test/run-pass/unique-in-vec.rs
+++ b/src/test/run-pass/unique-in-vec.rs
@@ -13,6 +13,6 @@
 #![feature(box_syntax)]
 
 pub fn main() {
-    let vect : Vec<Box<_>> = vec!(box 100);
+    let vect : Vec<Box<_>> = vec![box 100];
     assert_eq!(vect[0], box 100);
 }
diff --git a/src/test/run-pass/utf8_chars.rs b/src/test/run-pass/utf8_chars.rs
index 0f751501293f5..0a984429fabbf 100644
--- a/src/test/run-pass/utf8_chars.rs
+++ b/src/test/run-pass/utf8_chars.rs
@@ -15,7 +15,7 @@ use std::str;
 
 pub fn main() {
     // Chars of 1, 2, 3, and 4 bytes
-    let chs: Vec<char> = vec!('e', 'é', '€', '\u{10000}');
+    let chs: Vec<char> = vec!['e', 'é', '€', '\u{10000}'];
     let s: String = chs.iter().cloned().collect();
     let schs: Vec<char> = s.chars().collect();
 
diff --git a/src/test/run-pass/vec-concat.rs b/src/test/run-pass/vec-concat.rs
index 5fe9dd60591ce..8ba8df57e542c 100644
--- a/src/test/run-pass/vec-concat.rs
+++ b/src/test/run-pass/vec-concat.rs
@@ -11,8 +11,8 @@
 use std::vec;
 
 pub fn main() {
-    let a: Vec<isize> = vec!(1, 2, 3, 4, 5);
-    let b: Vec<isize> = vec!(6, 7, 8, 9, 0);
+    let a: Vec<isize> = vec![1, 2, 3, 4, 5];
+    let b: Vec<isize> = vec![6, 7, 8, 9, 0];
     let mut v: Vec<isize> = a;
     v.extend_from_slice(&b);
     println!("{}", v[9]);
diff --git a/src/test/run-pass/vec-growth.rs b/src/test/run-pass/vec-growth.rs
index e51d898e1d46e..5bf6a457df9b3 100644
--- a/src/test/run-pass/vec-growth.rs
+++ b/src/test/run-pass/vec-growth.rs
@@ -11,7 +11,7 @@
 
 
 pub fn main() {
-    let mut v = vec!(1);
+    let mut v = vec![1];
     v.push(2);
     v.push(3);
     v.push(4);
diff --git a/src/test/run-pass/vec-late-init.rs b/src/test/run-pass/vec-late-init.rs
index 7a8c0739efeb9..420f6a429f1f8 100644
--- a/src/test/run-pass/vec-late-init.rs
+++ b/src/test/run-pass/vec-late-init.rs
@@ -11,6 +11,6 @@
 
 pub fn main() {
     let mut later: Vec<isize> ;
-    if true { later = vec!(1); } else { later = vec!(2); }
+    if true { later = vec![1]; } else { later = vec![2]; }
     println!("{}", later[0]);
 }
diff --git a/src/test/run-pass/vec-macro-with-trailing-comma.rs b/src/test/run-pass/vec-macro-with-trailing-comma.rs
index 35af249ef5fad..135ecb4749845 100644
--- a/src/test/run-pass/vec-macro-with-trailing-comma.rs
+++ b/src/test/run-pass/vec-macro-with-trailing-comma.rs
@@ -11,6 +11,6 @@
 
 
 pub fn main() {
-    assert_eq!(vec!(1), vec!(1,));
-    assert_eq!(vec!(1, 2, 3), vec!(1, 2, 3,));
+    assert_eq!(vec![1], vec![1,]);
+    assert_eq!(vec![1, 2, 3], vec![1, 2, 3,]);
 }
diff --git a/src/test/run-pass/vec-push.rs b/src/test/run-pass/vec-push.rs
index 33f01c5bd41c8..14a52cc4b5c55 100644
--- a/src/test/run-pass/vec-push.rs
+++ b/src/test/run-pass/vec-push.rs
@@ -8,4 +8,4 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-pub fn main() { let mut v = vec!(1, 2, 3); v.push(1); }
+pub fn main() { let mut v = vec![1, 2, 3]; v.push(1); }
diff --git a/src/test/run-pass/vec-to_str.rs b/src/test/run-pass/vec-to_str.rs
index f000ada770a40..1fed6a0be486c 100644
--- a/src/test/run-pass/vec-to_str.rs
+++ b/src/test/run-pass/vec-to_str.rs
@@ -10,9 +10,9 @@
 
 
 pub fn main() {
-    assert_eq!(format!("{:?}", vec!(0, 1)), "[0, 1]".to_string());
+    assert_eq!(format!("{:?}", vec![0, 1]), "[0, 1]".to_string());
 
-    let foo = vec!(3, 4);
+    let foo = vec![3, 4];
     let bar: &[isize] = &[4, 5];
 
     assert_eq!(format!("{:?}", foo), "[3, 4]");
diff --git a/src/test/run-pass/vec.rs b/src/test/run-pass/vec.rs
index c61b3d56dbfb9..9cacb9db20ea9 100644
--- a/src/test/run-pass/vec.rs
+++ b/src/test/run-pass/vec.rs
@@ -11,7 +11,7 @@
 
 
 pub fn main() {
-    let v: Vec<isize> = vec!(10, 20);
+    let v: Vec<isize> = vec![10, 20];
     assert_eq!(v[0], 10);
     assert_eq!(v[1], 20);
     let mut x: usize = 0;
diff --git a/src/test/run-pass/while-with-break.rs b/src/test/run-pass/while-with-break.rs
index ed149ad5109db..4c599e9c42898 100644
--- a/src/test/run-pass/while-with-break.rs
+++ b/src/test/run-pass/while-with-break.rs
@@ -16,7 +16,7 @@ pub fn main() {
         i = i + 1;
         if i == 95 {
             let _v: Vec<isize> =
-                vec!(1, 2, 3, 4, 5); // we check that it is freed by break
+                vec![1, 2, 3, 4, 5]; // we check that it is freed by break
 
             println!("breaking");
             break;
diff --git a/src/tools/compiletest/src/main.rs b/src/tools/compiletest/src/main.rs
index e6efd45cad186..2dc7cdbf93502 100644
--- a/src/tools/compiletest/src/main.rs
+++ b/src/tools/compiletest/src/main.rs
@@ -73,7 +73,7 @@ fn main() {
 pub fn parse_config(args: Vec<String> ) -> Config {
 
     let groups : Vec<getopts::OptGroup> =
-        vec!(reqopt("", "compile-lib-path", "path to host shared libraries", "PATH"),
+        vec![reqopt("", "compile-lib-path", "path to host shared libraries", "PATH"),
           reqopt("", "run-lib-path", "path to target shared libraries", "PATH"),
           reqopt("", "rustc-path", "path to rustc to use for compiling", "PATH"),
           reqopt("", "rustdoc-path", "path to rustdoc to use for compiling", "PATH"),
@@ -111,7 +111,7 @@ pub fn parse_config(args: Vec<String> ) -> Config {
           reqopt("", "llvm-components", "list of LLVM components built in", "LIST"),
           reqopt("", "llvm-cxxflags", "C++ flags for LLVM", "FLAGS"),
           optopt("", "nodejs", "the name of nodejs", "PATH"),
-          optflag("h", "help", "show this message"));
+          optflag("h", "help", "show this message")];
 
     let (argv0, args_) = args.split_first().unwrap();
     if args.len() == 1 || args[1] == "-h" || args[1] == "--help" {
diff --git a/src/tools/compiletest/src/runtest.rs b/src/tools/compiletest/src/runtest.rs
index e10420bf291e7..03c05f919b79e 100644
--- a/src/tools/compiletest/src/runtest.rs
+++ b/src/tools/compiletest/src/runtest.rs
@@ -253,7 +253,7 @@ impl<'test> TestCx<'test> {
 
         let mut src = String::new();
         File::open(&self.testpaths.file).unwrap().read_to_string(&mut src).unwrap();
-        let mut srcs = vec!(src);
+        let mut srcs = vec![src];
 
         let mut round = 0;
         while round < rounds {
@@ -335,13 +335,13 @@ impl<'test> TestCx<'test> {
                     -> ProcArgs {
         let aux_dir = self.aux_output_dir_name();
         // FIXME (#9639): This needs to handle non-utf8 paths
-        let mut args = vec!("-".to_owned(),
+        let mut args = vec!["-".to_owned(),
                             "-Zunstable-options".to_owned(),
                             "--unpretty".to_owned(),
                             pretty_type,
                             format!("--target={}", self.config.target),
                             "-L".to_owned(),
-                            aux_dir.to_str().unwrap().to_owned());
+                            aux_dir.to_str().unwrap().to_owned()];
         args.extend(self.split_maybe_args(&self.config.target_rustcflags));
         args.extend(self.props.compile_flags.iter().cloned());
         return ProcArgs {
@@ -388,7 +388,7 @@ actual:\n\
         self.create_dir_racy(&out_dir);
 
         // FIXME (#9639): This needs to handle non-utf8 paths
-        let mut args = vec!("-".to_owned(),
+        let mut args = vec!["-".to_owned(),
                             "-Zno-trans".to_owned(),
                             "--out-dir".to_owned(),
                             out_dir.to_str().unwrap().to_owned(),
@@ -396,7 +396,7 @@ actual:\n\
                             "-L".to_owned(),
                             self.config.build_base.to_str().unwrap().to_owned(),
                             "-L".to_owned(),
-                            aux_dir.to_str().unwrap().to_owned());
+                            aux_dir.to_str().unwrap().to_owned()];
         if let Some(revision) = self.revision {
             args.extend(vec![
                 format!("--cfg"),
@@ -487,7 +487,7 @@ actual:\n\
                                  exe_file.to_str().unwrap().to_owned(),
                                  self.config.adb_test_dir.clone()
                              ],
-                             vec!(("".to_owned(), "".to_owned())),
+                             vec![("".to_owned(), "".to_owned())],
                              Some("".to_owned()))
                     .expect(&format!("failed to exec `{:?}`", self.config.adb_path));
 
@@ -499,7 +499,7 @@ actual:\n\
                                  "tcp:5039".to_owned(),
                                  "tcp:5039".to_owned()
                              ],
-                             vec!(("".to_owned(), "".to_owned())),
+                             vec![("".to_owned(), "".to_owned())],
                              Some("".to_owned()))
                     .expect(&format!("failed to exec `{:?}`", self.config.adb_path));
 
@@ -520,8 +520,8 @@ actual:\n\
                                                               "shell".to_owned(),
                                                               adb_arg.clone()
                                                           ],
-                                                          vec!(("".to_owned(),
-                                                                "".to_owned())),
+                                                          vec![("".to_owned(),
+                                                                "".to_owned())],
                                                           Some("".to_owned()))
                     .expect(&format!("failed to exec `{:?}`", self.config.adb_path));
                 loop {
@@ -535,10 +535,10 @@ actual:\n\
                 let debugger_script = self.make_out_name("debugger.script");
                 // FIXME (#9639): This needs to handle non-utf8 paths
                 let debugger_opts =
-                    vec!("-quiet".to_owned(),
+                    vec!["-quiet".to_owned(),
                          "-batch".to_owned(),
                          "-nx".to_owned(),
-                         format!("-command={}", debugger_script.to_str().unwrap()));
+                         format!("-command={}", debugger_script.to_str().unwrap())];
 
                 let mut gdb_path = tool_path;
                 gdb_path.push_str(&format!("/bin/{}-gdb", self.config.target));
@@ -550,7 +550,7 @@ actual:\n\
                                  &gdb_path,
                                  None,
                                  &debugger_opts,
-                                 vec!(("".to_owned(), "".to_owned())),
+                                 vec![("".to_owned(), "".to_owned())],
                                  None)
                     .expect(&format!("failed to exec `{:?}`", gdb_path));
                 let cmdline = {
@@ -642,10 +642,10 @@ actual:\n\
 
                 // FIXME (#9639): This needs to handle non-utf8 paths
                 let debugger_opts =
-                    vec!("-quiet".to_owned(),
+                    vec!["-quiet".to_owned(),
                          "-batch".to_owned(),
                          "-nx".to_owned(),
-                         format!("-command={}", debugger_script.to_str().unwrap()));
+                         format!("-command={}", debugger_script.to_str().unwrap())];
 
                 let proc_args = ProcArgs {
                     prog: debugger().to_owned(),
@@ -830,9 +830,9 @@ actual:\n\
         let command_directive = format!("{}-command", debugger_prefix);
         let check_directive = format!("{}-check", debugger_prefix);
 
-        let mut breakpoint_lines = vec!();
-        let mut commands = vec!();
-        let mut check_lines = vec!();
+        let mut breakpoint_lines = vec![];
+        let mut commands = vec![];
+        let mut check_lines = vec![];
         let mut counter = 1;
         let reader = BufReader::new(File::open(&self.testpaths.file).unwrap());
         for line in reader.lines() {
@@ -1120,8 +1120,8 @@ actual:\n\
     fn compile_test(&self) -> ProcRes {
         let aux_dir = self.aux_output_dir_name();
         // FIXME (#9639): This needs to handle non-utf8 paths
-        let link_args = vec!("-L".to_owned(),
-                             aux_dir.to_str().unwrap().to_owned());
+        let link_args = vec!["-L".to_owned(),
+                             aux_dir.to_str().unwrap().to_owned()];
         let args = self.make_compile_args(link_args,
                                           &self.testpaths.file,
                                           TargetLocation::ThisFile(self.make_exe_name()));
@@ -1231,9 +1231,9 @@ actual:\n\
                 if (self.config.target.contains("musl") && !aux_props.force_host) ||
                     self.config.target.contains("emscripten")
                 {
-                    vec!("--crate-type=lib".to_owned())
+                    vec!["--crate-type=lib".to_owned()]
                 } else {
-                    vec!("--crate-type=dylib".to_owned())
+                    vec!["--crate-type=dylib".to_owned()]
                 }
             };
             crate_type.extend(extra_link_args.clone());
@@ -1315,10 +1315,10 @@ actual:\n\
         };
 
         // FIXME (#9639): This needs to handle non-utf8 paths
-        let mut args = vec!(input_file.to_str().unwrap().to_owned(),
+        let mut args = vec![input_file.to_str().unwrap().to_owned(),
                             "-L".to_owned(),
                             self.config.build_base.to_str().unwrap().to_owned(),
-                            format!("--target={}", target));
+                            format!("--target={}", target)];
 
         if let Some(revision) = self.revision {
             args.extend(vec![
@@ -1613,7 +1613,7 @@ actual:\n\
                                            args.prog.clone(),
                                            self.config.adb_test_dir.clone()
                                        ],
-                                       vec!(("".to_owned(), "".to_owned())),
+                                       vec![("".to_owned(), "".to_owned())],
                                        Some("".to_owned()))
             .expect(&format!("failed to exec `{}`", self.config.adb_path));
 
@@ -1645,7 +1645,7 @@ actual:\n\
                      &self.config.adb_path,
                      None,
                      &runargs,
-                     vec!(("".to_owned(), "".to_owned())), Some("".to_owned()))
+                     vec![("".to_owned(), "".to_owned())], Some("".to_owned()))
             .expect(&format!("failed to exec `{}`", self.config.adb_path));
 
         // get exitcode of result
@@ -1659,7 +1659,7 @@ actual:\n\
                          &self.config.adb_path,
                          None,
                          &runargs,
-                         vec!(("".to_owned(), "".to_owned())),
+                         vec![("".to_owned(), "".to_owned())],
                          Some("".to_owned()))
             .expect(&format!("failed to exec `{}`", self.config.adb_path));
 
@@ -1683,7 +1683,7 @@ actual:\n\
                          &self.config.adb_path,
                          None,
                          &runargs,
-                         vec!(("".to_owned(), "".to_owned())),
+                         vec![("".to_owned(), "".to_owned())],
                          Some("".to_owned()))
             .expect(&format!("failed to exec `{}`", self.config.adb_path));
 
@@ -1698,7 +1698,7 @@ actual:\n\
                          &self.config.adb_path,
                          None,
                          &runargs,
-                         vec!(("".to_owned(), "".to_owned())),
+                         vec![("".to_owned(), "".to_owned())],
                          Some("".to_owned()))
             .expect(&format!("failed to exec `{}`", self.config.adb_path));
 
@@ -1730,8 +1730,8 @@ actual:\n\
                                                        .to_owned(),
                                                    self.config.adb_test_dir.to_owned(),
                                                ],
-                                               vec!(("".to_owned(),
-                                                     "".to_owned())),
+                                               vec![("".to_owned(),
+                                                     "".to_owned())],
                                                Some("".to_owned()))
                     .expect(&format!("failed to exec `{}`", self.config.adb_path));
 
@@ -1749,9 +1749,9 @@ actual:\n\
     fn compile_test_and_save_ir(&self) -> ProcRes {
         let aux_dir = self.aux_output_dir_name();
         // FIXME (#9639): This needs to handle non-utf8 paths
-        let mut link_args = vec!("-L".to_owned(),
-                                 aux_dir.to_str().unwrap().to_owned());
-        let llvm_args = vec!("--emit=llvm-ir".to_owned(),);
+        let mut link_args = vec!["-L".to_owned(),
+                                 aux_dir.to_str().unwrap().to_owned()];
+        let llvm_args = vec!["--emit=llvm-ir".to_owned(),];
         link_args.extend(llvm_args);
         let args = self.make_compile_args(link_args,
                                           &self.testpaths.file,
@@ -1768,8 +1768,8 @@ actual:\n\
         let proc_args = ProcArgs {
             // FIXME (#9639): This needs to handle non-utf8 paths
             prog: prog.to_str().unwrap().to_owned(),
-            args: vec!(format!("-input-file={}", irfile.to_str().unwrap()),
-                       self.testpaths.file.to_str().unwrap().to_owned())
+            args: vec![format!("-input-file={}", irfile.to_str().unwrap()),
+                       self.testpaths.file.to_str().unwrap().to_owned()]
         };
         self.compose_and_run(proc_args, Vec::new(), "", None, None)
     }
diff --git a/src/tools/rustbook/book.rs b/src/tools/rustbook/book.rs
index 36a37dba1fa0f..c5f72127a9c80 100644
--- a/src/tools/rustbook/book.rs
+++ b/src/tools/rustbook/book.rs
@@ -94,16 +94,16 @@ pub fn parse_summary(input: &mut Read, src: &Path) -> Result<Book, Vec<String>>
         }
     }
 
-    let mut top_items = vec!();
-    let mut stack = vec!();
-    let mut errors = vec!();
+    let mut top_items = vec![];
+    let mut stack = vec![];
+    let mut errors = vec![];
 
     // always include the introduction
     top_items.push(BookItem {
         title: "Introduction".to_string(),
         path: PathBuf::from("README.md"),
         path_to_root: PathBuf::from(""),
-        children: vec!(),
+        children: vec![],
     });
 
     for line_result in BufReader::new(input).lines() {
@@ -142,7 +142,7 @@ pub fn parse_summary(input: &mut Read, src: &Path) -> Result<Book, Vec<String>>
             title: title,
             path: path_from_root,
             path_to_root: path_to_root,
-            children: vec!(),
+            children: vec![],
         };
         let level = indent.chars().map(|c| -> usize {
             match c {