Remove all external requirements of @ from TLS

Closes #6004

src/libstd/condition.rs

@@ -32,7 +32,7 @@ impl<'self, T, U> Condition<'self, T, U> {
     pub fn trap(&'self self, h: &'self fn(T) -> U) -> Trap<'self, T, U> {
         unsafe {
             let p : *RustClosure = ::cast::transmute(&h);
-            let prev = local_data::get(self.key);
+            let prev = local_data::get(self.key, |k| k.map(|&x| *x));
             let h = @Handler { handle: *p, prev: prev };
             Trap { cond: self, handler: h }
         }

src/libstd/local_data.rs

@@ -83,16 +83,16 @@ pub unsafe fn pop<T: 'static>(key: Key<T>) -> Option<T> {
  * table until explicitly removed.
  */
 #[cfg(stage0)]
-pub unsafe fn get<T: 'static>(key: Key<@T>) -> Option<@T> {
-    local_get(Handle::new(), key, |loc| loc.map(|&x| *x))
+pub unsafe fn get<T: 'static, U>(key: Key<@T>, f: &fn(Option<&@T>) -> U) -> U {
+    local_get(Handle::new(), key, f)
 }
 /**
  * Retrieve a task-local data value. It will also be kept alive in the
  * table until explicitly removed.
  */
 #[cfg(not(stage0))]
-pub unsafe fn get<T: 'static>(key: Key<@T>) -> Option<@T> {
-    local_get(Handle::new(), key, |loc| loc.map(|&x| *x))
+pub unsafe fn get<T: 'static, U>(key: Key<T>, f: &fn(Option<&T>) -> U) -> U {
+    local_get(Handle::new(), key, f)
 }
 /**
  * Store a value in task-local data. If this key already has a value,
@@ -142,16 +142,16 @@ fn test_tls_multitask() {
         set(my_key, @~"parent data");
         do task::spawn {
             // TLS shouldn't carry over.
-            assert!(get(my_key).is_none());
+            assert!(get(my_key, |k| k.map(|&k| *k)).is_none());
             set(my_key, @~"child data");
-            assert!(*(get(my_key).get()) ==
+            assert!(*(get(my_key, |k| k.map(|&k| *k)).get()) ==
                     ~"child data");
             // should be cleaned up for us
         }
         // Must work multiple times
-        assert!(*(get(my_key).get()) == ~"parent data");
-        assert!(*(get(my_key).get()) == ~"parent data");
-        assert!(*(get(my_key).get()) == ~"parent data");
+        assert!(*(get(my_key, |k| k.map(|&k| *k)).get()) == ~"parent data");
+        assert!(*(get(my_key, |k| k.map(|&k| *k)).get()) == ~"parent data");
+        assert!(*(get(my_key, |k| k.map(|&k| *k)).get()) == ~"parent data");
     }
 }
 
@@ -161,7 +161,7 @@ fn test_tls_overwrite() {
         fn my_key(_x: @~str) { }
         set(my_key, @~"first data");
         set(my_key, @~"next data"); // Shouldn't leak.
-        assert!(*(get(my_key).get()) == ~"next data");
+        assert!(*(get(my_key, |k| k.map(|&k| *k)).get()) == ~"next data");
     }
 }
 
@@ -170,7 +170,7 @@ fn test_tls_pop() {
     unsafe {
         fn my_key(_x: @~str) { }
         set(my_key, @~"weasel");
-        assert!(*(pop(my_key).get()) == ~"weasel");
+        assert!(*(pop(my_key, |k| k.map(|&k| *k)).get()) == ~"weasel");
         // Pop must remove the data from the map.
         assert!(pop(my_key).is_none());
     }

src/libstd/os.rs

@@ -1230,7 +1230,7 @@ fn overridden_arg_key(_v: @OverriddenArgs) {}
 /// `os::set_args` function.
 pub fn args() -> ~[~str] {
     unsafe {
-        match local_data::get(overridden_arg_key) {
+        match local_data::get(overridden_arg_key, |k| k.map(|&k| *k)) {
             None => real_args(),
             Some(args) => copy args.val
         }

src/libstd/rand.rs

@@ -850,7 +850,7 @@ fn tls_rng_state(_v: @@mut IsaacRng) {}
 pub fn task_rng() -> @mut IsaacRng {
     let r : Option<@@mut IsaacRng>;
     unsafe {
-        r = local_data::get(tls_rng_state);
+        r = local_data::get(tls_rng_state, |k| k.map(|&k| *k));
     }
     match r {
         None => {

src/libstd/rt/task.rs

@@ -172,10 +172,10 @@ mod test {
             unsafe {
                 fn key(_x: @~str) { }
                 local_data::set(key, @~"data");
-                assert!(*local_data::get(key).get() == ~"data");
+                assert!(*local_data::get(key, |k| k.map(|&k| *k)).get() == ~"data");
                 fn key2(_x: @~str) { }
                 local_data::set(key2, @~"data");
-                assert!(*local_data::get(key2).get() == ~"data");
+                assert!(*local_data::get(key2, |k| k.map(|&k| *k)).get() == ~"data");
             }
         }
     }