---

yaml
---
r: 63629
b: refs/heads/snap-stage3
c: fe6a4fd
h: refs/heads/master
i:
  63627: b779641
v: v3

Author: emberian

[refs]

@@ -1,7 +1,7 @@
 ---
 refs/heads/master: 2d28d645422c1617be58c8ca7ad9a457264ca850
 refs/heads/snap-stage1: e33de59e47c5076a89eadeb38f4934f58a3618a6
-refs/heads/snap-stage3: c6515ee6a7f424679e2b53336974a991dd3b71c8
+refs/heads/snap-stage3: fe6a4fd74a0a640fa9291f7cd4d31778da85e39b
 refs/heads/try: 7b78b52e602bb3ea8174f9b2006bff3315f03ef9
 refs/tags/release-0.1: 1f5c5126e96c79d22cb7862f75304136e204f105
 refs/heads/ndm: f3868061cd7988080c30d6d5bf352a5a5fe2460b

branches/snap-stage3/src/libextra/arena.rs

@@ -1,4 +1,4 @@
-// Copyright 2012-2013 The Rust Project Developers. See the COPYRIGHT
+// Copyright 2012 The Rust Project Developers. See the COPYRIGHT
 // file at the top-level directory of this distribution and at
 // http://rust-lang.org/COPYRIGHT.
 //
@@ -39,7 +39,7 @@ use core::prelude::*;
 use list::{MutList, MutCons, MutNil};
 
 use core::at_vec;
-use core::cast::{transmute, transmute_mut, transmute_mut_region};
+use core::cast::{transmute, transmute_mut_region};
 use core::cast;
 use core::libc::size_t;
 use core::ptr;
@@ -74,7 +74,6 @@ struct Chunk {
     is_pod: bool,
 }
 
-#[mutable]
 pub struct Arena {
     // The head is separated out from the list as a unbenchmarked
     // microoptimization, to avoid needing to case on the list to
@@ -270,22 +269,23 @@ impl Arena {
 
     // The external interface
     #[inline]
-    pub fn alloc<'a, T>(&'a self, op: &fn() -> T) -> &'a T {
+    pub fn alloc<'a, T>(&'a mut self, op: &fn() -> T) -> &'a T {
         unsafe {
             // XXX: Borrow check
-            let this = transmute_mut(self);
-            if intrinsics::needs_drop::<T>() {
-                this.alloc_nonpod(op)
-            } else {
-                this.alloc_pod(op)
+            let this = transmute_mut_region(self);
+            if !intrinsics::needs_drop::<T>() {
+                return this.alloc_pod(op);
             }
+            // XXX: Borrow check
+            let this = transmute_mut_region(self);
+            this.alloc_nonpod(op)
         }
     }
 }
 
 #[test]
 fn test_arena_destructors() {
-    let arena = Arena();
+    let mut arena = Arena();
     for uint::range(0, 10) |i| {
         // Arena allocate something with drop glue to make sure it
         // doesn't leak.
@@ -300,7 +300,7 @@ fn test_arena_destructors() {
 #[should_fail]
 #[ignore(cfg(windows))]
 fn test_arena_destructors_fail() {
-    let arena = Arena();
+    let mut arena = Arena();
     // Put some stuff in the arena.
     for uint::range(0, 10) |i| {
         // Arena allocate something with drop glue to make sure it

branches/snap-stage3/src/test/bench/shootout-binarytrees.rs

@@ -1,4 +1,8 @@
-// Copyright 2012-2013 The Rust Project Developers. See the COPYRIGHT
+// xfail-test
+
+// Broken due to arena API problems.
+
+// Copyright 2012 The Rust Project Developers. See the COPYRIGHT
 // file at the top-level directory of this distribution and at
 // http://rust-lang.org/COPYRIGHT.
 //
@@ -11,35 +15,33 @@
 extern mod extra;
 use extra::arena;
 
-enum Tree<'self> {
-    Nil,
-    Node(&'self Tree<'self>, &'self Tree<'self>, int),
+enum tree<'self> {
+    nil,
+    node(&'self tree<'self>, &'self tree<'self>, int),
 }
 
-fn item_check(t: &Tree) -> int {
+fn item_check(t: &tree) -> int {
     match *t {
-      Nil => { return 0; }
-      Node(left, right, item) => {
+      nil => { return 0; }
+      node(left, right, item) => {
         return item + item_check(left) - item_check(right);
       }
     }
 }
 
-fn bottom_up_tree<'r>(arena: &'r arena::Arena, item: int, depth: int)
-                   -> &'r Tree<'r> {
+fn bottom_up_tree<'r>(arena: &'r mut arena::Arena, item: int, depth: int)
+                   -> &'r tree<'r> {
     if depth > 0 {
         return arena.alloc(
-            || Node(bottom_up_tree(arena, 2 * item - 1, depth - 1),
+            || node(bottom_up_tree(arena, 2 * item - 1, depth - 1),
                     bottom_up_tree(arena, 2 * item, depth - 1),
                     item));
     }
-    return arena.alloc(|| Nil);
+    return arena.alloc(|| nil);
 }
 
 fn main() {
-    use std::os;
-    use std::int;
-    let args = std::os::args();
+    let args = os::args();
     let args = if os::getenv(~"RUST_BENCH").is_some() {
         ~[~"", ~"17"]
     } else if args.len() <= 1u {
@@ -57,34 +59,34 @@ fn main() {
         max_depth = n;
     }
 
-    let stretch_arena = arena::Arena();
+    let mut stretch_arena = arena::Arena();
     let stretch_depth = max_depth + 1;
-    let stretch_tree = bottom_up_tree(&stretch_arena, 0, stretch_depth);
+    let stretch_tree = bottom_up_tree(&mut stretch_arena, 0, stretch_depth);
 
-    println(fmt!("stretch tree of depth %d\t check: %d",
+    io::println(fmt!("stretch tree of depth %d\t check: %d",
                           stretch_depth,
                           item_check(stretch_tree)));
 
-    let long_lived_arena = arena::Arena();
-    let long_lived_tree = bottom_up_tree(&long_lived_arena, 0, max_depth);
+    let mut long_lived_arena = arena::Arena();
+    let long_lived_tree = bottom_up_tree(&mut long_lived_arena, 0, max_depth);
     let mut depth = min_depth;
     while depth <= max_depth {
         let iterations = int::pow(2, (max_depth - depth + min_depth) as uint);
         let mut chk = 0;
         let mut i = 1;
         while i <= iterations {
-            let mut temp_tree = bottom_up_tree(&long_lived_arena, i, depth);
+            let mut temp_tree = bottom_up_tree(&mut long_lived_arena, i, depth);
             chk += item_check(temp_tree);
-            temp_tree = bottom_up_tree(&long_lived_arena, -i, depth);
+            temp_tree = bottom_up_tree(&mut long_lived_arena, -i, depth);
             chk += item_check(temp_tree);
             i += 1;
         }
-        println(fmt!("%d\t trees of depth %d\t check: %d",
+        io::println(fmt!("%d\t trees of depth %d\t check: %d",
                          iterations * 2, depth,
                          chk));
         depth += 2;
     }
-    println(fmt!("long lived tree of depth %d\t check: %d",
+    io::println(fmt!("long lived trees of depth %d\t check: %d",
                      max_depth,
                      item_check(long_lived_tree)));
 }

branches/snap-stage3/src/test/bench/shootout-chameneos-redux.rs

@@ -85,7 +85,7 @@ fn show_number(nn: uint) -> ~str {
         out = show_digit(dig) + " " + out;
     }
 
-    return ~" " + out;
+    return out;
 }
 
 fn transform(aa: color, bb: color) -> color {

branches/snap-stage3/src/test/bench/shootout-fasta.rs

@@ -1,4 +1,4 @@
-// Copyright 2012-2013 The Rust Project Developers. See the COPYRIGHT
+// Copyright 2012 The Rust Project Developers. See the COPYRIGHT
 // file at the top-level directory of this distribution and at
 // http://rust-lang.org/COPYRIGHT.
 //
@@ -19,14 +19,16 @@ extern mod extra;
 
 use std::int;
 use std::io;
+use std::option;
 use std::os;
 use std::rand::Rng;
 use std::rand;
 use std::result;
 use std::str;
 use std::uint;
+use std::vec;
 
-static LINE_LENGTH: uint = 60u;
+fn LINE_LENGTH() -> uint { return 60u; }
 
 struct MyRandom {
     last: u32
@@ -79,7 +81,7 @@ fn make_random_fasta(wr: @io::Writer,
     for uint::range(0u, n as uint) |_i| {
         op.push_char(select_random(myrandom_next(rng, 100u32),
                                               copy genelist));
-        if op.len() >= LINE_LENGTH {
+        if op.len() >= LINE_LENGTH() {
             wr.write_line(op);
             op = ~"";
         }
@@ -88,18 +90,18 @@ fn make_random_fasta(wr: @io::Writer,
 }
 
 fn make_repeat_fasta(wr: @io::Writer, id: ~str, desc: ~str, s: ~str, n: int) {
-    wr.write_line(~">" + id + " " + desc);
-    let mut op = str::with_capacity( LINE_LENGTH );
-    let sl = s.len();
-    for uint::range(0u, n as uint) |i| {
-        if (op.len() >= LINE_LENGTH) {
-            wr.write_line( op );
-            op = str::with_capacity( LINE_LENGTH );
+    unsafe {
+        wr.write_line(~">" + id + " " + desc);
+        let mut op: ~str = ~"";
+        let sl: uint = s.len();
+        for uint::range(0u, n as uint) |i| {
+            str::raw::push_byte(&mut op, s[i % sl]);
+            if op.len() >= LINE_LENGTH() {
+                wr.write_line(op);
+                op = ~"";
+            }
         }
-        op.push_char( s[i % sl] as char );
-    }
-    if op.len() > 0 {
-        wr.write_line(op)
+        if op.len() > 0u { wr.write_line(op); }
     }
 }
 
@@ -109,7 +111,7 @@ fn acid(ch: char, prob: u32) -> AminoAcids {
 
 fn main() {
     let args = os::args();
-    let args = if os::getenv("RUST_BENCH").is_some() {
+    let args = if os::getenv(~"RUST_BENCH").is_some() {
         // alioth tests k-nucleotide with this data at 25,000,000
         ~[~"", ~"5000000"]
     } else if args.len() <= 1u {
@@ -118,9 +120,9 @@ fn main() {
         args
     };
 
-    let writer = if os::getenv("RUST_BENCH").is_some() {
+    let writer = if os::getenv(~"RUST_BENCH").is_some() {
         result::get(&io::file_writer(&Path("./shootout-fasta.data"),
-                                    [io::Truncate, io::Create]))
+                                    ~[io::Truncate, io::Create]))
     } else {
         io::stdout()
     };

branches/snap-stage3/src/test/bench/shootout-spectralnorm.rs

@@ -1,13 +1,3 @@
-// Copyright 2012-2013 The Rust Project Developers. See the COPYRIGHT
-// file at the top-level directory of this distribution and at
-// http://rust-lang.org/COPYRIGHT.
-//
-// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
-// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
-// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
-// option. This file may not be copied, modified, or distributed
-// except according to those terms.
-
 use std::f64;
 use std::from_str::FromStr;
 use std::os;

branches/snap-stage3/src/test/run-pass/newlambdas-ret-infer2.rs

@@ -8,7 +8,6 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-// xfail-test ~fn is not inferred
 // Test that the lambda kind is inferred correctly as a return
 // expression