---

yaml
---
r: 42093
b: refs/heads/master
c: d0391c5
h: refs/heads/master
i:
  42091: b2ce5b8
v: v3

Author: pcwalton

[refs]

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

trunk/src/libcore/at_vec.rs

@@ -29,16 +29,14 @@ use vec;
 
 #[abi = "cdecl"]
 pub extern mod rustrt {
-    #[legacy_exports];
-    unsafe fn vec_reserve_shared_actual(++t: *sys::TypeDesc,
-                                        ++v: **vec::raw::VecRepr,
-                                        ++n: libc::size_t);
+    pub unsafe fn vec_reserve_shared_actual(++t: *sys::TypeDesc,
+                                            ++v: **vec::raw::VecRepr,
+                                            ++n: libc::size_t);
 }
 
 #[abi = "rust-intrinsic"]
 pub extern mod rusti {
-    #[legacy_exports];
-    fn move_val_init<T>(dst: &mut T, -src: T);
+    pub fn move_val_init<T>(dst: &mut T, -src: T);
 }
 
 /// Returns the number of elements the vector can hold without reallocating

trunk/src/libcore/cleanup.rs

@@ -161,9 +161,8 @@ pub unsafe fn annihilate() {
 
 /// Bindings to the runtime
 extern mod rustrt {
-    #[legacy_exports];
     #[rust_stack]
     // FIXME (#4386): Unable to make following method private.
-    /* priv */ unsafe fn rust_get_task() -> *c_void;
+    pub unsafe fn rust_get_task() -> *c_void;
 }
 

trunk/src/libcore/dlist.rs

@@ -488,15 +488,13 @@ impl<T: Copy> DList<T> {
 
 #[cfg(test)]
 mod tests {
-    #[legacy_exports];
-
     use dlist::{DList, concat, from_vec, new_dlist_node};
     use iter;
     use option::{None, Some};
     use vec;
 
     #[test]
-    fn test_dlist_concat() {
+    pub fn test_dlist_concat() {
         let a = from_vec(~[1,2]);
         let b = from_vec(~[3,4]);
         let c = from_vec(~[5,6]);
@@ -516,7 +514,7 @@ mod tests {
         abcd.assert_consistent(); assert abcd.is_empty();
     }
     #[test]
-    fn test_dlist_append() {
+    pub fn test_dlist_append() {
         let a = from_vec(~[1,2,3]);
         let b = from_vec(~[4,5,6]);
         a.append(b);
@@ -532,7 +530,7 @@ mod tests {
         a.assert_consistent(); assert a.is_empty();
     }
     #[test]
-    fn test_dlist_append_empty() {
+    pub fn test_dlist_append_empty() {
         let a = from_vec(~[1,2,3]);
         let b = DList::<int>();
         a.append(b);
@@ -545,7 +543,7 @@ mod tests {
         a.assert_consistent(); assert a.is_empty();
     }
     #[test]
-    fn test_dlist_append_to_empty() {
+    pub fn test_dlist_append_to_empty() {
         let a = DList::<int>();
         let b = from_vec(~[4,5,6]);
         a.append(b);
@@ -558,7 +556,7 @@ mod tests {
         a.assert_consistent(); assert a.is_empty();
     }
     #[test]
-    fn test_dlist_append_two_empty() {
+    pub fn test_dlist_append_two_empty() {
         let a = DList::<int>();
         let b = DList::<int>();
         a.append(b);
@@ -570,19 +568,19 @@ mod tests {
     #[test]
     #[ignore(cfg(windows))]
     #[should_fail]
-    fn test_dlist_append_self() {
+    pub fn test_dlist_append_self() {
         let a = DList::<int>();
         a.append(a);
     }
     #[test]
     #[ignore(cfg(windows))]
     #[should_fail]
-    fn test_dlist_prepend_self() {
+    pub fn test_dlist_prepend_self() {
         let a = DList::<int>();
         a.prepend(a);
     }
     #[test]
-    fn test_dlist_prepend() {
+    pub fn test_dlist_prepend() {
         let a = from_vec(~[1,2,3]);
         let b = from_vec(~[4,5,6]);
         b.prepend(a);
@@ -598,7 +596,7 @@ mod tests {
         b.assert_consistent(); assert b.is_empty();
     }
     #[test]
-    fn test_dlist_reverse() {
+    pub fn test_dlist_reverse() {
         let a = from_vec(~[5,4,3,2,1]);
         a.reverse();
         assert a.len() == 5;
@@ -610,14 +608,14 @@ mod tests {
         a.assert_consistent(); assert a.is_empty();
     }
     #[test]
-    fn test_dlist_reverse_empty() {
+    pub fn test_dlist_reverse_empty() {
         let a = DList::<int>();
         a.reverse();
         assert a.len() == 0;
         a.assert_consistent();
     }
     #[test]
-    fn test_dlist_each_node() {
+    pub fn test_dlist_each_node() {
         let a = from_vec(~[1,2,4,5]);
         for a.each_node |nobe| {
             if nobe.data > 3 {
@@ -634,28 +632,28 @@ mod tests {
         a.assert_consistent(); assert a.is_empty();
     }
     #[test]
-    fn test_dlist_clear() {
+    pub fn test_dlist_clear() {
         let a = from_vec(~[5,4,3,2,1]);
         a.clear();
         assert a.len() == 0;
         a.assert_consistent();
     }
     #[test]
-    fn test_dlist_is_empty() {
+    pub fn test_dlist_is_empty() {
         let empty = DList::<int>();
         let full1 = from_vec(~[1,2,3]);
         assert empty.is_empty();
         assert !full1.is_empty();
     }
     #[test]
-    fn test_dlist_head_tail() {
+    pub fn test_dlist_head_tail() {
         let l = from_vec(~[1,2,3]);
         assert l.head() == 1;
         assert l.tail() == 3;
         assert l.len() == 3;
     }
     #[test]
-    fn test_dlist_pop() {
+    pub fn test_dlist_pop() {
         let l = from_vec(~[1,2,3]);
         assert l.pop().get() == 1;
         assert l.tail() == 3;
@@ -668,7 +666,7 @@ mod tests {
         assert l.pop().is_none();
     }
     #[test]
-    fn test_dlist_pop_tail() {
+    pub fn test_dlist_pop_tail() {
         let l = from_vec(~[1,2,3]);
         assert l.pop_tail().get() == 3;
         assert l.tail() == 2;
@@ -681,7 +679,7 @@ mod tests {
         assert l.pop_tail().is_none();
     }
     #[test]
-    fn test_dlist_push() {
+    pub fn test_dlist_push() {
         let l = DList::<int>();
         l.push(1);
         assert l.head() == 1;
@@ -695,7 +693,7 @@ mod tests {
         assert l.len() == 3;
     }
     #[test]
-    fn test_dlist_push_head() {
+    pub fn test_dlist_push_head() {
         let l = DList::<int>();
         l.push_head(3);
         assert l.head() == 3;
@@ -709,12 +707,12 @@ mod tests {
         assert l.len() == 3;
     }
     #[test]
-    fn test_dlist_foldl() {
+    pub fn test_dlist_foldl() {
         let l = from_vec(vec::from_fn(101, |x|x));
         assert iter::foldl(&l, 0, |accum,elem| *accum+*elem) == 5050;
     }
     #[test]
-    fn test_dlist_break_early() {
+    pub fn test_dlist_break_early() {
         let l = from_vec(~[1,2,3,4,5]);
         let mut x = 0;
         for l.each |i| {
@@ -724,7 +722,7 @@ mod tests {
         assert x == 3;
     }
     #[test]
-    fn test_dlist_remove_head() {
+    pub fn test_dlist_remove_head() {
         let l = DList::<int>();
         l.assert_consistent(); let one = l.push_n(1);
         l.assert_consistent(); let _two = l.push_n(2);
@@ -739,7 +737,7 @@ mod tests {
         l.assert_consistent(); assert l.is_empty();
     }
     #[test]
-    fn test_dlist_remove_mid() {
+    pub fn test_dlist_remove_mid() {
         let l = DList::<int>();
         l.assert_consistent(); let _one = l.push_n(1);
         l.assert_consistent(); let two = l.push_n(2);
@@ -754,7 +752,7 @@ mod tests {
         l.assert_consistent(); assert l.is_empty();
     }
     #[test]
-    fn test_dlist_remove_tail() {
+    pub fn test_dlist_remove_tail() {
         let l = DList::<int>();
         l.assert_consistent(); let _one = l.push_n(1);
         l.assert_consistent(); let _two = l.push_n(2);
@@ -769,7 +767,7 @@ mod tests {
         l.assert_consistent(); assert l.is_empty();
     }
     #[test]
-    fn test_dlist_remove_one_two() {
+    pub fn test_dlist_remove_one_two() {
         let l = DList::<int>();
         l.assert_consistent(); let one = l.push_n(1);
         l.assert_consistent(); let two = l.push_n(2);
@@ -785,7 +783,7 @@ mod tests {
         l.assert_consistent(); assert l.is_empty();
     }
     #[test]
-    fn test_dlist_remove_one_three() {
+    pub fn test_dlist_remove_one_three() {
         let l = DList::<int>();
         l.assert_consistent(); let one = l.push_n(1);
         l.assert_consistent(); let _two = l.push_n(2);
@@ -800,7 +798,7 @@ mod tests {
         l.assert_consistent(); assert l.is_empty();
     }
     #[test]
-    fn test_dlist_remove_two_three() {
+    pub fn test_dlist_remove_two_three() {
         let l = DList::<int>();
         l.assert_consistent(); let _one = l.push_n(1);
         l.assert_consistent(); let two = l.push_n(2);
@@ -815,7 +813,7 @@ mod tests {
         l.assert_consistent(); assert l.is_empty();
     }
     #[test]
-    fn test_dlist_remove_all() {
+    pub fn test_dlist_remove_all() {
         let l = DList::<int>();
         l.assert_consistent(); let one = l.push_n(1);
         l.assert_consistent(); let two = l.push_n(2);
@@ -828,7 +826,7 @@ mod tests {
         l.assert_consistent(); assert l.is_empty();
     }
     #[test]
-    fn test_dlist_insert_n_before() {
+    pub fn test_dlist_insert_n_before() {
         let l = DList::<int>();
         l.assert_consistent(); let _one = l.push_n(1);
         l.assert_consistent(); let two = l.push_n(2);
@@ -844,7 +842,7 @@ mod tests {
         l.assert_consistent(); assert l.is_empty();
     }
     #[test]
-    fn test_dlist_insert_n_after() {
+    pub fn test_dlist_insert_n_after() {
         let l = DList::<int>();
         l.assert_consistent(); let one = l.push_n(1);
         l.assert_consistent(); let _two = l.push_n(2);
@@ -860,7 +858,7 @@ mod tests {
         l.assert_consistent(); assert l.is_empty();
     }
     #[test]
-    fn test_dlist_insert_before_head() {
+    pub fn test_dlist_insert_before_head() {
         let l = DList::<int>();
         l.assert_consistent(); let one = l.push_n(1);
         l.assert_consistent(); let _two = l.push_n(2);
@@ -875,7 +873,7 @@ mod tests {
         l.assert_consistent(); assert l.is_empty();
     }
     #[test]
-    fn test_dlist_insert_after_tail() {
+    pub fn test_dlist_insert_after_tail() {
         let l = DList::<int>();
         l.assert_consistent(); let _one = l.push_n(1);
         l.assert_consistent(); let two = l.push_n(2);
@@ -890,15 +888,15 @@ mod tests {
         l.assert_consistent(); assert l.is_empty();
     }
     #[test] #[should_fail] #[ignore(cfg(windows))]
-    fn test_dlist_asymmetric_link() {
+    pub fn test_dlist_asymmetric_link() {
         let l = DList::<int>();
         let _one = l.push_n(1);
         let two = l.push_n(2);
         two.prev = None;
         l.assert_consistent();
     }
     #[test] #[should_fail] #[ignore(cfg(windows))]
-    fn test_dlist_cyclic_list() {
+    pub fn test_dlist_cyclic_list() {
         let l = DList::<int>();
         let one = l.push_n(1);
         let _two = l.push_n(2);
@@ -908,32 +906,32 @@ mod tests {
         l.assert_consistent();
     }
     #[test] #[should_fail] #[ignore(cfg(windows))]
-    fn test_dlist_headless() {
+    pub fn test_dlist_headless() {
         DList::<int>().head();
     }
     #[test] #[should_fail] #[ignore(cfg(windows))]
-    fn test_dlist_insert_already_present_before() {
+    pub fn test_dlist_insert_already_present_before() {
         let l = DList::<int>();
         let one = l.push_n(1);
         let two = l.push_n(2);
         l.insert_n_before(two, one);
     }
     #[test] #[should_fail] #[ignore(cfg(windows))]
-    fn test_dlist_insert_already_present_after() {
+    pub fn test_dlist_insert_already_present_after() {
         let l = DList::<int>();
         let one = l.push_n(1);
         let two = l.push_n(2);
         l.insert_n_after(one, two);
     }
     #[test] #[should_fail] #[ignore(cfg(windows))]
-    fn test_dlist_insert_before_orphan() {
+    pub fn test_dlist_insert_before_orphan() {
         let l = DList::<int>();
         let one = new_dlist_node(1);
         let two = new_dlist_node(2);
         l.insert_n_before(one, two);
     }
     #[test] #[should_fail] #[ignore(cfg(windows))]
-    fn test_dlist_insert_after_orphan() {
+    pub fn test_dlist_insert_after_orphan() {
         let l = DList::<int>();
         let one = new_dlist_node(1);
         let two = new_dlist_node(2);

trunk/src/libcore/gc.rs

@@ -62,16 +62,15 @@ struct StackSegment {
 }
 
 extern mod rustrt {
-    #[legacy_exports];
     #[rust_stack]
-    unsafe fn rust_call_tydesc_glue(root: *Word,
-                                    tydesc: *Word,
-                                    field: size_t);
+    pub unsafe fn rust_call_tydesc_glue(root: *Word,
+                                        tydesc: *Word,
+                                        field: size_t);
 
     #[rust_stack]
-    unsafe fn rust_gc_metadata() -> *Word;
+    pub unsafe fn rust_gc_metadata() -> *Word;
 
-    unsafe fn rust_get_stack_segment() -> *StackSegment;
+    pub unsafe fn rust_get_stack_segment() -> *StackSegment;
 }
 
 unsafe fn bump<T, U>(ptr: *T, count: uint) -> *U {