---

yaml
---
r: 40556
b: refs/heads/dist-snap
c: fc06114
h: refs/heads/master
v: v3

Author: brson

[refs]

@@ -7,7 +7,7 @@ refs/tags/release-0.1: 1f5c5126e96c79d22cb7862f75304136e204f105
 refs/heads/ndm: f3868061cd7988080c30d6d5bf352a5a5fe2460b
 refs/heads/try2: a810c03263670238bccd64cabb12a23a46e3a278
 refs/heads/incoming: e90142e536c150df0d9b4b2f11352152177509b5
-refs/heads/dist-snap: 8179e268efd86ae5c1bcf21b4f8d4e01eea7c193
+refs/heads/dist-snap: fc06114ddfd2bcdbc4f29076c226a7a1d66ea8d6
 refs/tags/release-0.2: c870d2dffb391e14efb05aa27898f1f6333a9596
 refs/tags/release-0.3: b5f0d0f648d9a6153664837026ba1be43d3e2503
 refs/heads/try3: 9387340aab40a73e8424c48fd42f0c521a4875c0

branches/dist-snap/src/compiletest/compiletest.rc

@@ -63,12 +63,12 @@ fn parse_config(args: ~[~str]) -> config {
     assert (vec::is_not_empty(args));
     let args_ = vec::tail(args);
     let matches =
-        match getopts::getopts(args_, opts) {
+        &match getopts::getopts(args_, opts) {
           Ok(m) => m,
           Err(f) => fail getopts::fail_str(f)
         };
 
-    fn opt_path(m: getopts::Matches, nm: ~str) -> Path {
+    fn opt_path(m: &getopts::Matches, nm: ~str) -> Path {
         Path(getopts::opt_str(m, nm))
     }
 

branches/dist-snap/src/libcargo/cargo.rc

@@ -655,7 +655,7 @@ fn load_source_packages(c: &Cargo, src: @Source) {
 }
 
 fn build_cargo_options(argv: ~[~str]) -> Options {
-    let matches = match getopts::getopts(argv, opts()) {
+    let matches = &match getopts::getopts(argv, opts()) {
         result::Ok(m) => m,
         result::Err(f) => {
             fail fmt!("%s", getopts::fail_str(f));

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

@@ -0,0 +1,10 @@
+/**
+Clonable types are copied with the clone method
+*/
+pub trait Clone {
+    fn clone(&self) -> self;
+}
+
+impl (): Clone {
+    fn clone(&self) -> () { () }
+}

branches/dist-snap/src/libcore/core.rc

@@ -128,6 +128,7 @@ pub mod to_str;
 pub mod to_bytes;
 pub mod from_str;
 pub mod util;
+pub mod clone;
 
 // Data structure modules
 
@@ -232,6 +233,10 @@ pub use coreops::ops::{BitXor};
 #[cfg(test)]
 pub use coreops::ops::{Shl, Shr, Index};
 
+#[cfg(notest)]
+pub use clone::Clone;
+#[cfg(test)]
+pub use coreops::clone::Clone;
 
 // Export the log levels as global constants. Higher levels mean
 // more-verbosity. Error is the bottom level, default logging level is

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

@@ -35,52 +35,52 @@ pub trait Add<RHS,Result> {
 
 #[lang="sub"]
 pub trait Sub<RHS,Result> {
-    pure fn sub(rhs: &RHS) -> Result;
+    pure fn sub(&self, rhs: &RHS) -> Result;
 }
 
 #[lang="mul"]
 pub trait Mul<RHS,Result> {
-    pure fn mul(rhs: &RHS) -> Result;
+    pure fn mul(&self, rhs: &RHS) -> Result;
 }
 
 #[lang="div"]
 pub trait Div<RHS,Result> {
-    pure fn div(rhs: &RHS) -> Result;
+    pure fn div(&self, rhs: &RHS) -> Result;
 }
 
 #[lang="modulo"]
 pub trait Modulo<RHS,Result> {
-    pure fn modulo(rhs: &RHS) -> Result;
+    pure fn modulo(&self, rhs: &RHS) -> Result;
 }
 
 #[lang="neg"]
 pub trait Neg<Result> {
-    pure fn neg() -> Result;
+    pure fn neg(&self) -> Result;
 }
 
 #[lang="bitand"]
 pub trait BitAnd<RHS,Result> {
-    pure fn bitand(rhs: &RHS) -> Result;
+    pure fn bitand(&self, rhs: &RHS) -> Result;
 }
 
 #[lang="bitor"]
 pub trait BitOr<RHS,Result> {
-    pure fn bitor(rhs: &RHS) -> Result;
+    pure fn bitor(&self, rhs: &RHS) -> Result;
 }
 
 #[lang="bitxor"]
 pub trait BitXor<RHS,Result> {
-    pure fn bitxor(rhs: &RHS) -> Result;
+    pure fn bitxor(&self, rhs: &RHS) -> Result;
 }
 
 #[lang="shl"]
 pub trait Shl<RHS,Result> {
-    pure fn shl(rhs: &RHS) -> Result;
+    pure fn shl(&self, rhs: &RHS) -> Result;
 }
 
 #[lang="shr"]
 pub trait Shr<RHS,Result> {
-    pure fn shr(rhs: &RHS) -> Result;
+    pure fn shr(&self, rhs: &RHS) -> Result;
 }
 
 #[lang="index"]

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

@@ -509,12 +509,14 @@ pub fn exclusive<T:Send >(user_data: T) -> Exclusive<T> {
     Exclusive { x: unsafe { shared_mutable_state(move data) } }
 }
 
-impl<T: Send> Exclusive<T> {
+impl<T: Send> Exclusive<T>: Clone {
     // Duplicate an exclusive ARC, as std::arc::clone.
-    fn clone() -> Exclusive<T> {
+    fn clone(&self) -> Exclusive<T> {
         Exclusive { x: unsafe { clone_shared_mutable_state(&self.x) } }
     }
+}
 
+impl<T: Send> Exclusive<T> {
     // Exactly like std::arc::mutex_arc,access(), but with the little_lock
     // instead of a proper mutex. Same reason for being unsafe.
     //

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

@@ -34,9 +34,12 @@ extern mod rustrt {
 // 'rt_', otherwise the compiler won't find it. To fix this, see
 // gather_rust_rtcalls.
 #[rt(fail_)]
-pub fn rt_fail_(expr: *c_char, file: *c_char, line: size_t) {
-    cleanup_stack_for_failure();
-    rustrt::rust_upcall_fail(expr, file, line);
+pub fn rt_fail_(expr: *c_char, file: *c_char, line: size_t) -> ! {
+    unsafe {
+        cleanup_stack_for_failure();
+        rustrt::rust_upcall_fail(expr, file, line);
+        cast::transmute(())
+    }
 }
 
 #[rt(fail_bounds_check)]