---

yaml
---
r: 49819
b: refs/heads/auto
c: d18f785
h: refs/heads/master
i:
  49817: e3d81ab
  49815: b786f0a
v: v3

Author: pcwalton

[refs]

@@ -14,5 +14,5 @@ refs/heads/try3: 9387340aab40a73e8424c48fd42f0c521a4875c0
 refs/tags/release-0.3.1: 495bae036dfe5ec6ceafd3312b4dca48741e845b
 refs/tags/release-0.4: e828ea2080499553b97dfe33b3f4d472b4562ad7
 refs/tags/release-0.5: 7e3bcfbf21278251ee936ad53e92e9b719702d73
-refs/heads/auto: 51cdca0bf0d3efc554c1815df9306ea10e881a14
+refs/heads/auto: d18f7854578e8c2e1d7dce90db6e3b5cf9befba9
 refs/heads/servo: af82457af293e2a842ba6b7759b70288da276167

branches/auto/src/compiletest/header.rs

@@ -103,7 +103,7 @@ pub fn is_test_ignored(config: config, testfile: &Path) -> bool {
     }
 }
 
-fn iter_header(testfile: &Path, it: fn(~str) -> bool) -> bool {
+fn iter_header(testfile: &Path, it: &fn(~str) -> bool) -> bool {
     let rdr = io::file_reader(testfile).get();
     while !rdr.eof() {
         let ln = rdr.read_line();

branches/auto/src/compiletest/runtest.rs

@@ -530,7 +530,7 @@ fn compose_and_run(config: config, testfile: &Path,
 }
 
 fn make_compile_args(config: config, props: TestProps, extras: ~[~str],
-                     xform: fn(config, (&Path)) -> Path,
+                     xform: &fn(config, (&Path)) -> Path,
                      testfile: &Path) -> ProcArgs {
     let prog = config.rustc_path;
     let mut args = ~[testfile.to_str(),

branches/auto/src/libcore/at_vec.rs

@@ -61,7 +61,7 @@ pub pure fn capacity<T>(v: @[const T]) -> uint {
  */
 #[inline(always)]
 pub pure fn build_sized<A>(size: uint,
-                           builder: &fn(push: pure fn(v: A))) -> @[A] {
+                           builder: &fn(push: &pure fn(v: A))) -> @[A] {
     let mut vec: @[const A] = @[];
     unsafe { raw::reserve(&mut vec, size); }
     builder(|+x| unsafe { raw::push(&mut vec, x) });
@@ -79,7 +79,7 @@ pub pure fn build_sized<A>(size: uint,
  *             onto the vector being constructed.
  */
 #[inline(always)]
-pub pure fn build<A>(builder: &fn(push: pure fn(v: A))) -> @[A] {
+pub pure fn build<A>(builder: &fn(push: &pure fn(v: A))) -> @[A] {
     build_sized(4, builder)
 }
 
@@ -97,7 +97,7 @@ pub pure fn build<A>(builder: &fn(push: pure fn(v: A))) -> @[A] {
  */
 #[inline(always)]
 pub pure fn build_sized_opt<A>(size: Option<uint>,
-                               builder: &fn(push: pure fn(v: A))) -> @[A] {
+                               builder: &fn(push: &pure fn(v: A))) -> @[A] {
     build_sized(size.get_or_default(4), builder)
 }
 

branches/auto/src/libcore/bool.rs

@@ -67,7 +67,7 @@ pub pure fn to_str(v: bool) -> ~str { if v { ~"true" } else { ~"false" } }
  * Iterates over all truth values by passing them to `blk` in an unspecified
  * order
  */
-pub fn all_values(blk: fn(v: bool)) {
+pub fn all_values(blk: &fn(v: bool)) {
     blk(true);
     blk(false);
 }

branches/auto/src/libcore/cell.rs

@@ -54,7 +54,7 @@ pub impl<T> Cell<T> {
     }
 
     // Calls a closure with a reference to the value.
-    fn with_ref<R>(&self, op: fn(v: &T) -> R) -> R {
+    fn with_ref<R>(&self, op: &fn(v: &T) -> R) -> R {
         let v = self.take();
         let r = op(&v);
         self.put_back(v);

branches/auto/src/libcore/cleanup.rs

@@ -124,7 +124,7 @@ struct AnnihilateStats {
     n_bytes_freed: uint
 }
 
-unsafe fn each_live_alloc(f: fn(box: *mut BoxRepr, uniq: bool) -> bool) {
+unsafe fn each_live_alloc(f: &fn(box: *mut BoxRepr, uniq: bool) -> bool) {
     use managed;
 
     let task: *Task = transmute(rustrt::rust_get_task());

branches/auto/src/libcore/container.rs

@@ -30,10 +30,10 @@ pub trait Map<K, V>: Mutable {
     pure fn contains_key(&self, key: &K) -> bool;
 
     /// Visit all keys
-    pure fn each_key(&self, f: fn(&K) -> bool);
+    pure fn each_key(&self, f: &fn(&K) -> bool);
 
     /// Visit all values
-    pure fn each_value(&self, f: fn(&V) -> bool);
+    pure fn each_value(&self, f: &fn(&V) -> bool);
 
     /// Return the value corresponding to the key in the map
     pure fn find(&self, key: &K) -> Option<&self/V>;
@@ -71,14 +71,14 @@ pub trait Set<T>: Mutable {
     pure fn is_superset(&self, other: &Self) -> bool;
 
     /// Visit the values representing the difference
-    pure fn difference(&self, other: &Self, f: fn(&T) -> bool);
+    pure fn difference(&self, other: &Self, f: &fn(&T) -> bool);
 
     /// Visit the values representing the symmetric difference
-    pure fn symmetric_difference(&self, other: &Self, f: fn(&T) -> bool);
+    pure fn symmetric_difference(&self, other: &Self, f: &fn(&T) -> bool);
 
     /// Visit the values representing the intersection
-    pure fn intersection(&self, other: &Self, f: fn(&T) -> bool);
+    pure fn intersection(&self, other: &Self, f: &fn(&T) -> bool);
 
     /// Visit the values representing the union
-    pure fn union(&self, other: &Self, f: fn(&T) -> bool);
+    pure fn union(&self, other: &Self, f: &fn(&T) -> bool);
 }

branches/auto/src/libcore/dlist.rs

@@ -399,7 +399,7 @@ pub impl<T> DList<T> {
     }
 
     /// Iterate over nodes.
-    pure fn each_node(@mut self, f: fn(@mut DListNode<T>) -> bool) {
+    pure fn each_node(@mut self, f: &fn(@mut DListNode<T>) -> bool) {
         let mut link = self.peek_n();
         while link.is_some() {
             let nobe = link.get();

branches/auto/src/libcore/either.rs

@@ -24,8 +24,8 @@ pub enum Either<T, U> {
 }
 
 #[inline(always)]
-pub fn either<T, U, V>(f_left: fn(&T) -> V,
-                       f_right: fn(&U) -> V, value: &Either<T, U>) -> V {
+pub fn either<T, U, V>(f_left: &fn(&T) -> V,
+                       f_right: &fn(&U) -> V, value: &Either<T, U>) -> V {
     /*!
      * Applies a function based on the given either value
      *
@@ -148,7 +148,7 @@ pub pure fn unwrap_right<T,U>(eith: Either<T,U>) -> U {
 
 pub impl<T, U> Either<T, U> {
     #[inline(always)]
-    fn either<V>(&self, f_left: fn(&T) -> V, f_right: fn(&U) -> V) -> V {
+    fn either<V>(&self, f_left: &fn(&T) -> V, f_right: &fn(&U) -> V) -> V {
         either(f_left, f_right, self)
     }
 

branches/auto/src/libcore/hashmap.rs

@@ -86,7 +86,7 @@ pub mod linear {
 
         #[inline(always)]
         pure fn bucket_sequence(&self, hash: uint,
-                                op: fn(uint) -> bool) -> uint {
+                                op: &fn(uint) -> bool) -> uint {
             let start_idx = self.to_bucket(hash);
             let len_buckets = self.buckets.len();
             let mut idx = start_idx;
@@ -263,7 +263,7 @@ pub mod linear {
         }
 
         fn search(&self, hash: uint,
-                  op: fn(x: &Option<Bucket<K, V>>) -> bool) {
+                  op: &fn(x: &Option<Bucket<K, V>>) -> bool) {
             let _ = self.bucket_sequence(hash, |i| op(&self.buckets[i]));
         }
     }
@@ -272,7 +272,7 @@ pub mod linear {
         BaseIter<(&self/K, &self/V)> for LinearMap<K, V>
     {
         /// Visit all key-value pairs
-        pure fn each(&self, blk: fn(&(&self/K, &self/V)) -> bool) {
+        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| {
@@ -315,12 +315,12 @@ pub mod linear {
         }
 
         /// Visit all keys
-        pure fn each_key(&self, blk: fn(k: &K) -> bool) {
+        pure fn each_key(&self, blk: &fn(k: &K) -> bool) {
             self.each(|&(k, _)| blk(k))
         }
 
         /// Visit all values
-        pure fn each_value(&self, blk: fn(v: &V) -> bool) {
+        pure fn each_value(&self, blk: &fn(v: &V) -> bool) {
             self.each(|&(_, v)| blk(v))
         }
 
@@ -428,7 +428,7 @@ pub mod linear {
 
         /// Return the value corresponding to the key in the map, or create,
         /// insert, and return a new value if it doesn't exist.
-        fn find_or_insert_with(&mut self, k: K, f: fn(&K) -> V) -> &self/V {
+        fn find_or_insert_with(&mut self, k: K, f: &fn(&K) -> V) -> &self/V {
             if self.size >= self.resize_at {
                 // n.b.: We could also do this after searching, so
                 // that we do not resize if this call to insert is
@@ -457,7 +457,7 @@ pub mod linear {
             }
         }
 
-        fn consume(&mut self, f: fn(K, V)) {
+        fn consume(&mut self, f: &fn(K, V)) {
             let mut buckets = ~[];
             self.buckets <-> buckets;
             self.size = 0;
@@ -526,7 +526,7 @@ pub mod linear {
 
     impl<T:Hash + IterBytes + Eq> BaseIter<T> for LinearSet<T> {
         /// Visit all values in order
-        pure fn each(&self, f: fn(&T) -> bool) { self.map.each_key(f) }
+        pure fn each(&self, f: &fn(&T) -> bool) { self.map.each_key(f) }
         pure fn size_hint(&self) -> Option<uint> { Some(self.len()) }
     }
 
@@ -583,7 +583,7 @@ pub mod linear {
         }
 
         /// Visit the values representing the difference
-        pure fn difference(&self, other: &LinearSet<T>, f: fn(&T) -> bool) {
+        pure fn difference(&self, other: &LinearSet<T>, f: &fn(&T) -> bool) {
             for self.each |v| {
                 if !other.contains(v) {
                     if !f(v) { return }
@@ -593,13 +593,13 @@ pub mod linear {
 
         /// Visit the values representing the symmetric difference
         pure fn symmetric_difference(&self, other: &LinearSet<T>,
-                                     f: fn(&T) -> bool) {
+                                     f: &fn(&T) -> bool) {
             self.difference(other, f);
             other.difference(self, f);
         }
 
         /// Visit the values representing the intersection
-        pure fn intersection(&self, other: &LinearSet<T>, f: fn(&T) -> bool) {
+        pure fn intersection(&self, other: &LinearSet<T>, f: &fn(&T) -> bool) {
             for self.each |v| {
                 if other.contains(v) {
                     if !f(v) { return }
@@ -608,7 +608,7 @@ pub mod linear {
         }
 
         /// Visit the values representing the union
-        pure fn union(&self, other: &LinearSet<T>, f: fn(&T) -> bool) {
+        pure fn union(&self, other: &LinearSet<T>, f: &fn(&T) -> bool) {
             for self.each |v| {
                 if !f(v) { return }
             }

branches/auto/src/libcore/io.rs

@@ -118,13 +118,13 @@ pub trait ReaderUtil {
     fn read_whole_stream(&self) -> ~[u8];
 
     /// Iterate over every byte until the iterator breaks or EOF.
-    fn each_byte(&self, it: fn(int) -> bool);
+    fn each_byte(&self, it: &fn(int) -> bool);
 
     /// Iterate over every char until the iterator breaks or EOF.
-    fn each_char(&self, it: fn(char) -> bool);
+    fn each_char(&self, it: &fn(char) -> bool);
 
     /// Iterate over every line until the iterator breaks or EOF.
-    fn each_line(&self, it: fn(&str) -> bool);
+    fn each_line(&self, it: &fn(&str) -> bool);
 
     /// Read n (between 1 and 8) little-endian unsigned integer bytes.
     fn read_le_uint_n(&self, nbytes: uint) -> u64;
@@ -315,19 +315,19 @@ impl<T:Reader> ReaderUtil for T {
         bytes
     }
 
-    fn each_byte(&self, it: fn(int) -> bool) {
+    fn each_byte(&self, it: &fn(int) -> bool) {
         while !self.eof() {
             if !it(self.read_byte()) { break; }
         }
     }
 
-    fn each_char(&self, it: fn(char) -> bool) {
+    fn each_char(&self, it: &fn(char) -> bool) {
         while !self.eof() {
             if !it(self.read_char()) { break; }
         }
     }
 
-    fn each_line(&self, it: fn(s: &str) -> bool) {
+    fn each_line(&self, it: &fn(s: &str) -> bool) {
         while !self.eof() {
             if !it(self.read_line()) { break; }
         }
@@ -618,11 +618,11 @@ impl Reader for BytesReader/&self {
     fn tell(&self) -> uint { self.pos }
 }
 
-pub pure fn with_bytes_reader<t>(bytes: &[u8], f: fn(@Reader) -> t) -> t {
+pub pure fn with_bytes_reader<t>(bytes: &[u8], f: &fn(@Reader) -> t) -> t {
     f(@BytesReader { bytes: bytes, pos: 0u } as @Reader)
 }
 
-pub pure fn with_str_reader<T>(s: &str, f: fn(@Reader) -> T) -> T {
+pub pure fn with_str_reader<T>(s: &str, f: &fn(@Reader) -> T) -> T {
     str::byte_slice(s, |bytes| with_bytes_reader(bytes, f))
 }
 
@@ -819,7 +819,7 @@ pub fn mk_file_writer(path: &Path, flags: &[FileFlag])
 }
 
 pub fn u64_to_le_bytes<T>(n: u64, size: uint,
-                          f: fn(v: &[u8]) -> T) -> T {
+                          f: &fn(v: &[u8]) -> T) -> T {
     fail_unless!(size <= 8u);
     match size {
       1u => f(&[n as u8]),
@@ -851,7 +851,7 @@ pub fn u64_to_le_bytes<T>(n: u64, size: uint,
 }
 
 pub fn u64_to_be_bytes<T>(n: u64, size: uint,
-                           f: fn(v: &[u8]) -> T) -> T {
+                           f: &fn(v: &[u8]) -> T) -> T {
     fail_unless!(size <= 8u);
     match size {
       1u => f(&[n as u8]),
@@ -1142,14 +1142,14 @@ pub pure fn BytesWriter() -> BytesWriter {
     BytesWriter { bytes: ~[], mut pos: 0u }
 }
 
-pub pure fn with_bytes_writer(f: fn(Writer)) -> ~[u8] {
+pub pure fn with_bytes_writer(f: &fn(Writer)) -> ~[u8] {
     let wr = @BytesWriter();
     f(wr as Writer);
     let @BytesWriter{bytes, _} = wr;
     return bytes;
 }
 
-pub pure fn with_str_writer(f: fn(Writer)) -> ~str {
+pub pure fn with_str_writer(f: &fn(Writer)) -> ~str {
     let mut v = with_bytes_writer(f);
 
     // FIXME (#3758): This should not be needed.
@@ -1251,7 +1251,7 @@ pub mod fsync {
     // FIXME (#2004) find better way to create resources within lifetime of
     // outer res
     pub fn FILE_res_sync(file: &FILERes, opt_level: Option<Level>,
-                         blk: fn(v: Res<*libc::FILE>)) {
+                         blk: &fn(v: Res<*libc::FILE>)) {
         unsafe {
             blk(Res(Arg {
                 val: file.f, opt_level: opt_level,
@@ -1266,7 +1266,7 @@ pub mod fsync {
 
     // fsync fd after executing blk
     pub fn fd_res_sync(fd: &FdRes, opt_level: Option<Level>,
-                       blk: fn(v: Res<fd_t>)) {
+                       blk: &fn(v: Res<fd_t>)) {
         blk(Res(Arg {
             val: fd.fd, opt_level: opt_level,
             fsync_fn: |fd, l| os::fsync_fd(fd, l) as int
@@ -1278,7 +1278,7 @@ pub mod fsync {
 
     // Call o.fsync after executing blk
     pub fn obj_sync(o: FSyncable, opt_level: Option<Level>,
-                    blk: fn(v: Res<FSyncable>)) {
+                    blk: &fn(v: Res<FSyncable>)) {
         blk(Res(Arg {
             val: o, opt_level: opt_level,
             fsync_fn: |o, l| o.fsync(l)