---

yaml
---
r: 16070
b: refs/heads/try
c: bf129bd
h: refs/heads/master
v: v3

Author: brson

[refs]

@@ -2,5 +2,5 @@
 refs/heads/master: 61b1875c16de39c166b0f4d54bba19f9c6777d1a
 refs/heads/snap-stage1: e33de59e47c5076a89eadeb38f4934f58a3618a6
 refs/heads/snap-stage3: 4a81779abd786ff22d71434c6d9a5917ea4cdfff
-refs/heads/try: 0fa7858d1e8d4ebf6e881780ec9a37cf22f4c0b0
+refs/heads/try: bf129bd35f129e03ad36dae492d52cbf50d9b7c9
 refs/tags/release-0.1: 1f5c5126e96c79d22cb7862f75304136e204f105

branches/try/src/cargo/cargo.rs

@@ -603,7 +603,7 @@ fn install_uuid(c: cargo, wd: str, uuid: str) {
     for_each_package(c, { |s, p|
         info(#fmt["%s ? %s", p.uuid, uuid]);
         if p.uuid == uuid {
-            vec::grow(ps, 1u, (s, p));
+            vec::grow(ps, 1u, (s.name, p));
         }
     });
     if vec::len(ps) == 1u {
@@ -616,16 +616,16 @@ fn install_uuid(c: cargo, wd: str, uuid: str) {
     }
     error("Found multiple packages:");
     for ps.each {|elt|
-        let (s,p) = elt;
-        info("  " + s.name + "/" + p.uuid + " (" + p.name + ")");
+        let (sname,p) = elt;
+        info("  " + sname + "/" + p.uuid + " (" + p.name + ")");
     }
 }
 
 fn install_named(c: cargo, wd: str, name: str) {
     let mut ps = [];
     for_each_package(c, { |s, p|
         if p.name == name {
-            vec::grow(ps, 1u, (s, p));
+            vec::grow(ps, 1u, (s.name, p));
         }
     });
     if vec::len(ps) == 1u {
@@ -638,8 +638,8 @@ fn install_named(c: cargo, wd: str, name: str) {
     }
     error("Found multiple packages:");
     for ps.each {|elt|
-        let (s,p) = elt;
-        info("  " + s.name + "/" + p.uuid + " (" + p.name + ")");
+        let (sname,p) = elt;
+        info("  " + sname + "/" + p.uuid + " (" + p.name + ")");
     }
 }
 

branches/try/src/compiletest/runtest.rs

@@ -277,7 +277,7 @@ fn check_expected_errors(expected_errors: [errors::expected_error],
         }
     }
 
-    uint::range(0u, vec::len(found_flags)) {|i|
+    for uint::range(0u, vec::len(found_flags)) {|i|
         if !found_flags[i] {
             let ee = expected_errors[i];
             fatal_procres(#fmt["expected %s on line %u not found: %s",

branches/try/src/libcore/core.rc

@@ -13,7 +13,7 @@ built-in types and runtime services, or that is used in nearly every
 non-trivial program.
 
 `core` includes modules corresponding to each of the integer types, each of
-THE floating point types, the `bool` type, tuples, characters, strings,
+the floating point types, the `bool` type, tuples, characters, strings,
 vectors (`vec`), shared boxes (`box`), and unsafe pointers (`ptr`).
 Additionally, `core` provides very commonly used built-in types and
 operations, concurrency primitives, platform abstractions, I/O, and complete

branches/try/src/libcore/int-template.rs

@@ -36,9 +36,12 @@ pure fn is_nonpositive(x: T) -> bool { x <= 0 as T }
 pure fn is_nonnegative(x: T) -> bool { x >= 0 as T }
 
 #[doc = "Iterate over the range [`lo`..`hi`)"]
-fn range(lo: T, hi: T, it: fn(T)) {
+fn range(lo: T, hi: T, it: fn(T) -> bool) {
     let mut i = lo;
-    while i < hi { it(i); i += 1 as T; }
+    while i < hi {
+        if !it(i) { break }
+        i += 1 as T;
+    }
 }
 
 #[doc = "Computes the bitwise complement"]

branches/try/src/libcore/priv.rs

@@ -24,7 +24,7 @@ task to receive from it.
 unsafe fn chan_from_global_ptr<T: send>(
     global: global_ptr,
     builder: fn() -> task::builder,
-    f: fn~(comm::port<T>)
+    +f: fn~(comm::port<T>)
 ) -> comm::chan<T> {
 
     enum msg {
@@ -127,12 +127,12 @@ fn test_from_global_chan2() unsafe {
 
         // Spawn a bunch of tasks that all want to compete to
         // create the global channel
-        uint::range(0u, 10u) {|i|
+        for uint::range(0u, 10u) {|i|
             task::spawn() {||
                 let ch = chan_from_global_ptr(
                     globchanp, task::builder) {|po|
 
-                    uint::range(0u, 10u) {|_j|
+                    for uint::range(0u, 10u) {|_j|
                         let ch = comm::recv(po);
                         comm::send(ch, {i});
                     }
@@ -147,7 +147,7 @@ fn test_from_global_chan2() unsafe {
         }
         // There should be only one winner
         let mut winners = 0u;
-        uint::range(0u, 10u) {|_i|
+        for uint::range(0u, 10u) {|_i|
             let res = comm::recv(resultpo);
             if res { winners += 1u };
         }
@@ -233,4 +233,4 @@ fn test_weaken_task_fail() unsafe {
         }
     };
     assert result::is_failure(res);
-}
+}

branches/try/src/libcore/rand.rs

@@ -202,7 +202,7 @@ impl extensions for rng {
     fn weighted_vec<T:copy>(v: [weighted<T>]) -> [T] {
         let mut r = [];
         for v.each {|item|
-            uint::range(0u, item.weight) {|_i|
+            for uint::range(0u, item.weight) {|_i|
                 r += [item.item];
             }
         }

branches/try/src/libcore/to_str.rs

@@ -1,13 +1,28 @@
 iface to_str { fn to_str() -> str; }
 
-impl of to_str for int {
-    fn to_str() -> str { int::str(self) }
+impl of to_str for i8 {
+    fn to_str() -> str { i8::str(self) }
 }
-impl of to_str for uint {
-    fn to_str() -> str { uint::str(self) }
+impl of to_str for i16 {
+    fn to_str() -> str { i16::str(self) }
+}
+impl of to_str for i32 {
+    fn to_str() -> str { i32::str(self) }
+}
+impl of to_str for i64 {
+    fn to_str() -> str { i64::str(self) }
 }
 impl of to_str for u8 {
-    fn to_str() -> str { uint::str(self as uint) }
+    fn to_str() -> str { u8::str(self) }
+}
+impl of to_str for u16 {
+    fn to_str() -> str { u16::str(self) }
+}
+impl of to_str for u32 {
+    fn to_str() -> str { u32::str(self) }
+}
+impl of to_str for u64 {
+    fn to_str() -> str { u64::str(self) }
 }
 impl of to_str for float {
     fn to_str() -> str { float::to_str(self, 4u) }

branches/try/src/libcore/uint-template.rs

@@ -35,9 +35,12 @@ pure fn is_nonpositive(x: T) -> bool { x <= 0 as T }
 pure fn is_nonnegative(x: T) -> bool { x >= 0 as T }
 
 #[doc = "Iterate over the range [`lo`..`hi`)"]
-fn range(lo: T, hi: T, it: fn(T)) {
+fn range(lo: T, hi: T, it: fn(T) -> bool) {
     let mut i = lo;
-    while i < hi { it(i); i += 1 as T; }
+    while i < hi {
+        if !it(i) { break }
+        i += 1 as T;
+    }
 }
 
 #[doc = "Computes the bitwise complement"]

branches/try/src/libcore/vec.rs

@@ -199,13 +199,6 @@ fn from_mut<T>(+v: [mut T]) -> [T] unsafe {
     r
 }
 
-// This function only exists to work around bugs in the type checker.
-fn from_const<T>(+v: [const T]) -> [T] unsafe {
-    let r = ::unsafe::reinterpret_cast(v);
-    ::unsafe::forget(v);
-    r
-}
-
 // Accessors
 
 #[doc = "Returns the first element of a vector"]
@@ -534,7 +527,7 @@ Flattens a vector of vectors of T into a single vector of T.
 "]
 fn concat<T: copy>(v: [const [const T]]) -> [T] {
     let mut r = [];
-    for each(v) {|inner| r += from_const(inner); }
+    for each(v) {|inner| r += inner; }
     ret r;
 }
 
@@ -546,7 +539,7 @@ fn connect<T: copy>(v: [const [const T]], sep: T) -> [T] {
     let mut first = true;
     for each(v) {|inner|
         if first { first = false; } else { push(r, sep); }
-        r += from_const(inner);
+        r += inner;
     }
     ret r;
 }
@@ -899,7 +892,7 @@ Both vectors must have the same length
 #[inline]
 fn iter2<U, T>(v1: [const U], v2: [const T], f: fn(U, T)) {
     assert len(v1) == len(v2);
-    uint::range(0u, len(v1)) {|i|
+    for uint::range(0u, len(v1)) {|i|
         f(v1[i], v2[i])
     }
 }

branches/try/src/librustsyntax/codemap.rs

@@ -183,7 +183,7 @@ fn span_to_lines(sp: span, cm: codemap::codemap) -> @file_lines {
     let lo = lookup_char_pos(cm, sp.lo);
     let hi = lookup_char_pos(cm, sp.hi);
     let mut lines = [];
-    uint::range(lo.line - 1u, hi.line as uint) {|i| lines += [i]; };
+    for uint::range(lo.line - 1u, hi.line as uint) {|i| lines += [i]; };
     ret @{file: lo.file, lines: lines};
 }
 

branches/try/src/librustsyntax/ext/qquote.rs

@@ -193,7 +193,7 @@ fn finish<T: qq_helper>
     let qcx = gather_anti_quotes(sp.lo, node);
     let cx = qcx;
 
-    uint::range(1u, cx.gather.len()) {|i|
+    for uint::range(1u, cx.gather.len()) {|i|
         assert cx.gather[i-1u].lo < cx.gather[i].lo;
         // ^^ check that the vector is sorted
         assert cx.gather[i-1u].hi <= cx.gather[i].lo;

branches/try/src/libstd/arc.rs

@@ -19,15 +19,17 @@ type arc_data<T> = {
     data: T
 };
 
-resource arc_destruct<T>(data: *arc_data<T>) {
+resource arc_destruct<T>(data: *libc::c_void) {
     unsafe {
-        let ptr = &mut (*data).count;
+        let data: ~arc_data<T> = unsafe::reinterpret_cast(data);
+        let ref_ptr = &mut data.count;
 
-        let new_count = rustrt::rust_atomic_decrement(ptr);
+        let new_count = rustrt::rust_atomic_decrement(ref_ptr);
         assert new_count >= 0;
         if new_count == 0 {
-            let _ptr : ~arc_data<T> = unsafe::reinterpret_cast(data);
             // drop glue takes over.
+        } else {
+            unsafe::forget(data);
         }
     }
 }
@@ -48,7 +50,11 @@ fn arc<T>(-data: T) -> arc<T> {
  wrapper."]
 fn get<T>(rc: &a.arc<T>) -> &a.T {
     unsafe {
-        &(***rc).data
+        let ptr: ~arc_data<T> = unsafe::reinterpret_cast(**rc);
+        // Cast us back into the correct region
+        let r = unsafe::reinterpret_cast(&ptr.data);
+        unsafe::forget(ptr);
+        ret r;
     }
 }
 
@@ -58,9 +64,10 @@ The resulting two `arc` objects will point to the same underlying data
 object. However, one of the `arc` objects can be sent to another task,
 allowing them to share the underlying data."]
 fn clone<T>(rc: &arc<T>) -> arc<T> {
-    let data = **rc;
     unsafe {
-        rustrt::rust_atomic_increment(&mut (*data).count);
+        let ptr: ~arc_data<T> = unsafe::reinterpret_cast(**rc);
+        rustrt::rust_atomic_increment(&mut ptr.count);
+        unsafe::forget(ptr);
     }
     arc_destruct(**rc)
 }

branches/try/src/libstd/bitv.rs

@@ -46,7 +46,7 @@ fn process(v0: bitv, v1: bitv, op: fn(uint, uint) -> uint) -> bool {
     assert (vec::len(v0.storage) == len);
     assert (v0.nbits == v1.nbits);
     let mut changed = false;
-    uint::range(0u, len) {|i|
+    for uint::range(0u, len) {|i|
         let w0 = v0.storage[i];
         let w1 = v1.storage[i];
         let w = op(w0, w1);
@@ -90,7 +90,7 @@ fn assign(v0: bitv, v1: bitv) -> bool {
 fn clone(v: bitv) -> bitv {
     let storage = vec::to_mut(vec::from_elem(v.nbits / uint_bits + 1u, 0u));
     let len = vec::len(v.storage);
-    uint::range(0u, len) {|i| storage[i] = v.storage[i]; };
+    for uint::range(0u, len) {|i| storage[i] = v.storage[i]; };
     ret @{storage: storage, nbits: v.nbits};
 }
 
@@ -121,17 +121,17 @@ fn equal(v0: bitv, v1: bitv) -> bool {
 
 #[doc = "Set all bits to 0"]
 fn clear(v: bitv) {
-    uint::range(0u, vec::len(v.storage)) {|i| v.storage[i] = 0u; };
+    for uint::range(0u, vec::len(v.storage)) {|i| v.storage[i] = 0u; };
 }
 
 #[doc = "Set all bits to 1"]
 fn set_all(v: bitv) {
-    uint::range(0u, v.nbits) {|i| set(v, i, true); };
+    for uint::range(0u, v.nbits) {|i| set(v, i, true); };
 }
 
 #[doc = "Invert all bits"]
 fn invert(v: bitv) {
-    uint::range(0u, vec::len(v.storage)) {|i|
+    for uint::range(0u, vec::len(v.storage)) {|i|
         v.storage[i] = !v.storage[i];
     };
 }

branches/try/src/libstd/getopts.rs

@@ -132,7 +132,7 @@ enum optval { val(str), given, }
 The result of checking command line arguments. Contains a vector
 of matches and a vector of free strings.
 "]
-type match = {opts: [opt], vals: [mut [optval]], free: [str]};
+type match = {opts: [opt], vals: [[optval]], free: [str]};
 
 fn is_arg(arg: str) -> bool {
     ret str::len(arg) > 1u && arg[0] == '-' as u8;
@@ -275,7 +275,7 @@ fn getopts(args: [str], opts: [opt]) -> result unsafe {
         }
         i += 1u;
     }
-    ret ok({opts: opts, vals: vals, free: free});
+    ret ok({opts: opts, vals: vec::from_mut(vals), free: free});
 }
 
 fn opt_vals(m: match, nm: str) -> [optval] {