---

yaml
---
r: 41910
b: refs/heads/master
c: b7ef28c
h: refs/heads/master
v: v3

Author: thestinger

[refs]

@@ -1,5 +1,5 @@
 ---
-refs/heads/master: 778aec998b0a4a34632b22abd8c1cfa599fe78f0
+refs/heads/master: b7ef28c33abff6bcaf353a3958e497e15ee3268d
 refs/heads/snap-stage1: e33de59e47c5076a89eadeb38f4934f58a3618a6
 refs/heads/snap-stage3: 2f46b763da2c098913884f101b6d71d69af41b49
 refs/heads/try: 3d5418789064fdb463e872a4e651af1c628a3650

trunk/AUTHORS.txt

@@ -26,7 +26,6 @@ Benjamin Jackman <[email protected]>
 Benjamin Kircher <[email protected]>
 Benjamin Peterson <[email protected]>
 Bilal Husain <[email protected]>
-Bill Fallon <[email protected]>
 Brendan Eich <[email protected]>
 Brian Anderson <[email protected]>
 Brian J. Burg <[email protected]>

trunk/doc/rust.md

@@ -3018,11 +3018,6 @@ Local variables are immutable unless declared with `let mut`.  The
 declaration (so `let mut x, y` declares two mutable variables, `x` and
 `y`).
 
-Function parameters are immutable unless declared with `mut`. The
-`mut` keyword applies only to the following parameter (so `|mut x, y|`
-and `fn f(mut x: ~int, y: ~int)` declare one mutable variable `x` and
-one immutable variable `y`).
-
 Local variables are not initialized when allocated; the entire frame worth of
 local variables are allocated at once, on frame-entry, in an uninitialized
 state. Subsequent statements within a function may or may not initialize the

trunk/src/compiletest/runtest.rs

@@ -273,7 +273,7 @@ fn check_expected_errors(expected_errors: ~[errors::expected_error],
                          procres: procres) {
 
     // true if we found the error in question
-    let found_flags = vec::cast_to_mut(vec::from_elem(
+    let found_flags = vec::to_mut(vec::from_elem(
         vec::len(expected_errors), false));
 
     if procres.status == 0 {

trunk/src/libcargo/cargo.rc

@@ -52,7 +52,7 @@ use core::*;
 use core::dvec::DVec;
 use core::io::WriterUtil;
 use core::result::{Ok, Err};
-use core::send_map::linear::LinearMap;
+use core::hashmap::linear::LinearMap;
 use std::getopts::{optflag, optopt, opt_present};
 use std::map::HashMap;
 use std::{map, json, tempfile, term, sort, getopts};

trunk/src/libcore/core.rc

@@ -138,7 +138,7 @@ pub mod dvec_iter;
 pub mod dlist;
 #[path="iter-trait.rs"] #[merge = "iter-trait/dlist.rs"]
 pub mod dlist_iter;
-pub mod send_map;
+pub mod hashmap;
 
 
 /* Tasks and communication */

trunk/src/libcore/dvec.rs

@@ -145,7 +145,7 @@ impl<A> DVec<A> {
     #[inline(always)]
     fn swap_mut(f: &fn(v: ~[mut A]) -> ~[mut A]) {
         do self.swap |v| {
-            vec::cast_from_mut(f(vec::cast_to_mut(move v)))
+            vec::from_mut(f(vec::to_mut(move v)))
         }
     }
 

trunk/src/libcore/gc.rs

@@ -44,7 +44,7 @@ use io;
 use libc::{size_t, uintptr_t};
 use option::{None, Option, Some};
 use ptr;
-use send_map::linear::LinearSet;
+use hashmap::linear::LinearSet;
 use stackwalk;
 use sys;
 

trunk/src/libcore/send_map.rs renamed to trunk/src/libcore/hashmap.rs

@@ -494,8 +494,8 @@ pub mod linear {
 #[test]
 pub mod test {
     use option::{None, Some};
-    use send_map::linear::LinearMap;
-    use send_map::linear;
+    use hashmap::linear::LinearMap;
+    use hashmap::linear;
     use uint;
 
     #[test]

trunk/src/libcore/os.rs

@@ -84,7 +84,7 @@ pub fn as_c_charp<T>(s: &str, f: fn(*c_char) -> T) -> T {
 
 pub fn fill_charp_buf(f: fn(*mut c_char, size_t) -> bool)
     -> Option<~str> {
-    let buf = vec::cast_to_mut(vec::from_elem(tmpbuf_sz, 0u8 as c_char));
+    let buf = vec::to_mut(vec::from_elem(tmpbuf_sz, 0u8 as c_char));
     do vec::as_mut_buf(buf) |b, sz| {
         if f(b, sz as size_t) unsafe {
             Some(str::raw::from_buf(b as *u8))
@@ -111,7 +111,7 @@ pub mod win32 {
             let mut res = None;
             let mut done = false;
             while !done {
-                let buf = vec::cast_to_mut(vec::from_elem(n as uint, 0u16));
+                let buf = vec::to_mut(vec::from_elem(n as uint, 0u16));
                 do vec::as_mut_buf(buf) |b, _sz| {
                     let k : DWORD = f(b, tmpbuf_sz as DWORD);
                     if k == (0 as DWORD) {
@@ -1269,7 +1269,7 @@ mod tests {
           };
           assert (ostream as uint != 0u);
           let s = ~"hello";
-          let mut buf = vec::cast_to_mut(str::to_bytes(s) + ~[0 as u8]);
+          let mut buf = vec::to_mut(str::to_bytes(s) + ~[0 as u8]);
           do vec::as_mut_buf(buf) |b, _len| {
               assert (libc::fwrite(b as *c_void, 1u as size_t,
                                    (str::len(s) + 1u) as size_t, ostream)

trunk/src/libcore/task/spawn.rs

@@ -81,7 +81,7 @@ use pipes;
 use prelude::*;
 use private;
 use ptr;
-use send_map;
+use hashmap::linear::LinearSet;
 use task::local_data_priv::{local_get, local_set};
 use task::rt::rust_task;
 use task::rt::rust_closure;
@@ -96,10 +96,10 @@ macro_rules! move_it (
     { $x:expr } => ( unsafe { let y = move *ptr::addr_of(&($x)); move y } )
 )
 
-type TaskSet = send_map::linear::LinearSet<*rust_task>;
+type TaskSet = LinearSet<*rust_task>;
 
 fn new_taskset() -> TaskSet {
-    send_map::linear::LinearSet::new()
+    LinearSet::new()
 }
 fn taskset_insert(tasks: &mut TaskSet, task: *rust_task) {
     let didnt_overwrite = tasks.insert(task);

trunk/src/libcore/vec.rs

@@ -209,12 +209,12 @@ pub pure fn build_sized_opt<A>(size: Option<uint>,
 }
 
 /// Produces a mut vector from an immutable vector.
-pub pure fn cast_to_mut<T>(v: ~[T]) -> ~[mut T] {
+pub pure fn to_mut<T>(v: ~[T]) -> ~[mut T] {
     unsafe { ::cast::transmute(v) }
 }
 
 /// Produces an immutable vector from a mut vector.
-pub pure fn cast_from_mut<T>(v: ~[mut T]) -> ~[T] {
+pub pure fn from_mut<T>(v: ~[mut T]) -> ~[T] {
     unsafe { ::cast::transmute(v) }
 }
 
@@ -552,7 +552,7 @@ pub fn consume<T>(v: ~[T], f: fn(uint, v: T)) unsafe {
 }
 
 pub fn consume_mut<T>(v: ~[mut T], f: fn(uint, v: T)) {
-    consume(vec::cast_from_mut(v), f)
+    consume(vec::from_mut(v), f)
 }
 
 /// Remove the last element from a vector and return it
@@ -718,7 +718,7 @@ pub pure fn append_one<T>(lhs: ~[T], x: T) -> ~[T] {
 
 #[inline(always)]
 pub pure fn append_mut<T: Copy>(lhs: ~[mut T], rhs: &[const T]) -> ~[mut T] {
-    cast_to_mut(append(cast_from_mut(lhs), rhs))
+    to_mut(append(from_mut(lhs), rhs))
 }
 
 /**
@@ -3271,22 +3271,22 @@ mod tests {
     }
 
     #[test]
-    fn cast_to_mut_no_copy() {
+    fn to_mut_no_copy() {
         unsafe {
             let x = ~[1, 2, 3];
             let addr = raw::to_ptr(x);
-            let x_mut = cast_to_mut(x);
+            let x_mut = to_mut(x);
             let addr_mut = raw::to_ptr(x_mut);
             assert addr == addr_mut;
         }
     }
 
     #[test]
-    fn cast_from_mut_no_copy() {
+    fn from_mut_no_copy() {
         unsafe {
             let x = ~[mut 1, 2, 3];
             let addr = raw::to_ptr(x);
-            let x_imm = cast_from_mut(x);
+            let x_imm = from_mut(x);
             let addr_imm = raw::to_ptr(x_imm);
             assert addr == addr_imm;
         }

trunk/src/librustc/middle/borrowck/gather_loans.rs

@@ -30,7 +30,7 @@ use util::common::indenter;
 use util::ppaux::{expr_repr, region_to_str};
 
 use core::dvec;
-use core::send_map::linear::LinearSet;
+use core::hashmap::linear::LinearSet;
 use core::vec;
 use std::map::HashMap;
 use syntax::ast::{m_const, m_imm, m_mutbl};

trunk/src/librustc/middle/liveness.rs

@@ -661,11 +661,11 @@ fn Liveness(ir: @IrMaps, specials: Specials) -> Liveness {
         tcx: ir.tcx,
         s: specials,
         successors:
-            vec::cast_to_mut(
+            vec::to_mut(
                 vec::from_elem(ir.num_live_nodes,
                                invalid_node())),
         users:
-            vec::cast_to_mut(
+            vec::to_mut(
                 vec::from_elem(ir.num_live_nodes * ir.num_vars,
                                invalid_users())),
         loop_scope: DVec(),

trunk/src/librustc/middle/trans/_match.rs

@@ -985,7 +985,7 @@ fn pick_col(m: &[@Match]) -> uint {
           _ => 0u
         }
     }
-    let scores = vec::cast_to_mut(vec::from_elem(m[0].pats.len(), 0u));
+    let scores = vec::to_mut(vec::from_elem(m[0].pats.len(), 0u));
     for vec::each(m) |br| {
         let mut i = 0u;
         for vec::each(br.pats) |p| { scores[i] += score(*p); i += 1u; }

trunk/src/librustc/middle/trans/foreign.rs

@@ -297,14 +297,14 @@ fn classify_ty(ty: TypeRef) -> ~[x86_64_reg_class] {
     }
 
     let words = (ty_size(ty) + 7) / 8;
-    let cls = vec::cast_to_mut(vec::from_elem(words, no_class));
+    let cls = vec::to_mut(vec::from_elem(words, no_class));
     if words > 4 {
         all_mem(cls);
-        return vec::cast_from_mut(move cls);
+        return vec::from_mut(move cls);
     }
     classify(ty, cls, 0, 0);
     fixup(ty, cls);
-    return vec::cast_from_mut(move cls);
+    return vec::from_mut(move cls);
 }
 
 fn llreg_ty(cls: &[x86_64_reg_class]) -> TypeRef {

trunk/src/librustc/middle/trans/type_use.rs

@@ -68,7 +68,7 @@ fn type_uses_for(ccx: @crate_ctxt, fn_id: def_id, n_tps: uint)
     // Conservatively assume full use for recursive loops
     ccx.type_use_cache.insert(fn_id, vec::from_elem(n_tps, 3u));
 
-    let cx = {ccx: ccx, uses: vec::cast_to_mut(vec::from_elem(n_tps, 0u))};
+    let cx = {ccx: ccx, uses: vec::to_mut(vec::from_elem(n_tps, 0u))};
     match ty::get(ty::lookup_item_type(cx.ccx.tcx, fn_id).ty).sty {
         ty::ty_fn(ref fn_ty) => {
             for vec::each(fn_ty.sig.inputs) |arg| {
@@ -84,7 +84,7 @@ fn type_uses_for(ccx: @crate_ctxt, fn_id: def_id, n_tps: uint)
     }
 
     if fn_id_loc.crate != local_crate {
-        let uses = vec::cast_from_mut(copy cx.uses);
+        let uses = vec::from_mut(copy cx.uses);
         ccx.type_use_cache.insert(fn_id, copy uses);
         return uses;
     }
@@ -167,7 +167,7 @@ fn type_uses_for(ccx: @crate_ctxt, fn_id: def_id, n_tps: uint)
                                 ccx.tcx.sess.parse_sess.interner)));
       }
     }
-    let uses = vec::cast_from_mut(copy cx.uses);
+    let uses = vec::from_mut(copy cx.uses);
     // XXX: Bad copy, use @vec instead?
     ccx.type_use_cache.insert(fn_id, copy uses);
     uses

trunk/src/librustc/middle/typeck/check/mod.rs

@@ -3024,7 +3024,7 @@ fn check_bounds_are_used(ccx: @crate_ctxt,
 
     // make a vector of booleans initially false, set to true when used
     if tps.len() == 0u { return; }
-    let tps_used = vec::cast_to_mut(vec::from_elem(tps.len(), false));
+    let tps_used = vec::to_mut(vec::from_elem(tps.len(), false));
 
     ty::walk_regions_and_ty(
         ccx.tcx, ty,

trunk/src/librustc/middle/typeck/coherence.rs

@@ -57,7 +57,7 @@ use util::ppaux::ty_to_str;
 
 use core::dvec::DVec;
 use core::result::Ok;
-use core::send_map;
+use core::hashmap::linear::LinearSet;
 use core::uint::range;
 use core::uint;
 use core::vec::{len, push};
@@ -693,7 +693,7 @@ impl CoherenceChecker {
 
         let tcx = self.crate_context.tcx;
 
-        let mut provided_names = send_map::linear::LinearSet::new();
+        let mut provided_names = LinearSet::new();
         // Implemented methods
         for uint::range(0, all_methods.len()) |i| {
             provided_names.insert(all_methods[i].ident);

trunk/src/libstd/bitv.rs

@@ -13,7 +13,7 @@
 use core::ops;
 use core::prelude::*;
 use core::uint;
-use core::vec::{cast_to_mut, from_elem};
+use core::vec::{to_mut, from_elem};
 use core::vec;
 
 struct SmallBitv {
@@ -231,7 +231,7 @@ pub fn Bitv (nbits: uint, init: bool) -> Bitv {
         let nelems = nbits/uint_bits +
                      if nbits % uint_bits == 0 {0} else {1};
         let elem = if init {!0} else {0};
-        let s = cast_to_mut(from_elem(nelems, elem));
+        let s = to_mut(from_elem(nelems, elem));
         Big(~BigBitv(move s))
     };
     Bitv {rep: move rep, nbits: nbits}
@@ -516,7 +516,7 @@ impl Bitv: Clone {
             Bitv{nbits: self.nbits, rep: Small(~SmallBitv{bits: b.bits})}
           }
           Big(ref b) => {
-            let st = cast_to_mut(from_elem(self.nbits / uint_bits + 1, 0));
+            let st = to_mut(from_elem(self.nbits / uint_bits + 1, 0));
             let len = st.len();
             for uint::range(0, len) |i| { st[i] = b.storage[i]; };
             Bitv{nbits: self.nbits, rep: Big(~BigBitv{storage: move st})}

trunk/src/libstd/getopts.rs

@@ -222,7 +222,7 @@ pub type Result = result::Result<Matches, Fail_>;
 pub fn getopts(args: &[~str], opts: &[Opt]) -> Result unsafe {
     let n_opts = opts.len();
     fn f(_x: uint) -> ~[Optval] { return ~[]; }
-    let vals = vec::cast_to_mut(vec::from_fn(n_opts, f));
+    let vals = vec::to_mut(vec::from_fn(n_opts, f));
     let mut free: ~[~str] = ~[];
     let l = args.len();
     let mut i = 0;
@@ -337,7 +337,7 @@ pub fn getopts(args: &[~str], opts: &[Opt]) -> Result unsafe {
         i += 1;
     }
     return Ok(Matches {opts: vec::from_slice(opts),
-               vals: vec::cast_from_mut(move vals),
+               vals: vec::from_mut(move vals),
                free: free});
 }
 

trunk/src/libstd/json.rs

@@ -24,7 +24,7 @@ use core::float;
 use core::io::{WriterUtil, ReaderUtil};
 use core::io;
 use core::prelude::*;
-use core::send_map::linear;
+use core::hashmap::linear;
 use core::str;
 use core::to_str;
 use core::vec;
@@ -1223,7 +1223,7 @@ mod tests {
     use json::*;
 
     use core::result;
-    use core::send_map::linear;
+    use core::hashmap::linear;
 
     fn mk_object(items: &[(~str, Json)]) -> Json {
         let mut d = ~linear::LinearMap();

trunk/src/libstd/map.rs

@@ -19,7 +19,7 @@ use core::ops;
 use core::to_str::ToStr;
 use core::mutable::Mut;
 use core::prelude::*;
-use core::send_map::linear::LinearMap;
+use core::hashmap::linear::LinearMap;
 use core::to_bytes::IterBytes;
 use core::uint;
 use core::vec;
@@ -450,7 +450,7 @@ pub mod chained {
     }
 
     fn chains<K,V>(nchains: uint) -> ~[mut Option<@Entry<K,V>>] {
-        vec::cast_to_mut(vec::from_elem(nchains, None))
+        vec::to_mut(vec::from_elem(nchains, None))
     }
 
     pub fn mk<K:Eq IterBytes Hash, V: Copy>() -> T<K,V> {

trunk/src/libstd/md4.rs

@@ -47,7 +47,7 @@ pub pure fn md4(msg: &[u8]) -> {a: u32, b: u32, c: u32, d: u32} {
 
     let mut i = 0u;
     let e = vec::len(msg);
-    let x = vec::cast_to_mut(vec::from_elem(16u, 0u32));
+    let x = vec::to_mut(vec::from_elem(16u, 0u32));
     while i < e {
         let aa = a, bb = b, cc = c, dd = d;