---

yaml
---
r: 62699
b: refs/heads/snap-stage3
c: b238a08
h: refs/heads/master
i:
  62697: 43c08e4
  62695: 57fcb85
v: v3

Author: bors

[refs]

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

branches/snap-stage3/mk/platform.mk

@@ -29,7 +29,7 @@ $(foreach t,$(CFG_TARGET_TRIPLES),$(info cfg: os for $(t) is $(OSTYPE_$(t))))
 # FIXME: no-omit-frame-pointer is just so that task_start_wrapper
 # has a frame pointer and the stack walker can understand it. Turning off
 # frame pointers everywhere is overkill
-CFG_GCCISH_CFLAGS += -fno-omit-frame-pointer
+CFG_GCCISH_CFLAGS += -fno-omit-frame-pointer -DUSE_UTF8
 
 # On Darwin, we need to run dsymutil so the debugging information ends
 # up in the right place.  On other platforms, it automatically gets

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

@@ -107,7 +107,7 @@ pub impl<'self> Condvar<'self> {
  ****************************************************************************/
 
 /// An atomically reference counted wrapper for shared immutable state.
-struct ARC<T> { x: UnsafeAtomicRcBox<T> }
+pub struct ARC<T> { x: UnsafeAtomicRcBox<T> }
 
 /// Create an atomically reference counted wrapper.
 pub fn ARC<T:Const + Owned>(data: T) -> ARC<T> {
@@ -118,29 +118,22 @@ pub fn ARC<T:Const + Owned>(data: T) -> ARC<T> {
  * Access the underlying data in an atomically reference counted
  * wrapper.
  */
-pub fn get<'a, T:Const + Owned>(rc: &'a ARC<T>) -> &'a T {
-    rc.get()
-}
-
-impl<T:Const+Owned> ARC<T> {
-    pub fn get<'a>(&'a self) -> &'a T {
+pub impl<T:Const+Owned> ARC<T> {
+    fn get<'a>(&'a self) -> &'a T {
         unsafe { &*self.x.get_immut() }
     }
 }
+
 /**
  * Duplicate an atomically reference counted wrapper.
  *
  * 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.
  */
-pub fn clone<T:Const + Owned>(rc: &ARC<T>) -> ARC<T> {
-    ARC { x: rc.x.clone() }
-}
-
 impl<T:Const + Owned> Clone for ARC<T> {
     fn clone(&self) -> ARC<T> {
-        clone(self)
+        ARC { x: self.x.clone() }
     }
 }
 
@@ -512,34 +505,31 @@ pub impl<'self, T:Const + Owned> RWReadMode<'self, T> {
 #[cfg(test)]
 mod tests {
     use core::prelude::*;
-
+    use core::cell::Cell;
     use arc::*;
     use arc;
 
-    use core::cell::Cell;
-    use core::task;
-
     #[test]
     fn manually_share_arc() {
         let v = ~[1, 2, 3, 4, 5, 6, 7, 8, 9, 10];
-        let arc_v = arc::ARC(v);
+        let arc_v = ARC(v);
 
         let (p, c) = comm::stream();
 
         do task::spawn() || {
             let p = comm::PortSet::new();
             c.send(p.chan());
 
-            let arc_v = p.recv();
+            let arc_v : ARC<~[int]> = p.recv();
 
-            let v = copy *arc::get::<~[int]>(&arc_v);
+            let v = copy (*arc_v.get());
             assert_eq!(v[3], 4);
         };
 
         let c = p.recv();
-        c.send(arc::clone(&arc_v));
+        c.send(arc_v.clone());
 
-        assert_eq!((*arc::get(&arc_v))[2], 3);
+        assert_eq!(arc_v.get()[2], 3);
         assert_eq!(arc_v.get()[4], 5);
 
         info!(arc_v);

branches/snap-stage3/src/librust/rust.rc

@@ -32,16 +32,17 @@ extern mod rustc;
 use core::prelude::*;
 
 use core::run;
+use core::libc::exit;
 
 enum ValidUsage {
-    Valid, Invalid
+    Valid(int), Invalid
 }
 
 impl ValidUsage {
     fn is_valid(&self) -> bool {
         match *self {
-            Valid   => true,
-            Invalid => false
+            Valid(_)   => true,
+            Invalid    => false
         }
     }
 }
@@ -144,7 +145,7 @@ fn cmd_help(args: &[~str]) -> ValidUsage {
                     UsgStr(msg) => io::println(fmt!("%s\n", msg)),
                     UsgCall(f)  => f(),
                 }
-                Valid
+                Valid(0)
             },
             None => Invalid
         }
@@ -162,8 +163,8 @@ fn cmd_test(args: &[~str]) -> ValidUsage {
             let test_exec = Path(filename).filestem().unwrap() + "test~";
             invoke("rustc", &[~"--test", filename.to_owned(),
                               ~"-o", test_exec.to_owned()], rustc::main);
-            run::run_program(~"./" + test_exec, []);
-            Valid
+            let exit_code = run::run_program(~"./" + test_exec, []);
+            Valid(exit_code)
         }
         _ => Invalid
     }
@@ -175,8 +176,8 @@ fn cmd_run(args: &[~str]) -> ValidUsage {
             let exec = Path(filename).filestem().unwrap() + "~";
             invoke("rustc", &[filename.to_owned(), ~"-o", exec.to_owned()],
                    rustc::main);
-            run::run_program(~"./"+exec, prog_args);
-            Valid
+            let exit_code = run::run_program(~"./"+exec, prog_args);
+            Valid(exit_code)
         }
         _ => Invalid
     }
@@ -194,7 +195,7 @@ fn do_command(command: &Command, args: &[~str]) -> ValidUsage {
         Call(f) => f(args),
         CallMain(prog, f) => {
             invoke(prog, args, f);
-            Valid
+            Valid(0)
         }
     }
 }
@@ -233,7 +234,10 @@ pub fn main() {
     if !args.is_empty() {
         for find_cmd(*args.head()).each |command| {
             let result = do_command(command, args.tail());
-            if result.is_valid() { return; }
+            match result {
+                Valid(exit_code) => unsafe { exit(exit_code.to_i32()) },
+                _                => loop
+            }
         }
     }
 

branches/snap-stage3/src/librustc/front/config.rs

@@ -136,8 +136,10 @@ fn fold_block(
 ) -> ast::blk_ {
     let filtered_stmts =
         b.stmts.filter_mapped(|a| filter_stmt(cx, *a));
+    let filtered_view_items =
+        b.view_items.filter_mapped(|a| filter_view_item(cx, *a));
     ast::blk_ {
-        view_items: /*bad*/copy b.view_items,
+        view_items: vec::map(filtered_view_items, |x| fld.fold_view_item(*x)),
         stmts: vec::map(filtered_stmts, |x| fld.fold_stmt(*x)),
         expr: b.expr.map(|x| fld.fold_expr(*x)),
         id: b.id,