---

yaml
---
r: 16298
b: refs/heads/try
c: a760958
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: ee8c762bdebb9800e768762e8f7d36a44b65f167
+refs/heads/try: a760958b52d3580ffba4d93f7c4732876893fc2a
 refs/tags/release-0.1: 1f5c5126e96c79d22cb7862f75304136e204f105

branches/try/Makefile.in

@@ -421,9 +421,9 @@ else
 TSREQS :=											\
 	$(foreach target,$(CFG_TARGET_TRIPLES),			\
 		$(SREQ3_T_$(target)_H_$(CFG_HOST_TRIPLE)))
-FUZZ := $(HBIN3_H_$(CFG_HOST_TRIPLE))/fuzzer$(X)
-CARGO := $(HBIN3_H_$(CFG_HOST_TRIPLE))/cargo$(X)
-RUSTDOC := $(HBIN3_H_$(CFG_HOST_TRIPLE))/rustdoc$(X)
+FUZZ := $(HBIN2_H_$(CFG_HOST_TRIPLE))/fuzzer$(X)
+CARGO := $(HBIN2_H_$(CFG_HOST_TRIPLE))/cargo$(X)
+RUSTDOC := $(HBIN2_H_$(CFG_HOST_TRIPLE))/rustdoc$(X)
 
 all: rustc $(GENERATED) docs $(FUZZ) $(CARGO) $(RUSTDOC)
 

branches/try/src/libcore/cmp.rs

@@ -0,0 +1,10 @@
+#[doc="Interfaces used for comparison."]
+
+iface ord {
+    fn lt(&&other: self) -> bool;
+}
+
+iface eq {
+    fn eq(&&other: self) -> bool;
+}
+

branches/try/src/libcore/core.rc

@@ -43,7 +43,9 @@ export comm, task, future;
 export extfmt;
 export tuple;
 export to_str;
+export swappable;
 export dvec, dvec_iter;
+export cmp;
 
 // NDM seems to be necessary for resolve to work
 export option_iter;
@@ -152,6 +154,7 @@ mod tuple;
 
 // Ubiquitous-utility-type modules
 
+mod cmp;
 mod either;
 mod iter;
 mod logging;
@@ -163,6 +166,7 @@ mod option_iter {
 }
 mod result;
 mod to_str;
+mod swappable;
 mod dvec;
 #[path="iter-trait"]
 mod dvec_iter {

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

@@ -1,4 +1,5 @@
 import T = inst::T;
+import cmp::{eq, ord};
 
 export min_value, max_value;
 export min, max;
@@ -10,6 +11,7 @@ export range;
 export compl;
 export abs;
 export parse_buf, from_str, to_str, to_str_bytes, str;
+export ord, eq;
 
 const min_value: T = -1 as T << (inst::bits - 1 as T);
 const max_value: T = min_value - 1 as T;
@@ -108,6 +110,18 @@ fn to_str_bytes<U>(n: T, radix: uint, f: fn([u8]/&) -> U) -> U {
 #[doc = "Convert to a string"]
 fn str(i: T) -> str { ret to_str(i, 10u); }
 
+impl ord of ord for T {
+    fn lt(&&other: T) -> bool {
+        ret self < other;
+    }
+}
+
+impl eq of eq for T {
+    fn eq(&&other: T) -> bool {
+        ret self == other;
+    }
+}
+
 
 // FIXME: Has alignment issues on windows and 32-bit linux
 #[test]

branches/try/src/libcore/swappable.rs

@@ -0,0 +1,98 @@
+export swappable;
+export unwrap;
+export methods;
+
+#[doc = "
+A value that may be swapped out temporarily while it is being processed
+and then replaced.  Swappables are most useful when working with unique
+values, which often cannot be mutated unless they are stored in the local
+stack frame to ensure memory safety.
+
+The type guarantees the invariant that the value is always \"swapped in\"
+except during the execution of the `swap()` and `with()` methods.
+"]
+type swappable<A> = {
+    mut o_t: option<A>
+};
+
+#[doc = "Create a swappable swapped in with a given initial value"]
+fn swappable<A>(+t: A) -> swappable<A> {
+    {mut o_t: some(t)}
+}
+
+#[doc = "Consumes a swappable and returns its contents without copying"]
+fn unwrap<A>(-s: swappable<A>) -> A {
+    let {o_t: o_t} <- s;
+    option::unwrap(o_t)
+}
+
+impl methods<A> for swappable<A> {
+    #[doc = "
+         Overwrites the contents of the swappable
+    "]
+    fn set(+a: A) {
+        self.o_t <- some(a);
+    }
+
+    #[doc = "
+         Invokes `f()` with the current value but replaces the
+         current value when complete.  Returns the result of `f()`.
+
+         Attempts to read or access the receiver while `f()` is executing
+         will fail dynamically.
+    "]
+    fn with<B>(f: fn(A) -> B) -> B {
+        let mut o_u = none;
+        self.swap { |t| o_u <- some(f(t)); t }
+        option::unwrap(o_u)
+    }
+
+    #[doc = "
+         Invokes `f()` with the current value and then replaces the
+         current value with the result of `f()`.
+
+         Attempts to read or access the receiver while `f()` is executing
+         will fail dynamically.
+    "]
+    fn swap(f: fn(-A) -> A) {
+        alt self.o_t {
+          none { fail "no value present---already swapped?"; }
+          some(_) {}
+        }
+
+        let mut o_t = none;
+        o_t <-> self.o_t;
+        self.o_t <- some(f(option::unwrap(o_t)));
+    }
+
+    #[doc = "True if there is a value present in this swappable"]
+    fn is_present() -> bool {
+        alt self.o_t {
+          none {false}
+          some(_) {true}
+        }
+    }
+
+    #[doc = "
+        Removes the value from the swappable.  Any further attempts
+        to use the swapabble without first invoking `set()` will fail.
+    "]
+    fn take() -> A {
+        alt self.o_t {
+          none { fail "swapped out"; }
+          some(_) {}
+        }
+
+        let mut o_t = none;
+        option::unwrap(o_t)
+    }
+}
+
+impl methods<A:copy> for swappable<A> {
+    #[doc = "
+        Copies out the contents of the swappable
+    "]
+    fn get() -> A {
+        self.o_t.get()
+    }
+}

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

@@ -1,4 +1,5 @@
 import T = inst::T;
+import cmp::{eq, ord};
 
 export min_value, max_value;
 export min, max;
@@ -10,6 +11,7 @@ export range;
 export compl;
 export to_str, to_str_bytes;
 export from_str, from_str_radix, str, parse_buf;
+export ord, eq;
 
 const min_value: T = 0 as T;
 const max_value: T = 0 as T - 1 as T;
@@ -49,6 +51,18 @@ pure fn compl(i: T) -> T {
     max_value ^ i
 }
 
+impl ord of ord for T {
+    fn lt(&&other: T) -> bool {
+        ret self < other;
+    }
+}
+
+impl eq of eq for T {
+    fn eq(&&other: T) -> bool {
+        ret self == other;
+    }
+}
+
 #[doc = "
 Parse a buffer of bytes
 

branches/try/src/libstd/sort.rs

@@ -1,5 +1,6 @@
 #[doc = "Sorting methods"];
 import vec::len;
+import int::{eq, ord};
 
 export le;
 export merge_sort;
@@ -141,7 +142,6 @@ fn qsort3<T: copy>(compare_func_lt: le<T>, compare_func_eq: le<T>,
     qsort3::<T>(compare_func_lt, compare_func_eq, arr, i, right);
 }
 
-// FIXME: This should take lt and eq types (#2348)
 #[doc = "
 Fancy quicksort. Sorts a mut vector in place.
 
@@ -152,22 +152,17 @@ According to these slides this is the algorithm of choice for
 
 This is an unstable sort.
 "]
-fn quick_sort3<T: copy>(compare_func_lt: le<T>, compare_func_eq: le<T>,
-                       arr: [mut T]) {
+fn quick_sort3<T: copy ord eq>(arr: [mut T]) {
     if len::<T>(arr) == 0u { ret; }
-    qsort3::<T>(compare_func_lt, compare_func_eq, arr, 0,
+    qsort3::<T>({ |x, y| x.lt(y) }, { |x, y| x.eq(y) }, arr, 0,
                 (len::<T>(arr) as int) - 1);
 }
 
 #[cfg(test)]
 mod test_qsort3 {
     fn check_sort(v1: [mut int], v2: [mut int]) {
         let len = vec::len::<int>(v1);
-        fn lt(&&a: int, &&b: int) -> bool { ret a < b; }
-        fn equal(&&a: int, &&b: int) -> bool { ret a == b; }
-        let f1 = lt;
-        let f2 = equal;
-        quick_sort3::<int>(f1, f2, v1);
+        quick_sort3::<int>(v1);
         let mut i = 0u;
         while i < len {
             log(debug, v2[i]);

branches/try/src/libsyntax/diagnostic.rs

@@ -86,11 +86,14 @@ impl codemap_handler of handler for handler_t {
     }
     fn has_errors() -> bool { self.err_count > 0u }
     fn abort_if_errors() {
-        if self.err_count > 0u {
-            let s = #fmt["aborting due to %u previous errors",
-                         self.err_count];
-            self.fatal(s);
+        let s;
+        alt self.err_count {
+          0u { ret; }
+          1u { s = "aborting due to previous error"; }
+          _  { s = #fmt["aborting due to %u previous errors",
+                        self.err_count]; }
         }
+        self.fatal(s);
     }
     fn warn(msg: str) {
         self.emit(none, msg, warning);

branches/try/src/rustc/back/link.rs

@@ -637,6 +637,11 @@ fn link_binary(sess: session,
     // and binutils 2.22+ won't add them automatically
     if sess.targ_cfg.os == session::os_linux {
         cc_args += ["-lrt", "-ldl"];
+
+        // LLVM implements the `frem` instruction as a call to `fmod`,
+        // which lives in libm. Similar to above, on some linuxes we
+        // have to be explicit about linking to it. See #2510
+        cc_args += ["-lm"];
     }
 
     if sess.targ_cfg.os == session::os_freebsd {

branches/try/src/rustc/driver/driver.rs

@@ -194,7 +194,7 @@ fn compile_upto(sess: session, cfg: ast::crate_cfg,
          bind middle::check_loop::check_crate(ty_cx, crate));
     time(time_passes, "alt checking",
          bind middle::check_alt::check_crate(ty_cx, crate));
-    let (last_use_map, spill_map) =
+    let last_use_map =
         time(time_passes, "liveness checking",
              bind middle::liveness::check_crate(ty_cx, method_map, crate));
     time(time_passes, "typestate checking",
@@ -216,7 +216,7 @@ fn compile_upto(sess: session, cfg: ast::crate_cfg,
     let maps = {mutbl_map: mutbl_map, root_map: root_map,
                 copy_map: copy_map, last_use_map: last_use_map,
                 impl_map: impl_map, method_map: method_map,
-                vtable_map: vtable_map, spill_map: spill_map};
+                vtable_map: vtable_map};
 
     let (llmod, link_meta) =
         time(time_passes, "translation",

branches/try/src/rustc/driver/rustc.rs

@@ -15,7 +15,8 @@ import std::map::hashmap;
 import getopts::{opt_present};
 import rustc::driver::driver::*;
 import syntax::codemap;
-import rustc::driver::{diagnostic, session};
+import syntax::diagnostic;
+import rustc::driver::session;
 import rustc::middle::lint;
 import io::reader_util;
 

branches/try/src/rustc/metadata/decoder.rs

@@ -7,14 +7,14 @@ import syntax::{ast, ast_util};
 import syntax::attr;
 import middle::ty;
 import syntax::ast_map;
-import common::*;
 import tydecode::{parse_ty_data, parse_def_id, parse_bounds_data,
         parse_ident};
 import syntax::print::pprust;
 import cmd=cstore::crate_metadata;
 import util::ppaux::ty_to_str;
 import ebml::deserializer;
 import syntax::diagnostic::span_handler;
+import common::*;
 
 export class_dtor;
 export get_class_fields;

branches/try/src/rustc/middle/astencode.rs

@@ -57,7 +57,6 @@ type maps = {
     impl_map: middle::resolve::impl_map,
     method_map: middle::typeck::method_map,
     vtable_map: middle::typeck::vtable_map,
-    spill_map: middle::liveness::spill_map
 };
 
 type decode_ctxt = @{
@@ -839,12 +838,6 @@ fn encode_side_tables_for_id(ecx: @e::encode_ctxt,
         }
     }
 
-    option::iter(maps.spill_map.find(id)) {|_m|
-        ebml_w.tag(c::tag_table_spill) {||
-            ebml_w.id(id);
-        }
-    }
-
     option::iter(maps.last_use_map.find(id)) {|m|
         ebml_w.tag(c::tag_table_last_use) {||
             ebml_w.id(id);
@@ -953,8 +946,6 @@ fn decode_side_tables(xcx: extended_decode_ctxt,
             dcx.maps.mutbl_map.insert(id, ());
         } else if tag == (c::tag_table_copy as uint) {
             dcx.maps.copy_map.insert(id, ());
-        } else if tag == (c::tag_table_spill as uint) {
-            dcx.maps.spill_map.insert(id, ());
         } else {
             let val_doc = entry_doc[c::tag_table_val];
             let val_dsr = ebml::ebml_deserializer(val_doc);