auto merge of #13326 : alexcrichton/rust/rollup, r=alexcrichton

Closes #13313 (Fix typo in README.md)
Closes #13311 (Fix inner attribute syntax from `#[foo];` to `#![foo]`)
Closes #13309 (Add stdlib docs to the Linux binary tarball.)
Closes #13308 (syntax: remove obsolete mutability from ExprVec and ExprRepeat.)
Closes #13306 (TrieSet should impl Set/MutableSet; add with_capacity to PriorityQueue/SmallIntMap)
Closes #13303 (Register new snapshots)
Closes #13274 (Added grow_fn and retain to Vec)

*Issues Closed*

Closes #13249

7 files changed, 19 insertions, 30 deletions

diff --git a/src/libsyntax/ast.rs b/src/libsyntax/ast.rs
index 53d2ac97b49..6a5acff3fe0 100644
--- a/src/libsyntax/ast.rs
+++ b/src/libsyntax/ast.rs
@@ -493,7 +493,7 @@ pub enum Expr_ {
     ExprVstore(@Expr, ExprVstore),
     // First expr is the place; second expr is the value.
     ExprBox(@Expr, @Expr),
-    ExprVec(Vec<@Expr>, Mutability),
+    ExprVec(Vec<@Expr>),
     ExprCall(@Expr, Vec<@Expr>),
     ExprMethodCall(Ident, Vec<P<Ty>>, Vec<@Expr>),
     ExprTup(Vec<@Expr>),
@@ -536,7 +536,7 @@ pub enum Expr_ {
     ExprStruct(Path, Vec<Field> , Option<@Expr> /* base */),
 
     // A vector literal constructed from one repeated element.
-    ExprRepeat(@Expr /* element */, @Expr /* count */, Mutability),
+    ExprRepeat(@Expr /* element */, @Expr /* count */),
 
     // No-op: used solely so we can pretty-print faithfully
     ExprParen(@Expr)
diff --git a/src/libsyntax/ext/build.rs b/src/libsyntax/ext/build.rs
index ef62f0a01f6..b7c12cd4fdc 100644
--- a/src/libsyntax/ext/build.rs
+++ b/src/libsyntax/ext/build.rs
@@ -579,7 +579,7 @@ impl<'a> AstBuilder for ExtCtxt<'a> {
         self.expr(sp, ast::ExprVstore(expr, vst))
     }
     fn expr_vec(&self, sp: Span, exprs: Vec<@ast::Expr> ) -> @ast::Expr {
-        self.expr(sp, ast::ExprVec(exprs, ast::MutImmutable))
+        self.expr(sp, ast::ExprVec(exprs))
     }
     fn expr_vec_ng(&self, sp: Span) -> @ast::Expr {
         self.expr_call_global(sp,
diff --git a/src/libsyntax/fold.rs b/src/libsyntax/fold.rs
index 06bf892771d..e21f14e4a96 100644
--- a/src/libsyntax/fold.rs
+++ b/src/libsyntax/fold.rs
@@ -740,11 +740,11 @@ pub fn noop_fold_expr<T: Folder>(e: @Expr, folder: &mut T) -> @Expr {
         ExprBox(p, e) => {
             ExprBox(folder.fold_expr(p), folder.fold_expr(e))
         }
-        ExprVec(ref exprs, mutt) => {
-            ExprVec(exprs.iter().map(|&x| folder.fold_expr(x)).collect(), mutt)
+        ExprVec(ref exprs) => {
+            ExprVec(exprs.iter().map(|&x| folder.fold_expr(x)).collect())
         }
-        ExprRepeat(expr, count, mutt) => {
-            ExprRepeat(folder.fold_expr(expr), folder.fold_expr(count), mutt)
+        ExprRepeat(expr, count) => {
+            ExprRepeat(folder.fold_expr(expr), folder.fold_expr(count))
         }
         ExprTup(ref elts) => ExprTup(elts.iter().map(|x| folder.fold_expr(*x)).collect()),
         ExprCall(f, ref args) => {
diff --git a/src/libsyntax/lib.rs b/src/libsyntax/lib.rs
index 5570219bd8e..012bc50ecab 100644
--- a/src/libsyntax/lib.rs
+++ b/src/libsyntax/lib.rs
@@ -30,8 +30,6 @@ This API is completely unstable and subject to change.
            quote)]
 #![allow(deprecated)]
 
-#![allow(visible_private_types)] // NOTE: remove after a stage0 snap
-
 extern crate serialize;
 extern crate term;
 extern crate collections;
diff --git a/src/libsyntax/parse/parser.rs b/src/libsyntax/parse/parser.rs
index 2d78bfe5694..94f5458ba53 100644
--- a/src/libsyntax/parse/parser.rs
+++ b/src/libsyntax/parse/parser.rs
@@ -1819,12 +1819,11 @@ impl<'a> Parser<'a> {
             return self.parse_block_expr(lo, UnsafeBlock(ast::UserProvided));
         } else if self.token == token::LBRACKET {
             self.bump();
-            let mutbl = MutImmutable;
 
             if self.token == token::RBRACKET {
                 // Empty vector.
                 self.bump();
-                ex = ExprVec(Vec::new(), mutbl);
+                ex = ExprVec(Vec::new());
             } else {
                 // Nonempty vector.
                 let first_expr = self.parse_expr();
@@ -1835,7 +1834,7 @@ impl<'a> Parser<'a> {
                     self.bump();
                     let count = self.parse_expr();
                     self.expect(&token::RBRACKET);
-                    ex = ExprRepeat(first_expr, count, mutbl);
+                    ex = ExprRepeat(first_expr, count);
                 } else if self.token == token::COMMA {
                     // Vector with two or more elements.
                     self.bump();
@@ -1846,11 +1845,11 @@ impl<'a> Parser<'a> {
                     );
                     let mut exprs = vec!(first_expr);
                     exprs.push_all_move(remaining_exprs);
-                    ex = ExprVec(exprs, mutbl);
+                    ex = ExprVec(exprs);
                 } else {
                     // Vector with one element.
                     self.expect(&token::RBRACKET);
-                    ex = ExprVec(vec!(first_expr), mutbl);
+                    ex = ExprVec(vec!(first_expr));
                 }
             }
             hi = self.last_span.hi;
diff --git a/src/libsyntax/print/pprust.rs b/src/libsyntax/print/pprust.rs
index 1eee0fb87d6..fe969c6fd51 100644
--- a/src/libsyntax/print/pprust.rs
+++ b/src/libsyntax/print/pprust.rs
@@ -915,9 +915,6 @@ impl<'a> State<'a> {
             match attr.node.style {
                 ast::AttrInner => {
                     try!(self.print_attribute(attr));
-                    if !attr.node.is_sugared_doc {
-                        try!(word(&mut self.s, ";"));
-                    }
                     count += 1;
                 }
                 _ => {/* fallthrough */ }
@@ -935,7 +932,10 @@ impl<'a> State<'a> {
         if attr.node.is_sugared_doc {
             word(&mut self.s, attr.value_str().unwrap().get())
         } else {
-            try!(word(&mut self.s, "#["));
+            match attr.node.style {
+                ast::AttrInner => try!(word(&mut self.s, "#![")),
+                ast::AttrOuter => try!(word(&mut self.s, "#[")),
+            }
             try!(self.print_meta_item(attr.meta()));
             word(&mut self.s, "]")
         }
@@ -1110,25 +1110,17 @@ impl<'a> State<'a> {
                 try!(self.word_space(")"));
                 try!(self.print_expr(e));
             }
-            ast::ExprVec(ref exprs, mutbl) => {
+            ast::ExprVec(ref exprs) => {
                 try!(self.ibox(indent_unit));
                 try!(word(&mut self.s, "["));
-                if mutbl == ast::MutMutable {
-                    try!(word(&mut self.s, "mut"));
-                    if exprs.len() > 0u { try!(self.nbsp()); }
-                }
                 try!(self.commasep_exprs(Inconsistent, exprs.as_slice()));
                 try!(word(&mut self.s, "]"));
                 try!(self.end());
             }
 
-            ast::ExprRepeat(element, count, mutbl) => {
+            ast::ExprRepeat(element, count) => {
                 try!(self.ibox(indent_unit));
                 try!(word(&mut self.s, "["));
-                if mutbl == ast::MutMutable {
-                    try!(word(&mut self.s, "mut"));
-                    try!(self.nbsp());
-                }
                 try!(self.print_expr(element));
                 try!(word(&mut self.s, ","));
                 try!(word(&mut self.s, ".."));
diff --git a/src/libsyntax/visit.rs b/src/libsyntax/visit.rs
index eb03bb1f0bb..81e5e228027 100644
--- a/src/libsyntax/visit.rs
+++ b/src/libsyntax/visit.rs
@@ -635,10 +635,10 @@ pub fn walk_expr<E: Clone, V: Visitor<E>>(visitor: &mut V, expression: &Expr, en
             visitor.visit_expr(place, env.clone());
             visitor.visit_expr(subexpression, env.clone())
         }
-        ExprVec(ref subexpressions, _) => {
+        ExprVec(ref subexpressions) => {
             walk_exprs(visitor, subexpressions.as_slice(), env.clone())
         }
-        ExprRepeat(element, count, _) => {
+        ExprRepeat(element, count) => {
             visitor.visit_expr(element, env.clone());
             visitor.visit_expr(count, env.clone())
         }