---

yaml
---
r: 42398
b: refs/heads/master
c: ee93fb2
h: refs/heads/master
v: v3

Author: bors

[refs]

@@ -1,5 +1,5 @@
 ---
-refs/heads/master: a380df809c8eb874540a123780612f14cfc7303e
+refs/heads/master: ee93fb2ad586a98ab1e5766cfd74b3bba6529b14
 refs/heads/snap-stage1: e33de59e47c5076a89eadeb38f4934f58a3618a6
 refs/heads/snap-stage3: 2f46b763da2c098913884f101b6d71d69af41b49
 refs/heads/try: 3d5418789064fdb463e872a4e651af1c628a3650

trunk/doc/tutorial-macros.md

@@ -281,7 +281,7 @@ pattern we want is clear:
 However, it's not possible to directly expand to nested match statements. But
 there is a solution.
 
-## The recusive approach to macro writing
+## The recursive approach to macro writing
 
 A macro may accept multiple different input grammars. The first one to
 successfully match the actual argument to a macro invocation is the one that

trunk/src/libcargo/cargo.rc

@@ -457,7 +457,7 @@ pub fn parse_source(name: ~str, j: &json::Json) -> @Source {
     }
 
     match *j {
-        json::Object(ref j) => {
+        json::Object(j) => {
             let mut url = match j.find(&~"url") {
                 Some(&json::String(u)) => copy u,
                 _ => die!(~"needed 'url' field in source")
@@ -495,7 +495,7 @@ pub fn try_parse_sources(filename: &Path,
     let c = io::read_whole_file_str(filename);
     match json::from_str(c.get()) {
         Ok(json::Object(j)) => {
-            for j.each |k, v| {
+            for j.each |&(k, v)| {
                 sources.insert(copy *k, parse_source(*k, v));
                 debug!("source: %s", *k);
             }
@@ -563,7 +563,7 @@ pub fn load_one_source_package(src: @Source, p: &json::Object) {
 
     let mut tags = ~[];
     match p.find(&~"tags") {
-        Some(&json::List(ref js)) => {
+        Some(&json::List(js)) => {
           for js.each |j| {
                 match *j {
                     json::String(ref j) => tags.grow(1u, j),
@@ -635,11 +635,11 @@ pub fn load_source_packages(c: &Cargo, src: @Source) {
     if !os::path_exists(&pkgfile) { return; }
     let pkgstr = io::read_whole_file_str(&pkgfile);
     match json::from_str(pkgstr.get()) {
-        Ok(json::List(ref js)) => {
+        Ok(json::List(js)) => {
           for js.each |j| {
                 match *j {
-                    json::Object(ref p) => {
-                        load_one_source_package(src, *p);
+                    json::Object(p) => {
+                        load_one_source_package(src, p);
                     }
                     _ => {
                         warn(~"malformed source json: " + src.name +

trunk/src/libcargo/pgp.rs

@@ -12,7 +12,7 @@ use core::os;
 use core::path::Path;
 use core::run;
 
-pub fn gpgv(args: ~[~str]) -> { status: int, out: ~str, err: ~str } {
+pub fn gpgv(args: ~[~str]) -> run::ProgramOutput {
     return run::program_output(~"gpgv", args);
 }
 

trunk/src/libcore/container.rs

@@ -29,9 +29,6 @@ pub trait Map<K, V>: Mutable {
     /// Return true if the map contains a value for the specified key
     pure fn contains_key(&self, key: &K) -> bool;
 
-    /// Visit all key-value pairs
-    pure fn each(&self, f: fn(&K, &V) -> bool);
-
     /// Visit all keys
     pure fn each_key(&self, f: fn(&K) -> bool);
 

trunk/src/libcore/extfmt.rs

@@ -51,9 +51,6 @@
 //! * s - str (any flavor)
 //! * ? - arbitrary type (does not use the to_str trait)
 
-// Transitional
-#[allow(structural_records)]; // Macros -- needs a snapshot
-
 /*
 Syntax Extension: fmt
 
@@ -619,11 +616,11 @@ pub mod rt {
             let padstr = str::from_chars(vec::from_elem(diff, padchar));
             return s + padstr;
         }
-        let {might_zero_pad, signed} = match mode {
-          PadNozero => {might_zero_pad:false, signed:false},
-          PadSigned => {might_zero_pad:true,  signed:true },
-          PadFloat => {might_zero_pad:true,  signed:true},
-          PadUnsigned => {might_zero_pad:true,  signed:false}
+        let (might_zero_pad, signed) = match mode {
+          PadNozero   => (false, true),
+          PadSigned   => (true, true),
+          PadFloat    => (true, true),
+          PadUnsigned => (true, false)
         };
         pure fn have_precision(cv: Conv) -> bool {
             return match cv.precision { CountImplied => false, _ => true };

trunk/src/libcore/gc.rs

@@ -35,9 +35,6 @@ with destructors.
 
 */
 
-// Transitional
-#[allow(structural_records)];
-
 use cast;
 use container::{Container, Mutable, Map, Set};
 use io;
@@ -172,12 +169,14 @@ unsafe fn is_frame_in_segment(fp: *Word, segment: *StackSegment) -> bool {
     return begin <= frame && frame <= end;
 }
 
+struct Segment { segment: *StackSegment, boundary: bool }
+
 // Find and return the segment containing the given frame pointer. At
 // stack segment boundaries, returns true for boundary, so that the
 // caller can do any special handling to identify where the correct
 // return address is in the stack frame.
 unsafe fn find_segment_for_frame(fp: *Word, segment: *StackSegment)
-    -> {segment: *StackSegment, boundary: bool} {
+    -> Segment {
     // Check if frame is in either current frame or previous frame.
     let in_segment = is_frame_in_segment(fp, segment);
     let in_prev_segment = ptr::is_not_null((*segment).prev) &&
@@ -191,16 +190,16 @@ unsafe fn find_segment_for_frame(fp: *Word, segment: *StackSegment)
             is_frame_in_segment(fp, (*segment).next) {
             segment = (*segment).next;
         }
-        return {segment: segment, boundary: false};
+        return Segment {segment: segment, boundary: false};
     }
 
     // If frame is in previous frame, then we're at a boundary.
     if !in_segment && in_prev_segment {
-        return {segment: (*segment).prev, boundary: true};
+        return Segment {segment: (*segment).prev, boundary: true};
     }
 
     // Otherwise, we're somewhere on the inside of the frame.
-    return {segment: segment, boundary: false};
+    return Segment {segment: segment, boundary: false};
 }
 
 type Memory = uint;
@@ -224,7 +223,7 @@ unsafe fn walk_gc_roots(mem: Memory, sentinel: **Word, visitor: Visitor) {
     for stackwalk::walk_stack |frame| {
         unsafe {
             let pc = last_ret;
-            let {segment: next_segment, boundary: boundary} =
+            let Segment {segment: next_segment, boundary: boundary} =
                 find_segment_for_frame(frame.fp, segment);
             segment = next_segment;
             // Each stack segment is bounded by a morestack frame. The

trunk/src/libcore/hashmap.rs

@@ -235,6 +235,23 @@ pub mod linear {
         }
     }
 
+    impl <K: Hash IterBytes Eq, V> LinearMap<K, V>: BaseIter<(&K, &V)> {
+        /// Visit all key-value pairs
+        pure fn each(&self, blk: fn(&(&self/K, &self/V)) -> bool) {
+            for uint::range(0, self.buckets.len()) |i| {
+                let mut broke = false;
+                do self.buckets[i].map |bucket| {
+                    if !blk(&(&bucket.key, &bucket.value)) {
+                        broke = true; // FIXME(#3064) just write "break;"
+                    }
+                };
+                if broke { break; }
+            }
+        }
+        pure fn size_hint(&self) -> Option<uint> { Some(self.len()) }
+    }
+
+
     impl <K: Hash IterBytes Eq, V> LinearMap<K, V>: Container {
         /// Return the number of elements in the map
         pure fn len(&self) -> uint { self.size }
@@ -262,27 +279,14 @@ pub mod linear {
             }
         }
 
-        /// Visit all key-value pairs
-        pure fn each(&self, blk: fn(k: &K, v: &V) -> bool) {
-            for self.buckets.each |slot| {
-                let mut broke = false;
-                do slot.iter |bucket| {
-                    if !blk(&bucket.key, &bucket.value) {
-                        broke = true; // FIXME(#3064) just write "break;"
-                    }
-                }
-                if broke { break; }
-            }
-        }
-
         /// Visit all keys
         pure fn each_key(&self, blk: fn(k: &K) -> bool) {
-            self.each(|k, _| blk(k))
+            self.each(|&(k, _)| blk(k))
         }
 
         /// Visit all values
         pure fn each_value(&self, blk: fn(v: &V) -> bool) {
-            self.each(|_, v| blk(v))
+            self.each(|&(_, v)| blk(v))
         }
 
         /// Return the value corresponding to the key in the map
@@ -388,7 +392,7 @@ pub mod linear {
         pure fn eq(&self, other: &LinearMap<K, V>) -> bool {
             if self.len() != other.len() { return false; }
 
-            for self.each |key, value| {
+            for self.each |&(key, value)| {
                 match other.find(key) {
                     None => return false,
                     Some(v) => if value != v { return false },
@@ -603,7 +607,7 @@ mod test_map {
             assert m.insert(i, i*2);
         }
         let mut observed = 0;
-        for m.each |k, v| {
+        for m.each |&(k, v)| {
             assert *v == *k * 2;
             observed |= (1 << *k);
         }

trunk/src/libcore/iter.rs

@@ -27,6 +27,10 @@ pub trait BaseIter<A> {
     pure fn size_hint(&self) -> Option<uint>;
 }
 
+pub trait ReverseIter<A>: BaseIter<A> {
+    pure fn each_reverse(&self, blk: fn(&A) -> bool);
+}
+
 pub trait ExtendedIter<A> {
     pure fn eachi(&self, blk: fn(uint, v: &A) -> bool);
     pure fn all(&self, blk: fn(&A) -> bool) -> bool;

trunk/src/libcore/option.rs

@@ -102,7 +102,7 @@ pub pure fn get_ref<T>(opt: &r/Option<T>) -> &r/T {
 }
 
 #[inline(always)]
-pub pure fn map<T, U>(opt: &Option<T>, f: fn(x: &T) -> U) -> Option<U> {
+pub pure fn map<T, U>(opt: &r/Option<T>, f: fn(x: &r/T) -> U) -> Option<U> {
     //! Maps a `some` value by reference from one type to another
 
     match *opt { Some(ref x) => Some(f(x)), None => None }
@@ -193,8 +193,8 @@ pub pure fn get_or_default<T: Copy>(opt: Option<T>, def: T) -> T {
 }
 
 #[inline(always)]
-pub pure fn map_default<T, U>(opt: &Option<T>, def: U,
-                              f: fn(x: &T) -> U) -> U {
+pub pure fn map_default<T, U>(opt: &r/Option<T>, def: U,
+                              f: fn(&r/T) -> U) -> U {
     //! Applies a function to the contained value or returns a default
 
     match *opt { None => move def, Some(ref t) => f(t) }
@@ -273,7 +273,7 @@ impl<T> Option<T> {
 
     /// Maps a `some` value from one type to another by reference
     #[inline(always)]
-    pure fn map<U>(&self, f: fn(x: &T) -> U) -> Option<U> { map(self, f) }
+    pure fn map<U>(&self, f: fn(&self/T) -> U) -> Option<U> { map(self, f) }
 
     /// As `map`, but consumes the option and gives `f` ownership to avoid
     /// copying.
@@ -284,7 +284,7 @@ impl<T> Option<T> {
 
     /// Applies a function to the contained value or returns a default
     #[inline(always)]
-    pure fn map_default<U>(&self, def: U, f: fn(x: &T) -> U) -> U {
+    pure fn map_default<U>(&self, def: U, f: fn(&self/T) -> U) -> U {
         map_default(self, move def, f)
     }
 

trunk/src/libcore/os.rs

@@ -8,8 +8,6 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-#[allow(structural_records)];
-
 /*!
  * Higher-level interfaces to libc::* functions and operating system services.
  *
@@ -318,33 +316,37 @@ pub fn waitpid(pid: pid_t) -> c_int {
 }
 
 
+pub struct Pipe { mut in: c_int, mut out: c_int }
+
 #[cfg(unix)]
-pub fn pipe() -> {in: c_int, out: c_int} {
+pub fn pipe() -> Pipe {
     unsafe {
-        let mut fds = {in: 0 as c_int, out: 0 as c_int};
+        let mut fds = Pipe {mut in: 0 as c_int,
+                        mut out: 0 as c_int };
         assert (libc::pipe(ptr::mut_addr_of(&(fds.in))) == (0 as c_int));
-        return {in: fds.in, out: fds.out};
+        return Pipe {in: fds.in, out: fds.out};
     }
 }
 
 
 
 #[cfg(windows)]
-pub fn pipe() -> {in: c_int, out: c_int} {
+pub fn pipe() -> Pipe {
     unsafe {
         // Windows pipes work subtly differently than unix pipes, and their
         // inheritance has to be handled in a different way that I do not
         // fully understand. Here we explicitly make the pipe non-inheritable,
         // which means to pass it to a subprocess they need to be duplicated
         // first, as in rust_run_program.
-        let mut fds = { in: 0 as c_int, out: 0 as c_int };
+        let mut fds = Pipe { mut in: 0 as c_int,
+                    mut out: 0 as c_int };
         let res = libc::pipe(ptr::mut_addr_of(&(fds.in)),
                              1024 as c_uint,
                              (libc::O_BINARY | libc::O_NOINHERIT) as c_int);
         assert (res == 0 as c_int);
         assert (fds.in != -1 as c_int && fds.in != 0 as c_int);
         assert (fds.out != -1 as c_int && fds.in != 0 as c_int);
-        return {in: fds.in, out: fds.out};
+        return Pipe {in: fds.in, out: fds.out};
     }
 }
 

trunk/src/libcore/pipes.rs

@@ -82,8 +82,7 @@ bounded and unbounded protocols allows for less code duplication.
 
 */
 
-// Transitional -- needs snapshot
-#[allow(structural_records)];
+#[allow(structural_records)]; // Macros -- needs another snapshot
 
 use cmp::Eq;
 use cast::{forget, reinterpret_cast, transmute};

trunk/src/libcore/ptr.rs

@@ -187,18 +187,7 @@ pub trait Ptr<T> {
     pure fn offset(count: uint) -> Self;
 }
 
-#[cfg(stage0)]
-unsafe fn memmove32(dst: *mut u8, src: *const u8, count: u32) {
-    libc::memmove(dst as *c_void, src as *c_void, count as size_t);
-}
-#[cfg(stage0)]
-unsafe fn memmove64(dst: *mut u8, src: *const u8, count: u64) {
-    libc::memmove(dst as *c_void, src as *c_void, count as size_t);
-}
-
 #[abi="rust-intrinsic"]
-#[cfg(stage1)]
-#[cfg(stage2)]
 pub extern {
     fn memmove32(dst: *mut u8, src: *u8, size: u32);
     fn memmove64(dst: *mut u8, src: *u8, size: u64);