Remove all external requirements of `@` from TLS

Closes #6004

diff --git a/src/libextra/rl.rs b/src/libextra/rl.rs
index 210c6593a184f13457918bb0312a2dd37a4ccf50..c1eeb5005b26578184736428aeed322313555efc 100644 (file)
--- a/src/libextra/rl.rs
+++ b/src/libextra/rl.rs
@@ -76,7 +76,7 @@ pub unsafe fn complete(cb: CompletionCb) {
 
     extern fn callback(line: *c_char, completions: *()) {
         unsafe {
-            let cb = *local_data::get(complete_key)
+            let cb = *local_data::get(complete_key, |k| k.map(|&k| *k))
                 .get();
 
             do cb(str::raw::from_c_str(line)) |suggestion| {

diff --git a/src/libextra/sort.rs b/src/libextra/sort.rs
index 50fa9c35d7e9304088f213a1b55e716ce9a5e7bb..d4d6162a9198f4ef804e0f9585d3d90bc92a722d 100644 (file)
--- a/src/libextra/sort.rs
+++ b/src/libextra/sort.rs
@@ -1204,7 +1204,7 @@ struct LVal<'self> {
     #[unsafe_destructor]
     impl<'self> Drop for LVal<'self> {
         fn drop(&self) {
-            let x = unsafe { local_data::get(self.key) };
+            let x = unsafe { local_data::get(self.key, |k| k.map(|&k| *k)) };
             match x {
                 Some(@y) => {
                     unsafe {

diff --git a/src/librustc/middle/trans/base.rs b/src/librustc/middle/trans/base.rs
index bc22f89da7e633b1a9add4f5b03e989b5fcf7ce7..dc62206fb34c8c06031b37dc10b08aedf41599f9 100644 (file)
--- a/src/librustc/middle/trans/base.rs
+++ b/src/librustc/middle/trans/base.rs
@@ -92,7 +92,7 @@ fn task_local_insn_key(_v: @~[&'static str]) {}
 
 pub fn with_insn_ctxt(blk: &fn(&[&'static str])) {
     unsafe {
-        let opt = local_data::get(task_local_insn_key);
+        let opt = local_data::get(task_local_insn_key, |k| k.map(|&k| *k));
         if opt.is_some() {
             blk(*opt.unwrap());
         }

diff --git a/src/librustc/middle/trans/context.rs b/src/librustc/middle/trans/context.rs
index dff365d79d2ef487aa47d9981acdd3ac62c443e8..77a565e675f0810dc3ead73dc75b6df8ccf843fb 100644 (file)
--- a/src/librustc/middle/trans/context.rs
+++ b/src/librustc/middle/trans/context.rs
@@ -241,7 +241,7 @@ fn drop(&self) {
 
 fn task_local_llcx_key(_v: @ContextRef) {}
 pub fn task_llcx() -> ContextRef {
-    let opt = unsafe { local_data::get(task_local_llcx_key) };
+    let opt = unsafe { local_data::get(task_local_llcx_key, |k| k.map(|&k| *k)) };
     *opt.expect("task-local LLVMContextRef wasn't ever set!")
 }
 

diff --git a/src/librusti/program.rs b/src/librusti/program.rs
index 3af5e98ebaf32e73b6975d0c669af3d9686afd4d..03a48117cd4e5b6c15d6351fd1e7292e112ba043 100644 (file)
--- a/src/librusti/program.rs
+++ b/src/librusti/program.rs
@@ -144,7 +144,7 @@ fn main() {
                 let key = ::std::sys::Closure{ code: %? as *(),
                                                env: ::std::ptr::null() };
                 let key = ::std::cast::transmute(key);
-                *::std::local_data::get(key).unwrap()
+                *::std::local_data::get(key, |k| k.map(|&x| *x)).unwrap()
             };\n", key.code as uint));
 
         // Using this __tls_map handle, deserialize each variable binding that

diff --git a/src/libstd/condition.rs b/src/libstd/condition.rs
index 10900b7172a93e6a70981854ad0dbbf0da8d4408..d6d09527f83012c118130ace8708fbe37d2f6f1a 100644 (file)
--- a/src/libstd/condition.rs
+++ b/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 }
         }

diff --git a/src/libstd/local_data.rs b/src/libstd/local_data.rs
index 711ed15fa9d2f05349b74b32331f5ca8ec34fa9b..fa981d273e28ccc15ea03cac023a9d570f76251e 100644 (file)
--- a/src/libstd/local_data.rs
+++ b/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 my_key(_x: @~str) { }
         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());
     }

diff --git a/src/libstd/os.rs b/src/libstd/os.rs
index 3c8294bdfd119a23bbb50982b6fc7a46e09e138f..2e511f91b5abee7d284f8fc95bf1ba9192984d1b 100644 (file)
--- a/src/libstd/os.rs
+++ b/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
         }

diff --git a/src/libstd/rand.rs b/src/libstd/rand.rs
index 860a69bd1e08b63091fd261b4c08e4bf61ce980a..bc80bd9dc6abafb55928f60c1e9bb8b47ff7c3b3 100644 (file)
--- a/src/libstd/rand.rs
+++ b/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 => {

diff --git a/src/libstd/rt/task.rs b/src/libstd/rt/task.rs
index 55e633e84969e1a4d23c250957c3c05e03038782..2100e71e9fd2342a356568472159100efe050449 100644 (file)
--- a/src/libstd/rt/task.rs
+++ b/src/libstd/rt/task.rs
@@ -172,10 +172,10 @@ fn tls() {
             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");
             }
         }
     }

diff --git a/src/libsyntax/ast_util.rs b/src/libsyntax/ast_util.rs
index a224d686cea5d367b3d526b7157c307a33d89c49..1942cb6ad56928c23b3b474f827b2c6d90ce5247 100644 (file)
--- a/src/libsyntax/ast_util.rs
+++ b/src/libsyntax/ast_util.rs
@@ -698,7 +698,7 @@ pub fn get_sctable() -> @mut SCTable {
         let sctable_key = (cast::transmute::<(uint, uint),
                            &fn:Copy(v: @@mut SCTable)>(
                                (-4 as uint, 0u)));
-        match local_data::get(sctable_key) {
+        match local_data::get(sctable_key, |k| k.map(|&k| *k)) {
             None => {
                 let new_table = @@mut new_sctable_internal();
                 local_data::set(sctable_key,new_table);

diff --git a/src/libsyntax/parse/token.rs b/src/libsyntax/parse/token.rs
index 1ddc42b4a4ef26869d64a047e3e9e76f23cba888..46e0ef32321a5a3f1faa788d5976ba792cdaa63c 100644 (file)
--- a/src/libsyntax/parse/token.rs
+++ b/src/libsyntax/parse/token.rs
@@ -490,7 +490,7 @@ pub fn get_ident_interner() -> @ident_interner {
             (cast::transmute::<(uint, uint),
              &fn:Copy(v: @@::parse::token::ident_interner)>(
                  (-3 as uint, 0u)));
-        match local_data::get(key) {
+        match local_data::get(key, |k| k.map(|&k| *k)) {
             Some(interner) => *interner,
             None => {
                 let interner = mk_fresh_ident_interner();