proc_macro: handle proc macro panics in their proc_macro instance.

Author: eddyb

src/Cargo.lock

@@ -7,3 +7,5 @@ version = "0.0.0"
 path = "lib.rs"
 crate-type = ["dylib"]
 
+[dependencies]
+lazy_static = "1.0.0"

src/libproc_macro/Cargo.toml

@@ -22,8 +22,10 @@
 use std::cell::Cell;
 use std::fmt;
 use std::ops::Deref;
+use std::panic;
 use std::path::PathBuf;
 use std::ptr::NonNull;
+use std::thread;
 
 use self::storage::{FromConcrete, ToConcrete, Storage};
 
@@ -580,8 +582,20 @@ thread_local! {
     static CURRENT_FRONTEND: Cell<Option<NonNull<CurrentFrontend<'static>>>> = Cell::new(None);
 }
 
-pub fn has_current_frontend() -> bool {
-    CURRENT_FRONTEND.with(|p| p.get().is_some())
+// Hide the default panic output within `proc_macro` expansions.
+// NB. frontends can't do this because they may use a different libstd.
+lazy_static! {
+    static ref DEFAULT_HOOK: Box<Fn(&panic::PanicInfo) + Sync + Send + 'static> = {
+        let hook = panic::take_hook();
+        panic::set_hook(Box::new(panic_hook));
+        hook
+    };
+}
+
+fn panic_hook(info: &panic::PanicInfo) {
+    if CURRENT_FRONTEND.with(|p| p.get().is_none()) {
+        (*DEFAULT_HOOK)(info)
+    }
 }
 
 fn with_current_frontend<F, R>(f: F) -> R
@@ -604,6 +618,9 @@ fn set_current_frontend<F, R>(frontend: &CurrentFrontend, f: F) -> R
         }
     }
 
+    // Ensure panic output hiding is set up.
+    ::lazy_static::initialize(&DEFAULT_HOOK);
+
     CURRENT_FRONTEND.with(|p| {
         let _reset = Reset { prev: p.get() };
         p.set(NonNull::new(frontend as *const _ as *mut _));
@@ -657,8 +674,9 @@ fn erase_concrete_frontend<F, G, R>(ng: extern "C" fn() -> generation::Generatio
 pub struct Expand1 {
     next_generation: extern "C" fn() -> generation::Generation,
     data: *const (),
+    // FIXME(eddyb) achieve ABI compatibility for the `thread::Result` type.
     run: unsafe extern "C" fn(*const (), &&CurrentFrontend, TokenStream)
-                              -> TokenStream,
+                              -> thread::Result<TokenStream>,
 }
 
 impl !Send for Expand1 {}
@@ -670,12 +688,15 @@ impl Expand1 {
     {
         unsafe extern "C" fn run<F>(f: *const (),
                                     frontend: &&CurrentFrontend,
-                                    input: TokenStream) -> TokenStream
+                                    input: TokenStream)
+                                    -> thread::Result<TokenStream>
             where F: Fn(::TokenStream) -> ::TokenStream
         {
             let f = &*(f as *const F);
             set_current_frontend(*frontend, || {
-                f(::TokenStream(input)).0
+                panic::catch_unwind(panic::AssertUnwindSafe(|| {
+                    f(::TokenStream(input)).0
+                }))
             })
         }
         Expand1 {
@@ -685,15 +706,16 @@ impl Expand1 {
         }
     }
 
-    pub fn run<F>(&self, frontend: F, input: F::TokenStream) -> F::TokenStream
+    pub fn run<F>(&self, frontend: F, input: F::TokenStream)
+                  -> thread::Result<F::TokenStream>
         where F: FrontendInterface<TokenNode = TokenNode<F>>
     {
         erase_concrete_frontend(self.next_generation, frontend, |frontend, storage| {
             let input = storage.from_concrete(input);
             let output = unsafe {
                 (self.run)(self.data, &frontend, input)
             };
-            storage.to_concrete(output)
+            output.map(|output| storage.to_concrete(output))
         })
     }
 }
@@ -705,8 +727,9 @@ impl Expand1 {
 pub struct Expand2 {
     next_generation: extern "C" fn() -> generation::Generation,
     data: *const (),
+    // FIXME(eddyb) achieve ABI compatibility for the `thread::Result` type.
     run: unsafe extern "C" fn(*const (), &&CurrentFrontend, TokenStream, TokenStream)
-                              -> TokenStream,
+                              -> thread::Result<TokenStream>,
 }
 
 impl !Send for Expand2 {}
@@ -719,12 +742,15 @@ impl Expand2 {
         unsafe extern "C" fn run<F>(f: *const (),
                                     frontend: &&CurrentFrontend,
                                     input: TokenStream,
-                                    input2: TokenStream) -> TokenStream
+                                    input2: TokenStream)
+                                    -> thread::Result<TokenStream>
             where F: Fn(::TokenStream, ::TokenStream) -> ::TokenStream
         {
             let f = &*(f as *const F);
             set_current_frontend(*frontend, || {
-                f(::TokenStream(input), ::TokenStream(input2)).0
+                panic::catch_unwind(panic::AssertUnwindSafe(|| {
+                    f(::TokenStream(input), ::TokenStream(input2)).0
+                }))
             })
         }
         Expand2 {
@@ -735,7 +761,7 @@ impl Expand2 {
     }
 
     pub fn run<F>(&self, frontend: F, input: F::TokenStream, input2: F::TokenStream)
-                  -> F::TokenStream
+                  -> thread::Result<F::TokenStream>
         where F: FrontendInterface<TokenNode = TokenNode<F>>
     {
         erase_concrete_frontend(self.next_generation, frontend, |frontend, storage| {
@@ -744,7 +770,7 @@ impl Expand2 {
             let output = unsafe {
                 (self.run)(self.data, &frontend, input, input2)
             };
-            storage.to_concrete(output)
+            output.map(|output| storage.to_concrete(output))
         })
     }
 }

src/libproc_macro/bridge.rs

@@ -42,6 +42,9 @@
 #![feature(box_into_raw_non_null)]
 #![feature(nonnull_cast)]
 
+#[macro_use]
+extern crate lazy_static;
+
 #[unstable(feature = "proc_macro_internals", issue = "27812")]
 #[doc(hidden)]
 pub mod bridge;

src/libproc_macro/lib.rs

@@ -24,7 +24,6 @@ use std::sync::mpsc::{Sender};
 use syntax_pos::{SpanData};
 use ty::maps::{QueryMsg};
 use dep_graph::{DepNode};
-use proc_macro;
 use lazy_static;
 use session::Session;
 
@@ -47,9 +46,7 @@ lazy_static! {
 }
 
 fn panic_hook(info: &panic::PanicInfo) {
-    if !proc_macro::bridge::has_current_frontend() {
-        (*DEFAULT_HOOK)(info)
-    }
+    (*DEFAULT_HOOK)(info)
 }
 
 pub fn install_panic_hook() {

src/librustc/util/common.rs

@@ -8,8 +8,6 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-use std::panic;
-
 use errors::FatalError;
 use syntax::ast::{self, ItemKind, Attribute, Mac};
 use syntax::attr::{mark_used, mark_known};
@@ -79,11 +77,8 @@ impl MultiItemModifier for ProcMacroDerive {
         let item = ecx.resolver.eliminate_crate_var(item.clone());
         let token = Token::interpolated(token::NtItem(item));
         let input = tokenstream::TokenTree::Token(DUMMY_SP, token).into();
-        let res = panic::catch_unwind(panic::AssertUnwindSafe(|| {
-            self.inner.run(::proc_macro_impl::Frontend::new(ecx), input)
-        }));
 
-        let stream = match res {
+        let stream = match self.inner.run(::proc_macro_impl::Frontend::new(ecx), input) {
             Ok(stream) => stream,
             Err(e) => {
                 let msg = "proc-macro derive panicked";

src/libsyntax_ext/deriving/custom.rs

@@ -8,7 +8,6 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-use std::panic;
 use std::path::PathBuf;
 
 use errors::{Diagnostic, DiagnosticBuilder, FatalError, Level};
@@ -36,11 +35,7 @@ impl base::AttrProcMacro for AttrProcMacro {
                    annotation: TokenStream,
                    annotated: TokenStream)
                    -> TokenStream {
-        let res = panic::catch_unwind(panic::AssertUnwindSafe(|| {
-            self.inner.run(Frontend::new(ecx), annotation, annotated)
-        }));
-
-        match res {
+        match self.inner.run(Frontend::new(ecx), annotation, annotated) {
             Ok(stream) => stream,
             Err(e) => {
                 let msg = "custom attribute panicked";
@@ -69,11 +64,7 @@ impl ProcMacro for BangProcMacro {
                    span: Span,
                    input: TokenStream)
                    -> TokenStream {
-        let res = panic::catch_unwind(panic::AssertUnwindSafe(|| {
-            self.inner.run(Frontend::new(ecx), input)
-        }));
-
-        match res {
+        match self.inner.run(Frontend::new(ecx), input) {
             Ok(stream) => stream,
             Err(e) => {
                 let msg = "proc macro panicked";
@@ -105,7 +96,7 @@ impl ProcMacro for Quoter {
         info.callee.allow_internal_unstable = true;
         cx.current_expansion.mark.set_expn_info(info);
 
-        expand_quoter.run(Frontend::new(cx), stream)
+        expand_quoter.run(Frontend::new(cx), stream).unwrap()
     }
 }