---

yaml
---
r: 64373
b: refs/heads/snap-stage3
c: 0fd4d5d
h: refs/heads/master
i:
  64371: 996dbe0
v: v3

Author: alexcrichton

[refs]

@@ -1,7 +1,7 @@
 ---
 refs/heads/master: 2d28d645422c1617be58c8ca7ad9a457264ca850
 refs/heads/snap-stage1: e33de59e47c5076a89eadeb38f4934f58a3618a6
-refs/heads/snap-stage3: 948a62401ef717eb484c2215713291749f0f35ed
+refs/heads/snap-stage3: 0fd4d5d7783ffa709bcf089f5167a1871ec278fa
 refs/heads/try: 7b78b52e602bb3ea8174f9b2006bff3315f03ef9
 refs/tags/release-0.1: 1f5c5126e96c79d22cb7862f75304136e204f105
 refs/heads/ndm: f3868061cd7988080c30d6d5bf352a5a5fe2460b

branches/snap-stage3/src/librustc/middle/lint.rs

@@ -108,17 +108,22 @@ pub fn level_to_str(lv: level) -> &'static str {
     }
 }
 
-#[deriving(Eq)]
+#[deriving(Eq, Ord)]
 pub enum level {
     allow, warn, deny, forbid
 }
 
-struct LintSpec {
+#[deriving(Eq)]
+pub struct LintSpec {
     lint: lint,
     desc: &'static str,
     default: level
 }
 
+impl Ord for LintSpec {
+    fn lt(&self, other: &LintSpec) -> bool { self.default < other.default }
+}
+
 pub type LintDict = HashMap<&'static str, LintSpec>;
 
 enum AttributedNode<'self> {

branches/snap-stage3/src/librustc/rustc.rs

@@ -144,6 +144,7 @@ Additional help:
 }
 
 pub fn describe_warnings() {
+    use extra::sort::Sort;
     io::println(fmt!("
 Available lint options:
     -W <foo>           Warn about <foo>
@@ -153,8 +154,15 @@ Available lint options:
 "));
 
     let lint_dict = lint::get_lint_dict();
+    let mut lint_dict = lint_dict.consume_iter()
+                                 .transform(|(k, v)| (v, k))
+                                 .collect::<~[(lint::LintSpec, &'static str)]>();
+    lint_dict.qsort();
+
     let mut max_key = 0;
-    for lint_dict.each_key |k| { max_key = num::max(k.len(), max_key); }
+    for lint_dict.iter().advance |&(_, name)| {
+        max_key = num::max(name.len(), max_key);
+    }
     fn padded(max: uint, s: &str) -> ~str {
         str::from_bytes(vec::from_elem(max - s.len(), ' ' as u8)) + s
     }
@@ -163,17 +171,12 @@ Available lint options:
                      padded(max_key, "name"), "default", "meaning"));
     io::println(fmt!("    %s  %7.7s  %s\n",
                      padded(max_key, "----"), "-------", "-------"));
-    for lint_dict.iter().advance |(k, v)| {
-        let k = k.replace("_", "-");
+    for lint_dict.consume_iter().advance |(spec, name)| {
+        let name = name.replace("_", "-");
         io::println(fmt!("    %s  %7.7s  %s",
-                         padded(max_key, k),
-                         match v.default {
-                             lint::allow => ~"allow",
-                             lint::warn => ~"warn",
-                             lint::deny => ~"deny",
-                             lint::forbid => ~"forbid"
-                         },
-                         v.desc));
+                         padded(max_key, name),
+                         lint::level_to_str(spec.default),
+                         spec.desc));
     }
     io::println("");
 }

branches/snap-stage3/src/libstd/local_data.rs

@@ -41,7 +41,7 @@ magic.
 
 use prelude::*;
 
-use task::local_data_priv::*;
+use task::local_data_priv::{local_get, local_pop, local_set, Handle};
 
 #[cfg(test)] use task;
 
@@ -95,13 +95,6 @@ pub fn get<T: 'static, U>(key: Key<@T>, f: &fn(Option<&@T>) -> U) -> U {
 pub fn get<T: 'static, U>(key: Key<T>, f: &fn(Option<&T>) -> U) -> U {
     unsafe { local_get(Handle::new(), key, f) }
 }
-/**
- * Retrieve a mutable borrowed pointer to a task-local data value.
- */
-#[cfg(not(stage0))]
-pub fn get_mut<T: 'static, U>(key: Key<T>, f: &fn(Option<&mut T>) -> U) -> U {
-    unsafe { local_get_mut(Handle::new(), key, f) }
-}
 /**
  * Store a value in task-local data. If this key already has a value,
  * that value is overwritten (and its destructor is run).
@@ -269,34 +262,6 @@ fn test_static_pointer() {
 fn test_owned() {
     static key: Key<~int> = &Key;
     set(key, ~1);
-
-    do get(key) |v| {
-        do get(key) |v| {
-            do get(key) |v| {
-                assert_eq!(**v.unwrap(), 1);
-            }
-            assert_eq!(**v.unwrap(), 1);
-        }
-        assert_eq!(**v.unwrap(), 1);
-    }
-    set(key, ~2);
-    do get(key) |v| {
-        assert_eq!(**v.unwrap(), 2);
-    }
-}
-
-#[test]
-fn test_get_mut() {
-    static key: Key<int> = &Key;
-    set(key, 1);
-
-    do get_mut(key) |v| {
-        *v.unwrap() = 2;
-    }
-
-    do get(key) |v| {
-        assert_eq!(*v.unwrap(), 2);
-    }
 }
 
 #[test]
@@ -318,43 +283,3 @@ fn test_same_key_type() {
     get(key4, |x| assert_eq!(*x.unwrap(), 4));
     get(key5, |x| assert_eq!(*x.unwrap(), 5));
 }
-
-#[test]
-#[should_fail]
-fn test_nested_get_set1() {
-    static key: Key<int> = &Key;
-    set(key, 4);
-    do get(key) |_| {
-        set(key, 4);
-    }
-}
-
-#[test]
-#[should_fail]
-fn test_nested_get_mut2() {
-    static key: Key<int> = &Key;
-    set(key, 4);
-    do get(key) |_| {
-        get_mut(key, |_| {})
-    }
-}
-
-#[test]
-#[should_fail]
-fn test_nested_get_mut3() {
-    static key: Key<int> = &Key;
-    set(key, 4);
-    do get_mut(key) |_| {
-        get(key, |_| {})
-    }
-}
-
-#[test]
-#[should_fail]
-fn test_nested_get_mut4() {
-    static key: Key<int> = &Key;
-    set(key, 4);
-    do get_mut(key) |_| {
-        get_mut(key, |_| {})
-    }
-}

branches/snap-stage3/src/libstd/task/local_data_priv.rs

@@ -44,21 +44,6 @@ impl Handle {
     }
 }
 
-#[deriving(Eq)]
-enum LoanState {
-    NoLoan, ImmLoan, MutLoan
-}
-
-impl LoanState {
-    fn describe(&self) -> &'static str {
-        match *self {
-            NoLoan => "no loan",
-            ImmLoan => "immutable",
-            MutLoan => "mutable"
-        }
-    }
-}
-
 trait LocalData {}
 impl<T: 'static> LocalData for T {}
 
@@ -92,7 +77,7 @@ impl<T: 'static> LocalData for T {}
 //
 // n.b. If TLS is used heavily in future, this could be made more efficient with
 //      a proper map.
-type TaskLocalMap = ~[Option<(*libc::c_void, TLSValue, LoanState)>];
+type TaskLocalMap = ~[Option<(*libc::c_void, TLSValue, uint)>];
 type TLSValue = ~LocalData:;
 
 fn cleanup_task_local_map(map_ptr: *libc::c_void) {
@@ -167,10 +152,9 @@ pub unsafe fn local_pop<T: 'static>(handle: Handle,
 
     for map.mut_iter().advance |entry| {
         match *entry {
-            Some((k, _, loan)) if k == key_value => {
-                if loan != NoLoan {
-                    fail!("TLS value cannot be removed because it is already \
-                          borrowed as %s", loan.describe());
+            Some((k, _, loans)) if k == key_value => {
+                if loans != 0 {
+                    fail!("TLS value has been loaned via get already");
                 }
                 // Move the data out of the `entry` slot via util::replace. This
                 // is guaranteed to succeed because we already matched on `Some`
@@ -208,29 +192,6 @@ pub unsafe fn local_pop<T: 'static>(handle: Handle,
 pub unsafe fn local_get<T: 'static, U>(handle: Handle,
                                        key: local_data::Key<T>,
                                        f: &fn(Option<&T>) -> U) -> U {
-    local_get_with(handle, key, ImmLoan, f)
-}
-
-pub unsafe fn local_get_mut<T: 'static, U>(handle: Handle,
-                                           key: local_data::Key<T>,
-                                           f: &fn(Option<&mut T>) -> U) -> U {
-    do local_get_with(handle, key, MutLoan) |x| {
-        match x {
-            None => f(None),
-            // We're violating a lot of compiler guarantees with this
-            // invocation of `transmute_mut`, but we're doing runtime checks to
-            // ensure that it's always valid (only one at a time).
-            //
-            // there is no need to be upset!
-            Some(x) => { f(Some(cast::transmute_mut(x))) }
-        }
-    }
-}
-
-unsafe fn local_get_with<T: 'static, U>(handle: Handle,
-                                        key: local_data::Key<T>,
-                                        state: LoanState,
-                                        f: &fn(Option<&T>) -> U) -> U {
     // This function must be extremely careful. Because TLS can store owned
     // values, and we must have some form of `get` function other than `pop`,
     // this function has to give a `&` reference back to the caller.
@@ -257,24 +218,12 @@ unsafe fn local_get_with<T: 'static, U>(handle: Handle,
         None => { return f(None); }
         Some(i) => {
             let ret;
-            let mut return_loan = false;
             match map[i] {
-                Some((_, ref data, ref mut loan)) => {
-                    match (state, *loan) {
-                        (_, NoLoan) => {
-                            *loan = state;
-                            return_loan = true;
-                        }
-                        (ImmLoan, ImmLoan) => {}
-                        (want, cur) => {
-                            fail!("TLS slot cannot be borrowed as %s because \
-                                   it is already borrowed as %s",
-                                  want.describe(), cur.describe());
-                        }
-                    }
+                Some((_, ref data, ref mut loans)) => {
+                    *loans = *loans + 1;
                     // data was created with `~~T as ~LocalData`, so we extract
                     // pointer part of the trait, (as ~~T), and then use
-                    // compiler coercions to achieve a '&' pointer.
+                    // compiler coercions to achieve a '&' pointer
                     match *cast::transmute::<&TLSValue, &(uint, ~~T)>(data) {
                         (_vtable, ref box) => {
                             let value: &T = **box;
@@ -289,11 +238,9 @@ unsafe fn local_get_with<T: 'static, U>(handle: Handle,
             // 'f' returned because `f` could have appended more TLS items which
             // in turn relocated the vector. Hence we do another lookup here to
             // fixup the loans.
-            if return_loan {
-                match map[i] {
-                    Some((_, _, ref mut loan)) => { *loan = NoLoan; }
-                    None => { libc::abort(); }
-                }
+            match map[i] {
+                Some((_, _, ref mut loans)) => { *loans = *loans - 1; }
+                None => { libc::abort(); }
             }
             return ret;
         }
@@ -322,10 +269,9 @@ pub unsafe fn local_set<T: 'static>(handle: Handle,
         // First see if the map contains this key already
         let curspot = map.iter().position(|entry| {
             match *entry {
-                Some((ekey, _, loan)) if key == ekey => {
-                    if loan != NoLoan {
-                        fail!("TLS value cannot be overwritten because it is
-                               already borrowed as %s", loan.describe())
+                Some((ekey, _, loans)) if key == ekey => {
+                    if loans != 0 {
+                        fail!("TLS value has been loaned via get already");
                     }
                     true
                 }
@@ -340,7 +286,7 @@ pub unsafe fn local_set<T: 'static>(handle: Handle,
     }
 
     match insertion_position(map, keyval) {
-        Some(i) => { map[i] = Some((keyval, data, NoLoan)); }
-        None => { map.push(Some((keyval, data, NoLoan))); }
+        Some(i) => { map[i] = Some((keyval, data, 0)); }
+        None => { map.push(Some((keyval, data, 0))); }
     }
 }