---

yaml
---
r: 65021
b: refs/heads/snap-stage3
c: c852a5b
h: refs/heads/master
i:
  65019: cad6fcf
v: v3

Author: huonw

[refs]

@@ -1,7 +1,7 @@
 ---
 refs/heads/master: 2d28d645422c1617be58c8ca7ad9a457264ca850
 refs/heads/snap-stage1: e33de59e47c5076a89eadeb38f4934f58a3618a6
-refs/heads/snap-stage3: 2765811cb6530eb73c5450bd25e915e67bd512cf
+refs/heads/snap-stage3: c852a5bb681d08796959818470ed5233bfa69edc
 refs/heads/try: 7b78b52e602bb3ea8174f9b2006bff3315f03ef9
 refs/tags/release-0.1: 1f5c5126e96c79d22cb7862f75304136e204f105
 refs/heads/ndm: f3868061cd7988080c30d6d5bf352a5a5fe2460b

branches/snap-stage3/src/libstd/hashmap.rs

@@ -61,27 +61,7 @@ enum SearchResult {
 
 #[inline]
 fn resize_at(capacity: uint) -> uint {
-    ((capacity as float) * 3. / 4.) as uint
-}
-
-/// Creates a new hash map with the specified capacity.
-pub fn linear_map_with_capacity<K:Eq + Hash,V>(
-    initial_capacity: uint) -> HashMap<K, V> {
-    let mut r = rand::task_rng();
-    linear_map_with_capacity_and_keys(r.gen(), r.gen(),
-                                      initial_capacity)
-}
-
-fn linear_map_with_capacity_and_keys<K:Eq + Hash,V>(
-    k0: u64, k1: u64,
-    initial_capacity: uint) -> HashMap<K, V> {
-    let cap = num::max(INITIAL_CAPACITY, initial_capacity);
-    HashMap {
-        k0: k0, k1: k1,
-        resize_at: resize_at(cap),
-        size: 0,
-        buckets: vec::from_fn(cap, |_| None)
-    }
+    (capacity * 3) / 4
 }
 
 impl<K:Hash + Eq,V> HashMap<K, V> {
@@ -352,10 +332,28 @@ impl<K: Hash + Eq, V> HashMap<K, V> {
         HashMap::with_capacity(INITIAL_CAPACITY)
     }
 
-    /// Create an empty HashMap with space for at least `n` elements in
-    /// the hash table.
+    /// Create an empty HashMap with space for at least `capacity`
+    /// elements in the hash table.
     pub fn with_capacity(capacity: uint) -> HashMap<K, V> {
-        linear_map_with_capacity(capacity)
+        let mut r = rand::task_rng();
+        HashMap::with_capacity_and_keys(r.gen(), r.gen(), capacity)
+    }
+
+    /// Create an empty HashMap with space for at least `capacity`
+    /// elements, using `k0` and `k1` as the keys.
+    ///
+    /// Warning: `k0` and `k1` are normally randomly generated, and
+    /// are designed to allow HashMaps to be resistant to attacks that
+    /// cause many collisions and very poor performance. Setting them
+    /// manually using this function can expose a DoS attack vector.
+    pub fn with_capacity_and_keys(k0: u64, k1: u64, capacity: uint) -> HashMap<K, V> {
+        let cap = num::max(INITIAL_CAPACITY, capacity);
+        HashMap {
+            k0: k0, k1: k1,
+            resize_at: resize_at(cap),
+            size: 0,
+            buckets: vec::from_fn(cap, |_| None)
+        }
     }
 
     /// Reserve space for at least `n` elements in the hash table.
@@ -844,7 +842,7 @@ mod test_map {
 
     #[test]
     fn test_insert_conflicts() {
-        let mut m = linear_map_with_capacity(4);
+        let mut m = HashMap::with_capacity(4);
         assert!(m.insert(1, 2));
         assert!(m.insert(5, 3));
         assert!(m.insert(9, 4));
@@ -855,7 +853,7 @@ mod test_map {
 
     #[test]
     fn test_conflict_remove() {
-        let mut m = linear_map_with_capacity(4);
+        let mut m = HashMap::with_capacity(4);
         assert!(m.insert(1, 2));
         assert!(m.insert(5, 3));
         assert!(m.insert(9, 4));
@@ -866,7 +864,7 @@ mod test_map {
 
     #[test]
     fn test_is_empty() {
-        let mut m = linear_map_with_capacity(4);
+        let mut m = HashMap::with_capacity(4);
         assert!(m.insert(1, 2));
         assert!(!m.is_empty());
         assert!(m.remove(&1));
@@ -927,7 +925,7 @@ mod test_map {
 
     #[test]
     fn test_iterate() {
-        let mut m = linear_map_with_capacity(4);
+        let mut m = HashMap::with_capacity(4);
         foreach i in range(0u, 32) {
             assert!(m.insert(i, i*2));
         }

branches/snap-stage3/src/libsyntax/ext/build.rs

@@ -76,12 +76,12 @@ pub trait AstBuilder {
     fn stmt_let(&self, sp: span, mutbl: bool, ident: ast::ident, ex: @ast::expr) -> @ast::stmt;
 
     // blocks
-    fn block(&self, span: span, stmts: ~[@ast::stmt], expr: Option<@ast::expr>) -> ast::Block;
-    fn block_expr(&self, expr: @ast::expr) -> ast::Block;
-    fn block_all(&self, span: span,
-                 view_items: ~[ast::view_item],
-                 stmts: ~[@ast::stmt],
-                 expr: Option<@ast::expr>) -> ast::Block;
+    fn blk(&self, span: span, stmts: ~[@ast::stmt], expr: Option<@ast::expr>) -> ast::Block;
+    fn blk_expr(&self, expr: @ast::expr) -> ast::Block;
+    fn blk_all(&self, span: span,
+               view_items: ~[ast::view_item],
+               stmts: ~[@ast::stmt],
+               expr: Option<@ast::expr>) -> ast::Block;
 
     // expressions
     fn expr(&self, span: span, node: ast::expr_) -> @ast::expr;
@@ -105,7 +105,7 @@ pub trait AstBuilder {
     fn expr_method_call(&self, span: span,
                         expr: @ast::expr, ident: ast::ident,
                         args: ~[@ast::expr]) -> @ast::expr;
-    fn expr_block(&self, b: ast::Block) -> @ast::expr;
+    fn expr_blk(&self, b: ast::Block) -> @ast::expr;
 
     fn field_imm(&self, span: span, name: ident, e: @ast::expr) -> ast::Field;
     fn expr_struct(&self, span: span, path: ast::Path, fields: ~[ast::Field]) -> @ast::expr;
@@ -387,18 +387,18 @@ impl AstBuilder for @ExtCtxt {
         @respan(sp, ast::stmt_decl(@decl, self.next_id()))
     }
 
-    fn block(&self, span: span, stmts: ~[@ast::stmt], expr: Option<@expr>) -> ast::Block {
-        self.block_all(span, ~[], stmts, expr)
+    fn blk(&self, span: span, stmts: ~[@ast::stmt], expr: Option<@expr>) -> ast::Block {
+        self.blk_all(span, ~[], stmts, expr)
     }
 
-    fn block_expr(&self, expr: @ast::expr) -> ast::Block {
-        self.block_all(expr.span, ~[], ~[], Some(expr))
+    fn blk_expr(&self, expr: @ast::expr) -> ast::Block {
+        self.blk_all(expr.span, ~[], ~[], Some(expr))
     }
-    fn block_all(&self,
-                 span: span,
-                 view_items: ~[ast::view_item],
-                 stmts: ~[@ast::stmt],
-                 expr: Option<@ast::expr>) -> ast::Block {
+    fn blk_all(&self,
+               span: span,
+               view_items: ~[ast::view_item],
+               stmts: ~[@ast::stmt],
+               expr: Option<@ast::expr>) -> ast::Block {
            ast::Block {
                view_items: view_items,
                stmts: stmts,
@@ -474,7 +474,7 @@ impl AstBuilder for @ExtCtxt {
         self.expr(span,
                   ast::expr_method_call(self.next_id(), expr, ident, ~[], args, ast::NoSugar))
     }
-    fn expr_block(&self, b: ast::Block) -> @ast::expr {
+    fn expr_blk(&self, b: ast::Block) -> @ast::expr {
         self.expr(b.span, ast::expr_block(b))
     }
     fn field_imm(&self, span: span, name: ident, e: @ast::expr) -> ast::Field {
@@ -577,7 +577,7 @@ impl AstBuilder for @ExtCtxt {
         ast::arm {
             pats: pats,
             guard: None,
-            body: self.block_expr(expr)
+            body: self.blk_expr(expr)
         }
     }
 
@@ -591,8 +591,8 @@ impl AstBuilder for @ExtCtxt {
 
     fn expr_if(&self, span: span,
                cond: @ast::expr, then: @ast::expr, els: Option<@ast::expr>) -> @ast::expr {
-        let els = els.map(|x| self.expr_block(self.block_expr(*x)));
-        self.expr(span, ast::expr_if(cond, self.block_expr(then), els))
+        let els = els.map(|x| self.expr_blk(self.blk_expr(*x)));
+        self.expr(span, ast::expr_if(cond, self.blk_expr(then), els))
     }
 
     fn lambda_fn_decl(&self, span: span, fn_decl: ast::fn_decl, blk: ast::Block) -> @ast::expr {
@@ -618,23 +618,23 @@ impl AstBuilder for @ExtCtxt {
     }
 
     fn lambda_expr(&self, span: span, ids: ~[ast::ident], expr: @ast::expr) -> @ast::expr {
-        self.lambda(span, ids, self.block_expr(expr))
+        self.lambda(span, ids, self.blk_expr(expr))
     }
     fn lambda_expr_0(&self, span: span, expr: @ast::expr) -> @ast::expr {
-        self.lambda0(span, self.block_expr(expr))
+        self.lambda0(span, self.blk_expr(expr))
     }
     fn lambda_expr_1(&self, span: span, expr: @ast::expr, ident: ast::ident) -> @ast::expr {
-        self.lambda1(span, self.block_expr(expr), ident)
+        self.lambda1(span, self.blk_expr(expr), ident)
     }
 
     fn lambda_stmts(&self, span: span, ids: ~[ast::ident], stmts: ~[@ast::stmt]) -> @ast::expr {
-        self.lambda(span, ids, self.block(span, stmts, None))
+        self.lambda(span, ids, self.blk(span, stmts, None))
     }
     fn lambda_stmts_0(&self, span: span, stmts: ~[@ast::stmt]) -> @ast::expr {
-        self.lambda0(span, self.block(span, stmts, None))
+        self.lambda0(span, self.blk(span, stmts, None))
     }
     fn lambda_stmts_1(&self, span: span, stmts: ~[@ast::stmt], ident: ast::ident) -> @ast::expr {
-        self.lambda1(span, self.block(span, stmts, None), ident)
+        self.lambda1(span, self.blk(span, stmts, None), ident)
     }
 
     fn arg(&self, span: span, ident: ast::ident, ty: ast::Ty) -> ast::arg {

branches/snap-stage3/src/libsyntax/ext/deriving/encodable.rs

@@ -178,7 +178,7 @@ fn encodable_substructure(cx: @ExtCtxt, span: span,
                                           ~[cx.expr_str(span,
                                             cx.str_of(substr.type_ident)),
                                             blk]);
-            cx.expr_block(cx.block(span, ~[me], Some(ret)))
+            cx.expr_blk(cx.blk(span, ~[me], Some(ret)))
         }
 
         _ => cx.bug("expected Struct or EnumMatching in deriving(Encodable)")

branches/snap-stage3/src/libsyntax/ext/deriving/generic.rs

@@ -527,7 +527,7 @@ impl<'self> MethodDef<'self> {
 
         let method_ident = cx.ident_of(self.name);
         let fn_decl = cx.fn_decl(args, ret_type);
-        let body_block = cx.block_expr(body);
+        let body_block = cx.blk_expr(body);
 
 
         // Create the method.

branches/snap-stage3/src/libsyntax/ext/deriving/to_str.rs

@@ -79,7 +79,7 @@ fn to_str_substructure(cx: @ExtCtxt, span: span,
             }
             push(cx.expr_str(span, end));
 
-            cx.expr_block(cx.block(span, stmts, Some(cx.expr_ident(span, buf))))
+            cx.expr_blk(cx.blk(span, stmts, Some(cx.expr_ident(span, buf))))
         }
     };
 

branches/snap-stage3/src/libsyntax/ext/fmt.rs

@@ -323,5 +323,5 @@ fn pieces_to_expr(cx: @ExtCtxt, sp: span,
                            nargs, expected_nargs));
     }
 
-    cx.expr_block(cx.block(fmt_sp, stms, Some(buf())))
+    cx.expr_blk(cx.blk(fmt_sp, stms, Some(buf())))
 }

branches/snap-stage3/src/libsyntax/ext/quote.rs

@@ -705,11 +705,11 @@ fn expand_tts(cx: @ExtCtxt,
                                   id_ext("tt"),
                                   cx.expr_vec_uniq(sp, ~[]));
 
-    cx.expr_block(
-        cx.block_all(sp, uses,
-                     ~[stmt_let_sp,
-                       stmt_let_tt] + mk_tts(cx, sp, tts),
-                     Some(cx.expr_ident(sp, id_ext("tt")))))
+    cx.expr_blk(
+        cx.blk_all(sp, uses,
+                   ~[stmt_let_sp,
+                     stmt_let_tt] + mk_tts(cx, sp, tts),
+                   Some(cx.expr_ident(sp, id_ext("tt")))))
 }
 
 fn expand_parse_call(cx: @ExtCtxt,