---

yaml
---
r: 30522
b: refs/heads/incoming
c: b776395
h: refs/heads/master
v: v3

Author: brson

[refs]

@@ -6,7 +6,7 @@ refs/heads/try: d324a424d8f84b1eb049b12cf34182bda91b0024
 refs/tags/release-0.1: 1f5c5126e96c79d22cb7862f75304136e204f105
 refs/heads/ndm: f3868061cd7988080c30d6d5bf352a5a5fe2460b
 refs/heads/try2: d0c6ce338884ee21843f4b40bf6bf18d222ce5df
-refs/heads/incoming: 62b51d9152e3289c8054792035ea63088247fead
+refs/heads/incoming: b776395263bfc9908d8fec80d7d1d0f67b8490e8
 refs/heads/dist-snap: 2f32a1581f522e524009138b33b1c7049ced668d
 refs/tags/release-0.2: c870d2dffb391e14efb05aa27898f1f6333a9596
 refs/tags/release-0.3: b5f0d0f648d9a6153664837026ba1be43d3e2503

branches/incoming/src/cargo/cargo.rs

@@ -13,6 +13,7 @@ use std::{map, json, tempfile, term, sort, getopts};
 use map::HashMap;
 use to_str::to_str;
 use getopts::{optflag, optopt, opt_present};
+use dvec::DVec;
 
 type package = {
     name: ~str,
@@ -60,7 +61,7 @@ type source = @{
     mut method: ~str,
     mut key: Option<~str>,
     mut keyfp: Option<~str>,
-    mut packages: ~[mut package]
+    packages: DVec<package>
 };
 
 type cargo = {
@@ -448,7 +449,7 @@ fn parse_source(name: ~str, j: json::Json) -> source {
                 mut method: method,
                 mut key: key,
                 mut keyfp: keyfp,
-                mut packages: ~[mut] };
+                packages: DVec() };
         }
         _ => fail ~"needed dict value in source"
     };
@@ -558,14 +559,14 @@ fn load_one_source_package(src: source, p: map::HashMap<~str, json::Json>) {
         versions: ~[]
     };
 
-    match vec::position(src.packages, |pkg| pkg.uuid == uuid) {
-      Some(idx) => {
-        src.packages[idx] = newpkg;
-        log(debug, ~"  updated package: " + src.name + ~"/" + name);
-      }
-      None => {
-        vec::grow(src.packages, 1u, newpkg);
-      }
+    match src.packages.position(|pkg| pkg.uuid == uuid) {
+        Some(idx) => {
+            src.packages.set_elt(idx, newpkg);
+            log(debug, ~"  updated package: " + src.name + ~"/" + name);
+        }
+        None => {
+            src.packages.push(newpkg);
+        }
     }
 
     log(debug, ~"  loaded package: " + src.name + ~"/" + name);
@@ -713,10 +714,7 @@ fn configure(opts: options) -> cargo {
 
 fn for_each_package(c: cargo, b: fn(source, package)) {
     for c.sources.each_value |v| {
-        // FIXME (#2280): this temporary shouldn't be
-        // necessary, but seems to be, for borrowing.
-        let pks = copy v.packages;
-        for vec::each(pks) |p| {
+        for v.packages.each |p| {
             b(v, p);
         }
     }
@@ -948,30 +946,28 @@ fn install_named(c: cargo, wd: &Path, name: ~str) {
 
 fn install_uuid_specific(c: cargo, wd: &Path, src: ~str, uuid: ~str) {
     match c.sources.find(src) {
-      Some(s) => {
-        let packages = copy s.packages;
-        if vec::any(packages, |p| {
-            if p.uuid == uuid {
-                install_package(c, src, wd, p);
-                true
-            } else { false }
-        }) { return; }
-      }
-      _ => ()
+        Some(s) => {
+            for s.packages.each |p| {
+                if p.uuid == uuid {
+                    install_package(c, src, wd, p);
+                    return;
+                }
+            }
+        }
+        _ => ()
     }
     error(~"can't find package: " + src + ~"/" + uuid);
 }
 
 fn install_named_specific(c: cargo, wd: &Path, src: ~str, name: ~str) {
     match c.sources.find(src) {
         Some(s) => {
-          let packages = copy s.packages;
-          if vec::any(packages, |p| {
+            for s.packages.each |p| {
                 if p.name == name {
                     install_package(c, src, wd, p);
-                    true
-                } else { false }
-            }) { return; }
+                    return;
+                }
+            }
         }
         _ => ()
     }
@@ -1500,8 +1496,7 @@ fn print_pkg(s: source, p: package) {
 fn print_source(s: source) {
     info(s.name + ~" (" + s.url + ~")");
 
-    let unsorted_pks = s.packages;  // to prevent illegal borrow?
-    let pks = sort::merge_sort(sys::shape_lt, unsorted_pks);
+    let pks = sort::merge_sort(sys::shape_lt, s.packages.get());
     let l = vec::len(pks);
 
     print(io::with_str_writer(|writer| {
@@ -1685,7 +1680,7 @@ fn cmd_sources(c: cargo) {
                     mut method: assume_source_method(url),
                     mut key: None,
                     mut keyfp: None,
-                    mut packages: ~[mut]
+                    packages: DVec()
                 });
                 info(fmt!("added source: %s", name));
             }

branches/incoming/src/libcore/iter-trait.rs

@@ -18,14 +18,14 @@ impl<A> IMPL_T<A>: iter::ExtendedIter<A> {
     pure fn foldl<B>(+b0: B, blk: fn(B, A) -> B) -> B {
         iter::foldl(self, move b0, blk)
     }
+    pure fn position(f: fn(A) -> bool) -> Option<uint> {
+        iter::position(self, f)
+    }
 }
 
 impl<A: Eq> IMPL_T<A>: iter::EqIter<A> {
     pure fn contains(x: A) -> bool { iter::contains(self, x) }
     pure fn count(x: A) -> uint { iter::count(self, x) }
-    pure fn position(f: fn(A) -> bool) -> Option<uint> {
-        iter::position(self, f)
-    }
 }
 
 impl<A: Copy> IMPL_T<A>: iter::CopyableIter<A> {

branches/incoming/src/libcore/iter.rs

@@ -13,12 +13,12 @@ trait ExtendedIter<A> {
     pure fn all(blk: fn(A) -> bool) -> bool;
     pure fn any(blk: fn(A) -> bool) -> bool;
     pure fn foldl<B>(+b0: B, blk: fn(B, A) -> B) -> B;
+    pure fn position(f: fn(A) -> bool) -> Option<uint>;
 }
 
 trait EqIter<A:Eq> {
     pure fn contains(x: A) -> bool;
     pure fn count(x: A) -> uint;
-    pure fn position(f: fn(A) -> bool) -> Option<uint>;
 }
 
 trait Times {
@@ -142,7 +142,8 @@ pure fn count<A:Eq,IA:BaseIter<A>>(self: IA, x: A) -> uint {
 }
 
 pure fn position<A,IA:BaseIter<A>>(self: IA, f: fn(A) -> bool)
-        -> Option<uint> {
+    -> Option<uint>
+{
     let mut i = 0;
     for self.each |a| {
         if f(a) { return Some(i); }

branches/incoming/src/libcore/repr.rs

@@ -184,7 +184,7 @@ impl ReprPrinterWrapper {
             self.printer.ptr = transmute(&(*box).data);
             intrinsic::visit_tydesc((*box).type_desc, self as @TyVisitor);
             let box_size = sys::size_of::<*BoxRepr>();
-            self.printer.ptr = transmute(self.printer.ptr as uint + box_size);
+            self.printer.ptr = transmute(box_ptr as uint + box_size);
             true
         }
     }
@@ -200,7 +200,7 @@ impl ReprPrinterWrapper {
                 intrinsic::visit_tydesc(inner, self as @TyVisitor);
             }
             let ptr_size = sys::size_of::<*c_void>();
-            self.printer.ptr = transmute(self.printer.ptr as uint + ptr_size);
+            self.printer.ptr = transmute(data_ptr as uint + ptr_size);
             true
         }
     }
@@ -508,7 +508,7 @@ impl ReprPrinterWrapper : TyVisitor {
                                 _disr_val: int,
                                 n_fields: uint,
                                 _name: &str) -> bool {
-        if !self.printer.skip && n_fields > 1 {
+        if !self.printer.skip && n_fields >= 1 {
             self.printer.writer.write_char(')');
         }
         true

branches/incoming/src/libcore/rt.rs

@@ -33,12 +33,6 @@ extern mod rustrt {
 // FIXME (#2861): This needs both the attribute, and the name prefixed with
 // 'rt_', otherwise the compiler won't find it. To fix this, see
 // gather_rust_rtcalls.
-#[rt(fail)]
-fn rt_fail(expr: *c_char, file: *c_char, line: size_t) {
-    cleanup_stack_for_failure();
-    rustrt::rust_upcall_fail(expr, file, line);
-}
-
 #[rt(fail_)]
 fn rt_fail_(expr: *c_char, file: *c_char, line: size_t) {
     cleanup_stack_for_failure();

branches/incoming/src/libcore/task.rs

@@ -1403,9 +1403,11 @@ fn spawn_raw(+opts: TaskOpts, +f: fn~()) {
 
         let num_threads = match opts.mode {
           SingleThreaded => 1u,
-          ThreadPerCore => rustrt::rust_num_threads(),
+          ThreadPerCore => {
+            fail ~"thread_per_core scheduling mode unimplemented"
+          }
           ThreadPerTask => {
-            fail ~"ThreadPerTask scheduling mode unimplemented"
+            fail ~"thread_per_task scheduling mode unimplemented"
           }
           ManualThreads(threads) => {
             if threads == 0u {
@@ -1655,8 +1657,6 @@ extern mod rustrt {
 
     fn rust_get_sched_id() -> sched_id;
     fn rust_new_sched(num_threads: libc::uintptr_t) -> sched_id;
-    fn sched_threads() -> libc::size_t;
-    fn rust_num_threads() -> libc::uintptr_t;
 
     fn get_task_id() -> task_id;
     #[rust_stack]
@@ -2422,13 +2422,3 @@ fn test_tls_cleanup_on_failure() unsafe {
     local_data_set(int_key, @31337);
     fail;
 }
-
-#[test]
-fn test_sched_thread_per_core() {
-    let cores = rustrt::rust_num_threads();
-    let mut reported_threads = 0u;
-    do spawn_sched(ThreadPerCore) {
-        reported_threads = rustrt::sched_threads();
-    }
-    assert(cores == reported_threads);
-}

branches/incoming/src/libcore/vec.rs

@@ -2019,14 +2019,14 @@ impl<A> &[A]: iter::ExtendedIter<A> {
     pure fn foldl<B>(+b0: B, blk: fn(B, A) -> B) -> B {
         iter::foldl(self, move b0, blk)
     }
+    pure fn position(f: fn(A) -> bool) -> Option<uint> {
+        iter::position(self, f)
+    }
 }
 
 impl<A: Eq> &[A]: iter::EqIter<A> {
     pure fn contains(x: A) -> bool { iter::contains(self, x) }
     pure fn count(x: A) -> uint { iter::count(self, x) }
-    pure fn position(f: fn(A) -> bool) -> Option<uint> {
-        iter::position(self, f)
-    }
 }
 
 impl<A: Copy> &[A]: iter::CopyableIter<A> {

branches/incoming/src/rt/rust_builtin.cpp

@@ -572,12 +572,6 @@ rust_get_sched_id() {
     return task->sched->get_id();
 }
 
-extern "C" CDECL uintptr_t
-rust_num_threads() {
-    rust_task *task = rust_get_current_task();
-    return task->kernel->env->num_sched_threads;
-}
-
 extern "C" CDECL rust_sched_id
 rust_new_sched(uintptr_t threads) {
     rust_task *task = rust_get_current_task();
@@ -626,7 +620,7 @@ start_task(rust_task *target, fn_env_pair *f) {
     target->start(f->f, f->env, NULL);
 }
 
-extern "C" CDECL size_t
+extern "C" CDECL int
 sched_threads() {
     rust_task *task = rust_get_current_task();
     return task->sched->number_of_threads();

branches/incoming/src/rt/rustrt.def.in

@@ -32,7 +32,6 @@ rand_seed
 rust_get_sched_id
 rust_new_sched
 rust_new_task_in_sched
-rust_num_threads
 rust_path_is_dir
 rust_path_exists
 rust_getcwd

branches/incoming/src/rustc/middle/trans/base.rs

@@ -2714,16 +2714,6 @@ fn trans_crate(sess: session::session,
         io::println(fmt!("n_monos: %u", ccx.stats.n_monos));
         io::println(fmt!("n_inlines: %u", ccx.stats.n_inlines));
         io::println(fmt!("n_closures: %u", ccx.stats.n_closures));
-
-        // FIXME (#2280): this temporary shouldn't be
-        // necessary, but seems to be, for borrowing.
-        /*
-        let times = copy *ccx.stats.fn_times;
-        for vec::each(times) |timing| {
-            io::println(fmt!("time: %s took %d ms", timing.ident,
-                             timing.time));
-        }
-        */
     }
 
     if ccx.sess.count_llvm_insns() {

branches/incoming/src/snapshots.txt

@@ -1,3 +1,11 @@
+S 2012-09-12 fa74edf
+  macos-i386 da38aa39fd1515ea765790a3c320194bc50fd602
+  macos-x86_64 7509861e5a6d3e082ad9a9d3474661856b7731c1
+  freebsd-x86_64 c4e0517d6894d18342eb852b6e738f48d086004f
+  linux-i386 ee0d36b221d8d2dbb02cd1fd1feb09294e0dbb6f
+  linux-x86_64 ce585fd55ae42e33398870c3bc77a671547411aa
+  winnt-i386 5b32231d75d65c057ccd91a6f810e67941f5400a
+
 S 2012-09-12 8fbe4b5
   macos-x86_64 bdbd0feff0391b902ea0a0c68948962c0acf5dae
   macos-i386 c7e0da4ffb778045f77b84878872dc3944d147da

branches/incoming/src/test/bench/shootout-mandelbrot.rs

@@ -118,7 +118,7 @@ fn writer(path: ~str, writech: comm::Chan<comm::Chan<line>>, size: uint)
     };
     cout.write_line(~"P4");
     cout.write_line(fmt!("%u %u", size, size));
-    let lines = std::map::uint_hash();
+    let lines: HashMap<uint, ~[u8]> = std::map::uint_hash();
     let mut done = 0_u;
     let mut i = 0_u;
     while i < size {
@@ -131,10 +131,7 @@ fn writer(path: ~str, writech: comm::Chan<comm::Chan<line>>, size: uint)
             while prev <= i {
                 if lines.contains_key(prev) {
                     debug!("WS %u", prev);
-                    // FIXME (#2280): this temporary shouldn't be
-                    // necessary, but seems to be, for borrowing.
-                    let v : ~[u8] = lines.get(prev);
-                    cout.write(v);
+                    cout.write(lines.get(prev));
                     done += 1_u;
                     lines.remove(prev);
                     prev += 1_u;

branches/incoming/src/test/run-pass/log-knows-the-names-of-variants.rs

@@ -4,8 +4,13 @@ enum foo {
   c,
 }
 
+enum bar {
+  d, e, f
+}
+
 fn main() {
     assert ~"a(22)" == fmt!("%?", a(22u));
     assert ~"b(~\"hi\")" == fmt!("%?", b(~"hi"));
     assert ~"c" == fmt!("%?", c);
+    assert ~"d" == fmt!("%?", d);
 }