De-export the submodules of task. Part of #3583.

Author: graydon

src/libcore/core.rc

@@ -216,17 +216,11 @@ mod send_map;
 
 // Concurrency
 mod comm;
-#[legacy_exports]
 mod task {
-    #[legacy_exports];
-    #[legacy_exports]
-    mod local_data;
-    #[legacy_exports]
+    pub mod local_data;
     mod local_data_priv;
-    #[legacy_exports]
-    mod spawn;
-    #[legacy_exports]
-    mod rt;
+    pub mod spawn;
+    pub mod rt;
 }
 mod future;
 mod pipes;

src/libcore/rt.rs

@@ -11,10 +11,9 @@ use libc::uintptr_t;
 use gc::{cleanup_stack_for_failure, gc, Word};
 
 #[allow(non_camel_case_types)]
-type rust_task = c_void;
+pub type rust_task = c_void;
 
 extern mod rustrt {
-    #[legacy_exports];
     #[rust_stack]
     fn rust_upcall_fail(expr: *c_char, file: *c_char, line: size_t);
 
@@ -35,13 +34,13 @@ extern mod rustrt {
 // 'rt_', otherwise the compiler won't find it. To fix this, see
 // gather_rust_rtcalls.
 #[rt(fail_)]
-fn rt_fail_(expr: *c_char, file: *c_char, line: size_t) {
+pub fn rt_fail_(expr: *c_char, file: *c_char, line: size_t) {
     cleanup_stack_for_failure();
     rustrt::rust_upcall_fail(expr, file, line);
 }
 
 #[rt(fail_bounds_check)]
-fn rt_fail_bounds_check(file: *c_char, line: size_t,
+pub fn rt_fail_bounds_check(file: *c_char, line: size_t,
                         index: size_t, len: size_t) {
     let msg = fmt!("index out of bounds: the len is %d but the index is %d",
                     len as int, index as int);
@@ -51,28 +50,28 @@ fn rt_fail_bounds_check(file: *c_char, line: size_t,
 }
 
 #[rt(exchange_malloc)]
-fn rt_exchange_malloc(td: *c_char, size: uintptr_t) -> *c_char {
+pub fn rt_exchange_malloc(td: *c_char, size: uintptr_t) -> *c_char {
     return rustrt::rust_upcall_exchange_malloc(td, size);
 }
 
 // NB: Calls to free CANNOT be allowed to fail, as throwing an exception from
 // inside a landing pad may corrupt the state of the exception handler. If a
 // problem occurs, call exit instead.
 #[rt(exchange_free)]
-fn rt_exchange_free(ptr: *c_char) {
+pub fn rt_exchange_free(ptr: *c_char) {
     rustrt::rust_upcall_exchange_free(ptr);
 }
 
 #[rt(malloc)]
-fn rt_malloc(td: *c_char, size: uintptr_t) -> *c_char {
+pub fn rt_malloc(td: *c_char, size: uintptr_t) -> *c_char {
     return rustrt::rust_upcall_malloc(td, size);
 }
 
 // NB: Calls to free CANNOT be allowed to fail, as throwing an exception from
 // inside a landing pad may corrupt the state of the exception handler. If a
 // problem occurs, call exit instead.
 #[rt(free)]
-fn rt_free(ptr: *c_char) {
+pub fn rt_free(ptr: *c_char) {
     rustrt::rust_upcall_free(ptr);
 }
 

src/libcore/task/local_data_priv.rs

@@ -3,7 +3,7 @@
 use local_data::LocalDataKey;
 use rt::rust_task;
 
-trait LocalData { }
+pub trait LocalData { }
 impl<T: Owned> @T: LocalData { }
 
 impl LocalData: Eq {
@@ -17,19 +17,19 @@ impl LocalData: Eq {
 
 // We use dvec because it's the best data structure in core. If TLS is used
 // heavily in future, this could be made more efficient with a proper map.
-type TaskLocalElement = (*libc::c_void, *libc::c_void, LocalData);
+pub type TaskLocalElement = (*libc::c_void, *libc::c_void, LocalData);
 // Has to be a pointer at outermost layer; the foreign call returns void *.
-type TaskLocalMap = @dvec::DVec<Option<TaskLocalElement>>;
+pub type TaskLocalMap = @dvec::DVec<Option<TaskLocalElement>>;
 
-extern fn cleanup_task_local_map(map_ptr: *libc::c_void) unsafe {
+pub extern fn cleanup_task_local_map(map_ptr: *libc::c_void) unsafe {
     assert !map_ptr.is_null();
     // Get and keep the single reference that was created at the beginning.
     let _map: TaskLocalMap = cast::reinterpret_cast(&map_ptr);
     // All local_data will be destroyed along with the map.
 }
 
 // Gets the map from the runtime. Lazily initialises if not done so already.
-unsafe fn get_task_local_map(task: *rust_task) -> TaskLocalMap {
+pub unsafe fn get_task_local_map(task: *rust_task) -> TaskLocalMap {
 
     // Relies on the runtime initialising the pointer to null.
     // NOTE: The map's box lives in TLS invisibly referenced once. Each time
@@ -52,7 +52,7 @@ unsafe fn get_task_local_map(task: *rust_task) -> TaskLocalMap {
     }
 }
 
-unsafe fn key_to_key_value<T: Owned>(
+pub unsafe fn key_to_key_value<T: Owned>(
     key: LocalDataKey<T>) -> *libc::c_void {
 
     // Keys are closures, which are (fnptr,envptr) pairs. Use fnptr.
@@ -62,7 +62,7 @@ unsafe fn key_to_key_value<T: Owned>(
 }
 
 // If returning Some(..), returns with @T with the map's reference. Careful!
-unsafe fn local_data_lookup<T: Owned>(
+pub unsafe fn local_data_lookup<T: Owned>(
     map: TaskLocalMap, key: LocalDataKey<T>)
     -> Option<(uint, *libc::c_void)> {
 
@@ -80,7 +80,7 @@ unsafe fn local_data_lookup<T: Owned>(
     }
 }
 
-unsafe fn local_get_helper<T: Owned>(
+pub unsafe fn local_get_helper<T: Owned>(
     task: *rust_task, key: LocalDataKey<T>,
     do_pop: bool) -> Option<@T> {
 
@@ -102,21 +102,21 @@ unsafe fn local_get_helper<T: Owned>(
 }
 
 
-unsafe fn local_pop<T: Owned>(
+pub unsafe fn local_pop<T: Owned>(
     task: *rust_task,
     key: LocalDataKey<T>) -> Option<@T> {
 
     local_get_helper(task, key, true)
 }
 
-unsafe fn local_get<T: Owned>(
+pub unsafe fn local_get<T: Owned>(
     task: *rust_task,
     key: LocalDataKey<T>) -> Option<@T> {
 
     local_get_helper(task, key, false)
 }
 
-unsafe fn local_set<T: Owned>(
+pub unsafe fn local_set<T: Owned>(
     task: *rust_task, key: LocalDataKey<T>, data: @T) {
 
     let map = get_task_local_map(task);
@@ -148,7 +148,7 @@ unsafe fn local_set<T: Owned>(
     }
 }
 
-unsafe fn local_modify<T: Owned>(
+pub unsafe fn local_modify<T: Owned>(
     task: *rust_task, key: LocalDataKey<T>,
     modify_fn: fn(Option<@T>) -> Option<@T>) {
 

src/libcore/task/rt.rs

@@ -7,16 +7,16 @@ The task interface to the runtime
 #[doc(hidden)]; // FIXME #3538
 
 #[allow(non_camel_case_types)] // runtime type
-type sched_id = int;
+pub type sched_id = int;
 #[allow(non_camel_case_types)] // runtime type
-type task_id = int;
+pub type task_id = int;
 
 // These are both opaque runtime/compiler types that we don't know the
 // structure of and should only deal with via unsafe pointer
 #[allow(non_camel_case_types)] // runtime type
-type rust_task = libc::c_void;
+pub type rust_task = libc::c_void;
 #[allow(non_camel_case_types)] // runtime type
-type rust_closure = libc::c_void;
+pub type rust_closure = libc::c_void;
 
 extern {
     #[rust_stack]

src/libcore/task/spawn.rs

@@ -69,38 +69,38 @@ macro_rules! move_it (
     { $x:expr } => { unsafe { let y <- *ptr::addr_of(&($x)); move y } }
 )
 
-type TaskSet = send_map::linear::LinearMap<*rust_task,()>;
+pub type TaskSet = send_map::linear::LinearMap<*rust_task,()>;
 
-fn new_taskset() -> TaskSet {
+pub fn new_taskset() -> TaskSet {
     send_map::linear::LinearMap()
 }
-fn taskset_insert(tasks: &mut TaskSet, task: *rust_task) {
+pub fn taskset_insert(tasks: &mut TaskSet, task: *rust_task) {
     let didnt_overwrite = tasks.insert(task, ());
     assert didnt_overwrite;
 }
-fn taskset_remove(tasks: &mut TaskSet, task: *rust_task) {
+pub fn taskset_remove(tasks: &mut TaskSet, task: *rust_task) {
     let was_present = tasks.remove(&task);
     assert was_present;
 }
-fn taskset_each(tasks: &TaskSet, blk: fn(v: *rust_task) -> bool) {
+pub fn taskset_each(tasks: &TaskSet, blk: fn(v: *rust_task) -> bool) {
     tasks.each_key(|k| blk(*k))
 }
 
 // One of these per group of linked-failure tasks.
-type TaskGroupData = {
+pub type TaskGroupData = {
     // All tasks which might kill this group. When this is empty, the group
     // can be "GC"ed (i.e., its link in the ancestor list can be removed).
     mut members:     TaskSet,
     // All tasks unidirectionally supervised by (directly or transitively)
     // tasks in this group.
     mut descendants: TaskSet,
 };
-type TaskGroupArc = private::Exclusive<Option<TaskGroupData>>;
+pub type TaskGroupArc = private::Exclusive<Option<TaskGroupData>>;
 
-type TaskGroupInner = &mut Option<TaskGroupData>;
+pub type TaskGroupInner = &mut Option<TaskGroupData>;
 
 // A taskgroup is 'dead' when nothing can cause it to fail; only members can.
-pure fn taskgroup_is_dead(tg: &TaskGroupData) -> bool {
+pub pure fn taskgroup_is_dead(tg: &TaskGroupData) -> bool {
     (&tg.members).is_empty()
 }
 
@@ -111,7 +111,7 @@ pure fn taskgroup_is_dead(tg: &TaskGroupData) -> bool {
 // taskgroup which was spawned-unlinked. Tasks from intermediate generations
 // have references to the middle of the list; when intermediate generations
 // die, their node in the list will be collected at a descendant's spawn-time.
-type AncestorNode = {
+pub type AncestorNode = {
     // Since the ancestor list is recursive, we end up with references to
     // exclusives within other exclusives. This is dangerous business (if
     // circular references arise, deadlock and memory leaks are imminent).
@@ -124,16 +124,16 @@ type AncestorNode = {
     // Recursive rest of the list.
     mut ancestors:    AncestorList,
 };
-enum AncestorList = Option<private::Exclusive<AncestorNode>>;
+pub enum AncestorList = Option<private::Exclusive<AncestorNode>>;
 
 // Accessors for taskgroup arcs and ancestor arcs that wrap the unsafety.
 #[inline(always)]
-fn access_group<U>(x: &TaskGroupArc, blk: fn(TaskGroupInner) -> U) -> U {
+pub fn access_group<U>(x: &TaskGroupArc, blk: fn(TaskGroupInner) -> U) -> U {
     unsafe { x.with(blk) }
 }
 
 #[inline(always)]
-fn access_ancestors<U>(x: &private::Exclusive<AncestorNode>,
+pub fn access_ancestors<U>(x: &private::Exclusive<AncestorNode>,
                        blk: fn(x: &mut AncestorNode) -> U) -> U {
     unsafe { x.with(blk) }
 }
@@ -146,9 +146,9 @@ fn access_ancestors<U>(x: &private::Exclusive<AncestorNode>,
 // (3) As a bonus, coalesces away all 'dead' taskgroup nodes in the list.
 // FIXME(#2190): Change Option<fn@(...)> to Option<fn&(...)>, to save on
 // allocations. Once that bug is fixed, changing the sigil should suffice.
-fn each_ancestor(list:        &mut AncestorList,
-                 bail_opt:    Option<fn@(TaskGroupInner)>,
-                 forward_blk: fn(TaskGroupInner) -> bool)
+pub fn each_ancestor(list:        &mut AncestorList,
+                     bail_opt:    Option<fn@(TaskGroupInner)>,
+                     forward_blk: fn(TaskGroupInner) -> bool)
         -> bool {
     // "Kickoff" call - there was no last generation.
     return !coalesce(list, bail_opt, forward_blk, uint::max_value);
@@ -271,7 +271,7 @@ fn each_ancestor(list:        &mut AncestorList,
 }
 
 // One of these per task.
-struct TCB {
+pub struct TCB {
     me:            *rust_task,
     // List of tasks with whose fates this one's is intertwined.
     tasks:         TaskGroupArc, // 'none' means the group has failed.
@@ -303,7 +303,7 @@ struct TCB {
     }
 }
 
-fn TCB(me: *rust_task, tasks: TaskGroupArc, ancestors: AncestorList,
+pub fn TCB(me: *rust_task, tasks: TaskGroupArc, ancestors: AncestorList,
        is_main: bool, notifier: Option<AutoNotify>) -> TCB {
 
     let notifier = move notifier;
@@ -318,7 +318,7 @@ fn TCB(me: *rust_task, tasks: TaskGroupArc, ancestors: AncestorList,
     }
 }
 
-struct AutoNotify {
+pub struct AutoNotify {
     notify_chan: Chan<Notification>,
     mut failed:  bool,
     drop {
@@ -327,15 +327,15 @@ struct AutoNotify {
     }
 }
 
-fn AutoNotify(chan: Chan<Notification>) -> AutoNotify {
+pub fn AutoNotify(chan: Chan<Notification>) -> AutoNotify {
     AutoNotify {
         notify_chan: chan,
         failed: true // Un-set above when taskgroup successfully made.
     }
 }
 
-fn enlist_in_taskgroup(state: TaskGroupInner, me: *rust_task,
-                       is_member: bool) -> bool {
+pub fn enlist_in_taskgroup(state: TaskGroupInner, me: *rust_task,
+                           is_member: bool) -> bool {
     let newstate = util::replace(state, None);
     // If 'None', the group was failing. Can't enlist.
     if newstate.is_some() {
@@ -350,7 +350,8 @@ fn enlist_in_taskgroup(state: TaskGroupInner, me: *rust_task,
 }
 
 // NB: Runs in destructor/post-exit context. Can't 'fail'.
-fn leave_taskgroup(state: TaskGroupInner, me: *rust_task, is_member: bool) {
+pub fn leave_taskgroup(state: TaskGroupInner, me: *rust_task,
+                       is_member: bool) {
     let newstate = util::replace(state, None);
     // If 'None', already failing and we've already gotten a kill signal.
     if newstate.is_some() {
@@ -362,7 +363,7 @@ fn leave_taskgroup(state: TaskGroupInner, me: *rust_task, is_member: bool) {
 }
 
 // NB: Runs in destructor/post-exit context. Can't 'fail'.
-fn kill_taskgroup(state: TaskGroupInner, me: *rust_task, is_main: bool) {
+pub fn kill_taskgroup(state: TaskGroupInner, me: *rust_task, is_main: bool) {
     // NB: We could do the killing iteration outside of the group arc, by
     // having "let mut newstate" here, swapping inside, and iterating after.
     // But that would let other exiting tasks fall-through and exit while we
@@ -404,8 +405,8 @@ macro_rules! taskgroup_key (
     () => (cast::transmute((-2 as uint, 0u)))
 )
 
-fn gen_child_taskgroup(linked: bool, supervised: bool)
-        -> (TaskGroupArc, AncestorList, bool) {
+pub fn gen_child_taskgroup(linked: bool, supervised: bool)
+    -> (TaskGroupArc, AncestorList, bool) {
     let spawner = rt::rust_get_task();
     /*######################################################################*
      * Step 1. Get spawner's taskgroup info.
@@ -486,7 +487,7 @@ fn gen_child_taskgroup(linked: bool, supervised: bool)
     }
 }
 
-fn spawn_raw(opts: TaskOpts, +f: fn~()) {
+pub fn spawn_raw(opts: TaskOpts, +f: fn~()) {
     let (child_tg, ancestors, is_main) =
         gen_child_taskgroup(opts.linked, opts.supervised);
 

src/test/run-pass/issue-783.rs

@@ -1,6 +1,6 @@
 extern mod std;
 use comm::*;
-use task::*;
+use task::spawn;
 
 fn a() {
     fn doit() {