Fix @alexcrichton comments

Author: PlasmaPower

src/libstd/io/stdio.rs

@@ -17,7 +17,7 @@ use io::{self, Initializer, BufReader, LineWriter};
 use sync::{Arc, Mutex, MutexGuard};
 use sys::stdio;
 use sys_common::remutex::{ReentrantMutex, ReentrantMutexGuard};
-use thread::LocalKey;
+use thread::{LocalKey, LocalKeyState};
 
 /// Stdout used by print! and println! macros
 thread_local! {
@@ -674,14 +674,20 @@ fn print_to<T>(args: fmt::Arguments,
                local_s: &'static LocalKey<RefCell<Option<Box<Write+Send>>>>,
                global_s: fn() -> T,
                label: &str) where T: Write {
-    let result = local_s.try_with(|s| {
-        if let Ok(mut borrowed) = s.try_borrow_mut() {
-            if let Some(w) = borrowed.as_mut() {
-                return w.write_fmt(args);
-            }
+    let result = match local_s.state() {
+        LocalKeyState::Uninitialized |
+        LocalKeyState::Destroyed => global_s().write_fmt(args),
+        LocalKeyState::Valid => {
+            local_s.with(|s| {
+                if let Ok(mut borrowed) = s.try_borrow_mut() {
+                    if let Some(w) = borrowed.as_mut() {
+                        return w.write_fmt(args);
+                    }
+                }
+                global_s().write_fmt(args)
+            })
         }
-        global_s().write_fmt(args)
-    }).unwrap_or_else(|_| global_s().write_fmt(args));
+    };
     if let Err(e) = result {
         panic!("failed printing to {}: {}", label, e);
     }

src/libstd/thread/mod.rs

@@ -159,7 +159,7 @@ use time::Duration;
 #[macro_use] mod local;
 
 #[stable(feature = "rust1", since = "1.0.0")]
-pub use self::local::{LocalKey, LocalKeyState};
+pub use self::local::{LocalKey, LocalKeyState, AccessError};
 
 // The types used by the thread_local! macro to access TLS keys. Note that there
 // are two types, the "OS" type and the "fast" type. The OS thread local key

src/test/run-pass/tls-try-with.rs

@@ -14,13 +14,16 @@
 
 use std::thread;
 
+static mut DROP_RUN: bool = false;
+
 struct Foo;
 
 thread_local!(static FOO: Foo = Foo {});
 
 impl Drop for Foo {
     fn drop(&mut self) {
         assert!(FOO.try_with(|_| panic!("`try_with` closure run")).is_err());
+        unsafe { DROP_RUN = true; }
     }
 }
 
@@ -30,4 +33,5 @@ fn main() {
             132
         }).expect("`try_with` failed"), 132);
     }).join().unwrap();
+    assert!(unsafe { DROP_RUN });
 }