---

yaml
---
r: 52471
b: refs/heads/dist-snap
c: 10e8ae8
h: refs/heads/master
i:
  52469: 7f59649
  52467: d526974
  52463: 7393dfa
v: v3

Author: catamorphism

[refs]

@@ -7,7 +7,7 @@ refs/tags/release-0.1: 1f5c5126e96c79d22cb7862f75304136e204f105
 refs/heads/ndm: f3868061cd7988080c30d6d5bf352a5a5fe2460b
 refs/heads/try2: 147ecfdd8221e4a4d4e090486829a06da1e0ca3c
 refs/heads/incoming: 44d4d6de762f3f9aae1fedcf454c66b79b3ad58d
-refs/heads/dist-snap: ba2a3e823493b71933105c458fb7103b8d0d4d77
+refs/heads/dist-snap: 10e8ae852d5164ca172d96360994727234839399
 refs/tags/release-0.2: c870d2dffb391e14efb05aa27898f1f6333a9596
 refs/tags/release-0.3: b5f0d0f648d9a6153664837026ba1be43d3e2503
 refs/heads/try3: 9387340aab40a73e8424c48fd42f0c521a4875c0

branches/dist-snap/AUTHORS.txt

@@ -15,6 +15,7 @@ Andrew Dunham <[email protected]>
 Andrew Paseltiner <[email protected]>
 Arkaitz Jimenez <[email protected]>
 Armin Ronacher <[email protected]>
+Ashok Gautham <[email protected]>
 Austin Seipp <[email protected]>
 auREAX <[email protected]>
 Ben Alpert <[email protected]>
@@ -25,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]>

branches/dist-snap/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

branches/dist-snap/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 {

branches/dist-snap/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)))
         }
     }
 

branches/dist-snap/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

branches/dist-snap/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

branches/dist-snap/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::LinearMap;
+use send_map::linear::LinearSet;
 use stackwalk;
 use sys;
 
@@ -294,12 +294,6 @@ pub fn gc() {
     }
 }
 
-type RootSet = LinearMap<*Word,()>;
-
-fn RootSet() -> RootSet {
-    LinearMap()
-}
-
 #[cfg(gc)]
 fn expect_sentinel() -> bool { true }
 
@@ -337,13 +331,13 @@ pub fn cleanup_stack_for_failure() {
             ptr::null()
         };
 
-        let mut roots = ~RootSet();
+        let mut roots = LinearSet::new();
         for walk_gc_roots(need_cleanup, sentinel) |root, tydesc| {
             // Track roots to avoid double frees.
-            if roots.find(&*root).is_some() {
+            if roots.contains(&*root) {
                 loop;
             }
-            roots.insert(*root, ());
+            roots.insert(*root);
 
             if ptr::is_null(tydesc) {
                 // FIXME #4420: Destroy this box

branches/dist-snap/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)

branches/dist-snap/src/libcore/send_map.rs

@@ -485,7 +485,7 @@ pub mod linear {
         fn remove(&mut self, value: &T) -> bool { self.map.remove(value) }
     }
 
-    impl <T: Hash IterBytes Eq> LinearSet<T> {
+    pub impl <T: Hash IterBytes Eq> LinearSet<T> {
         /// Create an empty LinearSet
         static fn new() -> LinearSet<T> { LinearSet{map: LinearMap()} }
     }

branches/dist-snap/src/libcore/task/spawn.rs

@@ -96,21 +96,21 @@ macro_rules! move_it (
     { $x:expr } => ( unsafe { let y = move *ptr::addr_of(&($x)); move y } )
 )
 
-type TaskSet = send_map::linear::LinearMap<*rust_task,()>;
+type TaskSet = send_map::linear::LinearSet<*rust_task>;
 
 fn new_taskset() -> TaskSet {
-    send_map::linear::LinearMap()
+    send_map::linear::LinearSet::new()
 }
 fn taskset_insert(tasks: &mut TaskSet, task: *rust_task) {
-    let didnt_overwrite = tasks.insert(task, ());
+    let didnt_overwrite = tasks.insert(task);
     assert didnt_overwrite;
 }
 fn taskset_remove(tasks: &mut TaskSet, task: *rust_task) {
     let was_present = tasks.remove(&task);
     assert was_present;
 }
 pub fn taskset_each(tasks: &TaskSet, blk: fn(v: *rust_task) -> bool) {
-    tasks.each_key(|k| blk(*k))
+    tasks.each(|k| blk(*k))
 }
 
 // One of these per group of linked-failure tasks.

branches/dist-snap/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 to_mut<T>(v: ~[T]) -> ~[mut T] {
+pub pure fn cast_to_mut<T>(v: ~[T]) -> ~[mut T] {
     unsafe { ::cast::transmute(v) }
 }
 
 /// Produces an immutable vector from a mut vector.
-pub pure fn from_mut<T>(v: ~[mut T]) -> ~[T] {
+pub pure fn cast_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::from_mut(v), f)
+    consume(vec::cast_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] {
-    to_mut(append(from_mut(lhs), rhs))
+    cast_to_mut(append(cast_from_mut(lhs), rhs))
 }
 
 /**
@@ -3271,22 +3271,22 @@ mod tests {
     }
 
     #[test]
-    fn to_mut_no_copy() {
+    fn cast_to_mut_no_copy() {
         unsafe {
             let x = ~[1, 2, 3];
             let addr = raw::to_ptr(x);
-            let x_mut = to_mut(x);
+            let x_mut = cast_to_mut(x);
             let addr_mut = raw::to_ptr(x_mut);
             assert addr == addr_mut;
         }
     }
 
     #[test]
-    fn from_mut_no_copy() {
+    fn cast_from_mut_no_copy() {
         unsafe {
             let x = ~[mut 1, 2, 3];
             let addr = raw::to_ptr(x);
-            let x_imm = from_mut(x);
+            let x_imm = cast_from_mut(x);
             let addr_imm = raw::to_ptr(x_imm);
             assert addr == addr_imm;
         }

branches/dist-snap/src/librustc/middle/astencode.rs

@@ -415,7 +415,7 @@ impl ast::def: tr {
           ast::def_mod(did) => { ast::def_mod(did.tr(xcx)) }
           ast::def_foreign_mod(did) => { ast::def_foreign_mod(did.tr(xcx)) }
           ast::def_const(did) => { ast::def_const(did.tr(xcx)) }
-          ast::def_arg(nid, m) => { ast::def_arg(xcx.tr_id(nid), m) }
+          ast::def_arg(nid, m, b) => { ast::def_arg(xcx.tr_id(nid), m, b) }
           ast::def_local(nid, b) => { ast::def_local(xcx.tr_id(nid), b) }
           ast::def_variant(e_did, v_did) => {
             ast::def_variant(e_did.tr(xcx), v_did.tr(xcx))

branches/dist-snap/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::LinearMap;
+use core::send_map::linear::LinearSet;
 use core::vec;
 use std::map::HashMap;
 use syntax::ast::{m_const, m_imm, m_mutbl};
@@ -73,17 +73,18 @@ enum gather_loan_ctxt = @{bccx: borrowck_ctxt,
                           req_maps: req_maps,
                           mut item_ub: ast::node_id,
                           mut root_ub: ast::node_id,
-                          mut ignore_adjustments: LinearMap<ast::node_id,()>};
+                          mut ignore_adjustments: LinearSet<ast::node_id>};
 
 fn gather_loans(bccx: borrowck_ctxt, crate: @ast::crate) -> req_maps {
     let glcx = gather_loan_ctxt(@{bccx: bccx,
                                   req_maps: {req_loan_map: HashMap(),
                                              pure_map: HashMap()},
                                   mut item_ub: 0,
                                   mut root_ub: 0,
-                                  mut ignore_adjustments: LinearMap()});
+                                  mut ignore_adjustments: LinearSet::new()});
     let v = visit::mk_vt(@visit::Visitor {visit_expr: req_loans_in_expr,
                                           visit_fn: req_loans_in_fn,
+                                          visit_stmt: add_stmt_to_map,
                                           .. *visit::default_visitor()});
     visit::visit_crate(*crate, glcx, v);
     return glcx.req_maps;
@@ -125,7 +126,7 @@ fn req_loans_in_expr(ex: @ast::expr,
            ex.id, pprust::expr_to_str(ex, tcx.sess.intr()));
 
     // If this expression is borrowed, have to ensure it remains valid:
-    if !self.ignore_adjustments.contains_key(&ex.id) {
+    if !self.ignore_adjustments.contains(&ex.id) {
         for tcx.adjustments.find(ex.id).each |adjustments| {
             self.guarantee_adjustments(ex, *adjustments);
         }
@@ -220,7 +221,7 @@ fn req_loans_in_expr(ex: @ast::expr,
 
         // FIXME (#3387): Total hack: Ignore adjustments for the left-hand
         // side. Their regions will be inferred to be too large.
-        self.ignore_adjustments.insert(rcvr.id, ());
+        self.ignore_adjustments.insert(rcvr.id);
 
         visit::visit_expr(ex, self, vt);
       }
@@ -573,3 +574,16 @@ impl gather_loan_ctxt {
     }
 }
 
+// Setting up info that preserve needs.
+// This is just the most convenient place to do it.
+fn add_stmt_to_map(stmt: @ast::stmt,
+                   &&self: gather_loan_ctxt,
+                   vt: visit::vt<gather_loan_ctxt>) {
+    match stmt.node {
+        ast::stmt_expr(_, id) | ast::stmt_semi(_, id) => {
+            self.bccx.stmt_map.insert(id, ());
+        }
+        _ => ()
+    }
+    visit::visit_stmt(stmt, self, vt);
+}

branches/dist-snap/src/librustc/middle/borrowck/mod.rs

@@ -232,7 +232,7 @@ use middle::liveness;
 use middle::mem_categorization::*;
 use middle::region;
 use middle::ty;
-use util::common::indenter;
+use util::common::{indenter, stmt_set};
 use util::ppaux::{expr_repr, note_and_explain_region};
 use util::ppaux::{ty_to_str, region_to_str, explain_region};
 
@@ -272,6 +272,7 @@ fn check_crate(tcx: ty::ctxt,
                                 root_map: root_map(),
                                 mutbl_map: HashMap(),
                                 write_guard_map: HashMap(),
+                                stmt_map: HashMap(),
                                 mut loaned_paths_same: 0,
                                 mut loaned_paths_imm: 0,
                                 mut stable_paths: 0,
@@ -313,6 +314,7 @@ type borrowck_ctxt_ = {tcx: ty::ctxt,
                        root_map: root_map,
                        mutbl_map: mutbl_map,
                        write_guard_map: write_guard_map,
+                       stmt_map: stmt_set,
 
                        // Statistics:
                        mut loaned_paths_same: uint,