---

yaml
---
r: 41919
b: refs/heads/master
c: d77f8d5
h: refs/heads/master
i:
  41917: 6359266
  41915: 7b836aa
  41911: acad4f9
  41903: 55cc6aa
  41887: 214eefd
  41855: db144bf
v: v3

Author: catamorphism

[refs]

@@ -1,5 +1,5 @@
 ---
-refs/heads/master: 8bf9bae30389b69bebeed4b1da60166fe0458a3f
+refs/heads/master: d77f8d55542bd0649031b8ccc45f5a7a3a4fbd07
 refs/heads/snap-stage1: e33de59e47c5076a89eadeb38f4934f58a3618a6
 refs/heads/snap-stage3: 2f46b763da2c098913884f101b6d71d69af41b49
 refs/heads/try: 3d5418789064fdb463e872a4e651af1c628a3650

trunk/AUTHORS.txt

@@ -26,6 +26,7 @@ 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,6 +3018,11 @@ 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::to_mut(vec::from_elem(
+    let found_flags = vec::cast_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::hashmap::linear::LinearMap;
+use core::send_map::linear::LinearMap;
 use std::getopts::{optflag, optopt, opt_present};
 use std::map::HashMap;
 use std::{map, json, tempfile, term, sort, getopts};
@@ -465,19 +465,19 @@ fn parse_source(name: ~str, j: &json::Json) -> @Source {
 
     match *j {
         json::Object(j) => {
-            let mut url = match j.find_copy(&~"url") {
+            let mut url = match j.find(&~"url") {
                 Some(json::String(u)) => u,
                 _ => fail ~"needed 'url' field in source"
             };
-            let method = match j.find_copy(&~"method") {
+            let method = match j.find(&~"method") {
                 Some(json::String(u)) => u,
                 _ => assume_source_method(url)
             };
-            let key = match j.find_copy(&~"key") {
+            let key = match j.find(&~"key") {
                 Some(json::String(u)) => Some(u),
                 _ => None
             };
-            let keyfp = match j.find_copy(&~"keyfp") {
+            let keyfp = match j.find(&~"keyfp") {
                 Some(json::String(u)) => Some(u),
                 _ => None
             };
@@ -512,7 +512,7 @@ fn try_parse_sources(filename: &Path, sources: map::HashMap<~str, @Source>) {
 }
 
 fn load_one_source_package(src: @Source, p: &json::Object) {
-    let name = match p.find_copy(&~"name") {
+    let name = match p.find(&~"name") {
         Some(json::String(n)) => {
             if !valid_pkg_name(n) {
                 warn(~"malformed source json: "
@@ -529,7 +529,7 @@ fn load_one_source_package(src: @Source, p: &json::Object) {
         }
     };
 
-    let uuid = match p.find_copy(&~"uuid") {
+    let uuid = match p.find(&~"uuid") {
         Some(json::String(n)) => {
             if !is_uuid(n) {
                 warn(~"malformed source json: "
@@ -545,15 +545,15 @@ fn load_one_source_package(src: @Source, p: &json::Object) {
         }
     };
 
-    let url = match p.find_copy(&~"url") {
+    let url = match p.find(&~"url") {
         Some(json::String(n)) => n,
         _ => {
             warn(~"malformed source json: " + src.name + ~" (missing url)");
             return;
         }
     };
 
-    let method = match p.find_copy(&~"method") {
+    let method = match p.find(&~"method") {
         Some(json::String(n)) => n,
         _ => {
             warn(~"malformed source json: "
@@ -562,13 +562,13 @@ fn load_one_source_package(src: @Source, p: &json::Object) {
         }
     };
 
-    let reference = match p.find_copy(&~"ref") {
+    let reference = match p.find(&~"ref") {
         Some(json::String(n)) => Some(n),
         _ => None
     };
 
     let mut tags = ~[];
-    match p.find_copy(&~"tags") {
+    match p.find(&~"tags") {
         Some(json::List(js)) => {
           for js.each |j| {
                 match *j {
@@ -580,7 +580,7 @@ fn load_one_source_package(src: @Source, p: &json::Object) {
         _ => ()
     }
 
-    let description = match p.find_copy(&~"description") {
+    let description = match p.find(&~"description") {
         Some(json::String(n)) => n,
         _ => {
             warn(~"malformed source json: " + src.name

trunk/src/libcore/container.rs

@@ -13,8 +13,6 @@
 #[forbid(deprecated_mode)];
 #[forbid(deprecated_pattern)];
 
-use option::Option;
-
 pub trait Container {
     /// Return the number of elements in the container
     pure fn len(&self) -> uint;
@@ -41,9 +39,6 @@ pub trait Map<K, V>: Mutable {
     /// Visit all values
     pure fn each_value(&self, f: fn(&V) -> bool);
 
-    /// Return the value corresponding to the key in the map
-    pure fn find(&self, key: &K) -> Option<&self/V>;
-
     /// Insert a key-value pair into the map. An existing value for a
     /// key is replaced by the new value. Return true if the key did
     /// not already exist in the map.

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 hashmap;
+pub mod send_map;
 
 
 /* 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::from_mut(f(vec::to_mut(move v)))
+            vec::cast_from_mut(f(vec::cast_to_mut(move v)))
         }
     }
 

trunk/src/libcore/f32.rs

@@ -56,7 +56,6 @@ delegate!(fn exp2(n: c_float) -> c_float = cmath::c_float_utils::exp2)
 delegate!(fn abs(n: c_float) -> c_float = cmath::c_float_utils::abs)
 delegate!(fn abs_sub(a: c_float, b: c_float) -> c_float =
     cmath::c_float_utils::abs_sub)
-delegate!(fn floor(n: c_float) -> c_float = cmath::c_float_utils::floor)
 delegate!(fn mul_add(a: c_float, b: c_float, c: c_float) -> c_float =
     cmath::c_float_utils::mul_add)
 delegate!(fn fmax(a: c_float, b: c_float) -> c_float =
@@ -141,6 +140,10 @@ pub pure fn ge(x: f32, y: f32) -> bool { return x >= y; }
 #[inline(always)]
 pub pure fn gt(x: f32, y: f32) -> bool { return x > y; }
 
+/// Returns `x` rounded down
+#[inline(always)]
+pub pure fn floor(x: f32) -> f32 { unsafe { floorf32(x) } }
+
 // FIXME (#1999): replace the predicates below with llvm intrinsics or
 // calls to the libmath macros in the rust runtime for performance.
 
@@ -298,6 +301,11 @@ impl f32: num::One {
     static pure fn one() -> f32 { 1.0 }
 }
 
+#[abi="rust-intrinsic"]
+pub extern {
+    fn floorf32(val: f32) -> f32;
+}
+
 //
 // Local Variables:
 // mode: rust

trunk/src/libcore/f64.rs

@@ -57,7 +57,6 @@ delegate!(fn exp2(n: c_double) -> c_double = cmath::c_double_utils::exp2)
 delegate!(fn abs(n: c_double) -> c_double = cmath::c_double_utils::abs)
 delegate!(fn abs_sub(a: c_double, b: c_double) -> c_double =
     cmath::c_double_utils::abs_sub)
-delegate!(fn floor(n: c_double) -> c_double = cmath::c_double_utils::floor)
 delegate!(fn mul_add(a: c_double, b: c_double, c: c_double) -> c_double =
     cmath::c_double_utils::mul_add)
 delegate!(fn fmax(a: c_double, b: c_double) -> c_double =
@@ -210,12 +209,16 @@ pub pure fn is_infinite(x: f64) -> bool {
     return x == infinity || x == neg_infinity;
 }
 
-/// Returns true if `x`is a finite number
+/// Returns true if `x` is a finite number
 #[inline(always)]
 pub pure fn is_finite(x: f64) -> bool {
     return !(is_NaN(x) || is_infinite(x));
 }
 
+/// Returns `x` rounded down
+#[inline(always)]
+pub pure fn floor(x: f64) -> f64 { unsafe { floorf64(x) } }
+
 // FIXME (#1999): add is_normal, is_subnormal, and fpclassify
 
 /* Module: consts */
@@ -322,6 +325,11 @@ impl f64: num::One {
     static pure fn one() -> f64 { 1.0 }
 }
 
+#[abi="rust-intrinsic"]
+pub extern {
+    fn floorf64(val: f64) -> f64;
+}
+
 //
 // Local Variables:
 // mode: rust

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 hashmap::linear::LinearSet;
+use send_map::linear::LinearSet;
 use stackwalk;
 use sys;
 

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::to_mut(vec::from_elem(tmpbuf_sz, 0u8 as c_char));
+    let buf = vec::cast_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::to_mut(vec::from_elem(n as uint, 0u16));
+                let buf = vec::cast_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::to_mut(str::to_bytes(s) + ~[0 as u8]);
+          let mut buf = vec::cast_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)