From 9a8d6b8bb5dd7dd2d378849f0c2fa586e3a5b48b Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?John=20K=C3=A5re=20Alsaker?= Date: Sun, 21 Jan 2018 12:47:58 +0100 Subject: [PATCH] Do not capture stderr in the compiler. Instead just panic silently for fatal errors --- src/librustc/hir/lowering.rs | 4 +- src/librustc/session/config.rs | 6 +-- src/librustc/session/mod.rs | 12 ++--- src/librustc_driver/lib.rs | 35 +++----------- src/librustc_errors/lib.rs | 16 ++++++- src/librustc_trans/back/write.rs | 4 +- src/libsyntax/ext/base.rs | 2 +- src/libsyntax/ext/expand.rs | 2 +- src/libsyntax/ext/source_util.rs | 5 +- src/libsyntax/ext/tt/macro_parser.rs | 6 +-- src/libsyntax/ext/tt/macro_rules.rs | 4 +- src/libsyntax/feature_gate.rs | 4 +- src/libsyntax/lib.rs | 2 +- src/libsyntax/parse/lexer/comments.rs | 2 +- src/libsyntax/parse/lexer/mod.rs | 67 +++++++++++++-------------- src/libsyntax/parse/mod.rs | 4 +- src/libsyntax/test.rs | 2 +- src/libsyntax_ext/deriving/custom.rs | 6 +-- src/libsyntax_ext/proc_macro_impl.rs | 4 +- 19 files changed, 90 insertions(+), 97 deletions(-) diff --git a/src/librustc/hir/lowering.rs b/src/librustc/hir/lowering.rs index e76f39a8fb100..bc7a1137d84a9 100644 --- a/src/librustc/hir/lowering.rs +++ b/src/librustc/hir/lowering.rs @@ -2837,8 +2837,8 @@ impl<'a> LoweringContext<'a> { (&None, &Some(..), Closed) => "RangeToInclusive", (&Some(..), &Some(..), Closed) => "RangeInclusive", (_, &None, Closed) => - panic!(self.diagnostic().span_fatal( - e.span, "inclusive range with no end")), + self.diagnostic().span_fatal( + e.span, "inclusive range with no end").raise(), }; let fields = diff --git a/src/librustc/session/config.rs b/src/librustc/session/config.rs index da119ba45694d..466bfa3e4e4cf 100644 --- a/src/librustc/session/config.rs +++ b/src/librustc/session/config.rs @@ -1333,7 +1333,7 @@ pub fn build_target_config(opts: &Options, sp: &Handler) -> Config { sp.struct_fatal(&format!("Error loading target specification: {}", e)) .help("Use `--print target-list` for a list of built-in targets") .emit(); - panic!(FatalError); + FatalError.raise(); } }; @@ -1341,8 +1341,8 @@ pub fn build_target_config(opts: &Options, sp: &Handler) -> Config { "16" => (ast::IntTy::I16, ast::UintTy::U16), "32" => (ast::IntTy::I32, ast::UintTy::U32), "64" => (ast::IntTy::I64, ast::UintTy::U64), - w => panic!(sp.fatal(&format!("target specification was invalid: \ - unrecognized target-pointer-width {}", w))), + w => sp.fatal(&format!("target specification was invalid: \ + unrecognized target-pointer-width {}", w)).raise(), }; Config { diff --git a/src/librustc/session/mod.rs b/src/librustc/session/mod.rs index 36f716a4a7694..be796129ed49e 100644 --- a/src/librustc/session/mod.rs +++ b/src/librustc/session/mod.rs @@ -250,7 +250,7 @@ impl Session { } pub fn span_fatal>(&self, sp: S, msg: &str) -> ! { - panic!(self.diagnostic().span_fatal(sp, msg)) + self.diagnostic().span_fatal(sp, msg).raise() } pub fn span_fatal_with_code>( &self, @@ -258,10 +258,10 @@ impl Session { msg: &str, code: DiagnosticId, ) -> ! { - panic!(self.diagnostic().span_fatal_with_code(sp, msg, code)) + self.diagnostic().span_fatal_with_code(sp, msg, code).raise() } pub fn fatal(&self, msg: &str) -> ! { - panic!(self.diagnostic().fatal(msg)) + self.diagnostic().fatal(msg).raise() } pub fn span_err_or_warn>(&self, is_warning: bool, sp: S, msg: &str) { if is_warning { @@ -919,7 +919,7 @@ pub fn build_session_(sopts: config::Options, let host = match Target::search(config::host_triple()) { Ok(t) => t, Err(e) => { - panic!(span_diagnostic.fatal(&format!("Error loading host specification: {}", e))); + span_diagnostic.fatal(&format!("Error loading host specification: {}", e)).raise(); } }; let target_cfg = config::build_target_config(&sopts, &span_diagnostic); @@ -945,7 +945,7 @@ pub fn build_session_(sopts: config::Options, let working_dir = match env::current_dir() { Ok(dir) => dir, Err(e) => { - panic!(p_s.span_diagnostic.fatal(&format!("Current directory is invalid: {}", e))) + p_s.span_diagnostic.fatal(&format!("Current directory is invalid: {}", e)).raise() } }; let working_dir = file_path_mapping.map_prefix(working_dir); @@ -1076,7 +1076,7 @@ pub fn early_error(output: config::ErrorOutputType, msg: &str) -> ! { }; let handler = errors::Handler::with_emitter(true, false, emitter); handler.emit(&MultiSpan::new(), msg, errors::Level::Fatal); - panic!(errors::FatalError); + errors::FatalError.raise(); } pub fn early_warn(output: config::ErrorOutputType, msg: &str) { diff --git a/src/librustc_driver/lib.rs b/src/librustc_driver/lib.rs index e737328b75ea6..cdb50a0ae4850 100644 --- a/src/librustc_driver/lib.rs +++ b/src/librustc_driver/lib.rs @@ -87,11 +87,11 @@ use std::env; use std::ffi::OsString; use std::io::{self, Read, Write}; use std::iter::repeat; +use std::panic; use std::path::PathBuf; use std::process::{self, Command, Stdio}; use std::rc::Rc; use std::str; -use std::sync::{Arc, Mutex}; use std::thread; use syntax::ast; @@ -168,7 +168,7 @@ pub fn run(run_compiler: F) -> isize handler.emit(&MultiSpan::new(), "aborting due to previous error(s)", errors::Level::Fatal); - exit_on_err(); + panic::resume_unwind(Box::new(errors::FatalErrorMarker)); } } } @@ -1228,27 +1228,16 @@ pub fn in_rustc_thread(f: F) -> Result> /// The diagnostic emitter yielded to the procedure should be used for reporting /// errors of the compiler. pub fn monitor(f: F) { - struct Sink(Arc>>); - impl Write for Sink { - fn write(&mut self, data: &[u8]) -> io::Result { - Write::write(&mut *self.0.lock().unwrap(), data) - } - fn flush(&mut self) -> io::Result<()> { - Ok(()) - } - } - - let data = Arc::new(Mutex::new(Vec::new())); - let err = Sink(data.clone()); - let result = in_rustc_thread(move || { - io::set_panic(Some(box err)); f() }); if let Err(value) = result { // Thread panicked without emitting a fatal diagnostic - if !value.is::() { + if !value.is::() { + // Emit a newline + eprintln!(""); + let emitter = Box::new(errors::emitter::EmitterWriter::stderr(errors::ColorConfig::Auto, None, @@ -1273,22 +1262,12 @@ pub fn monitor(f: F) { ¬e, errors::Level::Note); } - - eprintln!("{}", str::from_utf8(&data.lock().unwrap()).unwrap()); } - exit_on_err(); + panic::resume_unwind(Box::new(errors::FatalErrorMarker)); } } -fn exit_on_err() -> ! { - // Panic so the process returns a failure code, but don't pollute the - // output with some unnecessary panic messages, we've already - // printed everything that we needed to. - io::set_panic(Some(box io::sink())); - panic!(); -} - #[cfg(stage0)] pub fn diagnostics_registry() -> errors::registry::Registry { use errors::registry::Registry; diff --git a/src/librustc_errors/lib.rs b/src/librustc_errors/lib.rs index 1fb673815eea3..33948ea92b98e 100644 --- a/src/librustc_errors/lib.rs +++ b/src/librustc_errors/lib.rs @@ -19,6 +19,7 @@ #![cfg_attr(unix, feature(libc))] #![feature(conservative_impl_trait)] #![feature(i128_type)] +#![feature(optin_builtin_traits)] extern crate term; #[cfg(unix)] @@ -44,6 +45,7 @@ use std::rc::Rc; use std::{error, fmt}; use std::sync::atomic::AtomicUsize; use std::sync::atomic::Ordering::SeqCst; +use std::panic; mod diagnostic; mod diagnostic_builder; @@ -201,6 +203,18 @@ impl CodeSuggestion { #[must_use] pub struct FatalError; +pub struct FatalErrorMarker; + +// Don't implement Send on FatalError. This makes it impossible to panic!(FatalError). +// We don't want to invoke the panic handler and print a backtrace for fatal errors. +impl !Send for FatalError {} + +impl FatalError { + pub fn raise(self) -> ! { + panic::resume_unwind(Box::new(FatalErrorMarker)) + } +} + impl fmt::Display for FatalError { fn fmt(&self, f: &mut fmt::Formatter) -> Result<(), fmt::Error> { write!(f, "parser fatal error") @@ -539,7 +553,7 @@ impl Handler { } } - panic!(self.fatal(&s)); + self.fatal(&s).raise(); } pub fn emit(&self, msp: &MultiSpan, msg: &str, lvl: Level) { if lvl == Warning && !self.flags.can_emit_warnings { diff --git a/src/librustc_trans/back/write.rs b/src/librustc_trans/back/write.rs index a013af7a4600e..884d4c7d14b58 100644 --- a/src/librustc_trans/back/write.rs +++ b/src/librustc_trans/back/write.rs @@ -155,7 +155,7 @@ fn get_llvm_opt_size(optimize: config::OptLevel) -> llvm::CodeGenOptSize { pub fn create_target_machine(sess: &Session) -> TargetMachineRef { target_machine_factory(sess)().unwrap_or_else(|err| { - panic!(llvm_err(sess.diagnostic(), err)) + llvm_err(sess.diagnostic(), err).raise() }) } @@ -582,7 +582,7 @@ fn generate_lto_work(cgcx: &CodegenContext, lto::LTOMode::JustThisCrate }; let lto_modules = lto::run(cgcx, modules, mode, &mut timeline) - .unwrap_or_else(|e| panic!(e)); + .unwrap_or_else(|e| e.raise()); lto_modules.into_iter().map(|module| { let cost = module.cost(); diff --git a/src/libsyntax/ext/base.rs b/src/libsyntax/ext/base.rs index 612d8501fb2af..025aa94ce06f5 100644 --- a/src/libsyntax/ext/base.rs +++ b/src/libsyntax/ext/base.rs @@ -786,7 +786,7 @@ impl<'a> ExtCtxt<'a> { /// substitute; we never hit resolve/type-checking so the dummy /// value doesn't have to match anything) pub fn span_fatal>(&self, sp: S, msg: &str) -> ! { - panic!(self.parse_sess.span_diagnostic.span_fatal(sp, msg)); + self.parse_sess.span_diagnostic.span_fatal(sp, msg).raise(); } /// Emit `msg` attached to `sp`, without immediately stopping diff --git a/src/libsyntax/ext/expand.rs b/src/libsyntax/ext/expand.rs index 11988a8f89d70..44a073545a730 100644 --- a/src/libsyntax/ext/expand.rs +++ b/src/libsyntax/ext/expand.rs @@ -455,7 +455,7 @@ impl<'a, 'b> MacroExpander<'a, 'b> { suggested_limit)); err.emit(); self.cx.trace_macros_diag(); - panic!(FatalError); + FatalError.raise(); } Some(result) diff --git a/src/libsyntax/ext/source_util.rs b/src/libsyntax/ext/source_util.rs index 6b08448107a9f..ec4e6ced1b273 100644 --- a/src/libsyntax/ext/source_util.rs +++ b/src/libsyntax/ext/source_util.rs @@ -116,9 +116,10 @@ pub fn expand_include<'cx>(cx: &'cx mut ExtCtxt, sp: Span, tts: &[tokenstream::T while self.p.token != token::Eof { match panictry!(self.p.parse_item()) { Some(item) => ret.push(item), - None => panic!(self.p.diagnostic().span_fatal(self.p.span, + None => self.p.diagnostic().span_fatal(self.p.span, &format!("expected item, found `{}`", - self.p.this_token_to_string()))) + self.p.this_token_to_string())) + .raise() } } Some(ret) diff --git a/src/libsyntax/ext/tt/macro_parser.rs b/src/libsyntax/ext/tt/macro_parser.rs index 124477620c27f..3e3c1618fffb2 100644 --- a/src/libsyntax/ext/tt/macro_parser.rs +++ b/src/libsyntax/ext/tt/macro_parser.rs @@ -573,7 +573,7 @@ fn parse_nt<'a>(p: &mut Parser<'a>, sp: Span, name: &str) -> Nonterminal { Some(i) => token::NtItem(i), None => { p.fatal("expected an item keyword").emit(); - panic!(FatalError); + FatalError.raise(); } }, "block" => token::NtBlock(panictry!(p.parse_block())), @@ -581,7 +581,7 @@ fn parse_nt<'a>(p: &mut Parser<'a>, sp: Span, name: &str) -> Nonterminal { Some(s) => token::NtStmt(s), None => { p.fatal("expected a statement").emit(); - panic!(FatalError); + FatalError.raise(); } }, "pat" => token::NtPat(panictry!(p.parse_pat())), @@ -597,7 +597,7 @@ fn parse_nt<'a>(p: &mut Parser<'a>, sp: Span, name: &str) -> Nonterminal { let token_str = pprust::token_to_string(&p.token); p.fatal(&format!("expected ident, found {}", &token_str[..])).emit(); - panic!(FatalError) + FatalError.raise() } }, "path" => token::NtPath(panictry!(p.parse_path_common(PathStyle::Type, false))), diff --git a/src/libsyntax/ext/tt/macro_rules.rs b/src/libsyntax/ext/tt/macro_rules.rs index d86603e94e9df..9efb4faa63535 100644 --- a/src/libsyntax/ext/tt/macro_rules.rs +++ b/src/libsyntax/ext/tt/macro_rules.rs @@ -222,10 +222,10 @@ pub fn compile(sess: &ParseSess, features: &RefCell, def: &ast::Item) Success(m) => m, Failure(sp, tok) => { let s = parse_failure_msg(tok); - panic!(sess.span_diagnostic.span_fatal(sp.substitute_dummy(def.span), &s)); + sess.span_diagnostic.span_fatal(sp.substitute_dummy(def.span), &s).raise(); } Error(sp, s) => { - panic!(sess.span_diagnostic.span_fatal(sp.substitute_dummy(def.span), &s)); + sess.span_diagnostic.span_fatal(sp.substitute_dummy(def.span), &s).raise(); } }; diff --git a/src/libsyntax/feature_gate.rs b/src/libsyntax/feature_gate.rs index 5a7b53153fd61..8512e215ca765 100644 --- a/src/libsyntax/feature_gate.rs +++ b/src/libsyntax/feature_gate.rs @@ -1954,7 +1954,7 @@ impl FeatureChecker { .span_note(ca_span, "`#![feature(custom_attribute)]` declared here") .emit(); - panic!(FatalError); + FatalError.raise(); } if let (Some(span), None) = (self.copy_closures, self.clone_closures) { @@ -1963,7 +1963,7 @@ impl FeatureChecker { .span_note(span, "`#![feature(copy_closures)]` declared here") .emit(); - panic!(FatalError); + FatalError.raise(); } } } diff --git a/src/libsyntax/lib.rs b/src/libsyntax/lib.rs index d7f7ff554db4b..3b4c5da10f20b 100644 --- a/src/libsyntax/lib.rs +++ b/src/libsyntax/lib.rs @@ -54,7 +54,7 @@ macro_rules! panictry { Ok(e) => e, Err(mut e) => { e.emit(); - panic!(FatalError); + FatalError.raise() } } }) diff --git a/src/libsyntax/parse/lexer/comments.rs b/src/libsyntax/parse/lexer/comments.rs index 49362f0779921..63aa5d28ce8dc 100644 --- a/src/libsyntax/parse/lexer/comments.rs +++ b/src/libsyntax/parse/lexer/comments.rs @@ -265,7 +265,7 @@ fn read_block_comment(rdr: &mut StringReader, while level > 0 { debug!("=== block comment level {}", level); if rdr.is_eof() { - panic!(rdr.fatal("unterminated block comment")); + rdr.fatal("unterminated block comment").raise(); } if rdr.ch_is('\n') { trim_whitespace_prefix_and_push_line(&mut lines, curr_line, col); diff --git a/src/libsyntax/parse/lexer/mod.rs b/src/libsyntax/parse/lexer/mod.rs index 9828995362a35..b95c91548d00b 100644 --- a/src/libsyntax/parse/lexer/mod.rs +++ b/src/libsyntax/parse/lexer/mod.rs @@ -90,7 +90,7 @@ impl<'a> StringReader<'a> { Ok(tok) => tok, Err(_) => { self.emit_fatal_errors(); - panic!(FatalError); + FatalError.raise(); } } } @@ -191,7 +191,7 @@ impl<'a> StringReader<'a> { let mut sr = StringReader::new_raw(sess, filemap); if sr.advance_token().is_err() { sr.emit_fatal_errors(); - panic!(FatalError); + FatalError.raise(); } sr } @@ -216,7 +216,7 @@ impl<'a> StringReader<'a> { if sr.advance_token().is_err() { sr.emit_fatal_errors(); - panic!(FatalError); + FatalError.raise(); } sr } @@ -647,7 +647,7 @@ impl<'a> StringReader<'a> { "unterminated block comment" }; let last_bpos = self.pos; - panic!(self.fatal_span_(start_bpos, last_bpos, msg)); + self.fatal_span_(start_bpos, last_bpos, msg).raise(); } let n = self.ch.unwrap(); match n { @@ -808,9 +808,9 @@ impl<'a> StringReader<'a> { for _ in 0..n_digits { if self.is_eof() { let last_bpos = self.pos; - panic!(self.fatal_span_(start_bpos, - last_bpos, - "unterminated numeric character escape")); + self.fatal_span_(start_bpos, + last_bpos, + "unterminated numeric character escape").raise(); } if self.ch_is(delim) { let last_bpos = self.pos; @@ -1025,9 +1025,9 @@ impl<'a> StringReader<'a> { } }, None => { - panic!(self.fatal_span_(start_bpos, - self.pos, - "unterminated unicode escape (found EOF)")); + self.fatal_span_(start_bpos, + self.pos, + "unterminated unicode escape (found EOF)").raise(); } } self.bump(); @@ -1283,9 +1283,9 @@ impl<'a> StringReader<'a> { // lifetimes shouldn't end with a single quote // if we find one, then this is an invalid character literal if self.ch_is('\'') { - panic!(self.fatal_span_verbose( - start_with_quote, self.next_pos, - String::from("character literal may only contain one codepoint"))); + self.fatal_span_verbose(start_with_quote, self.next_pos, + String::from("character literal may only contain one codepoint")) + .raise(); } @@ -1332,9 +1332,8 @@ impl<'a> StringReader<'a> { break; } } - panic!(self.fatal_span_verbose( - start_with_quote, pos, - String::from("character literal may only contain one codepoint"))); + self.fatal_span_verbose(start_with_quote, pos, + String::from("character literal may only contain one codepoint")).raise(); } let id = if valid { @@ -1364,9 +1363,9 @@ impl<'a> StringReader<'a> { while !self.ch_is('"') { if self.is_eof() { let last_bpos = self.pos; - panic!(self.fatal_span_(start_bpos, - last_bpos, - "unterminated double quote string")); + self.fatal_span_(start_bpos, + last_bpos, + "unterminated double quote string").raise(); } let ch_start = self.pos; @@ -1399,15 +1398,15 @@ impl<'a> StringReader<'a> { if self.is_eof() { let last_bpos = self.pos; - panic!(self.fatal_span_(start_bpos, last_bpos, "unterminated raw string")); + self.fatal_span_(start_bpos, last_bpos, "unterminated raw string").raise(); } else if !self.ch_is('"') { let last_bpos = self.pos; let curr_char = self.ch.unwrap(); - panic!(self.fatal_span_char(start_bpos, - last_bpos, - "found invalid character; only `#` is allowed \ - in raw string delimitation", - curr_char)); + self.fatal_span_char(start_bpos, + last_bpos, + "found invalid character; only `#` is allowed \ + in raw string delimitation", + curr_char).raise(); } self.bump(); let content_start_bpos = self.pos; @@ -1416,7 +1415,7 @@ impl<'a> StringReader<'a> { 'outer: loop { if self.is_eof() { let last_bpos = self.pos; - panic!(self.fatal_span_(start_bpos, last_bpos, "unterminated raw string")); + self.fatal_span_(start_bpos, last_bpos, "unterminated raw string").raise(); } // if self.ch_is('"') { // content_end_bpos = self.pos; @@ -1573,9 +1572,9 @@ impl<'a> StringReader<'a> { // character before position `start` are an // ascii single quote and ascii 'b'. let pos = self.pos; - panic!(self.fatal_span_verbose(start - BytePos(2), - pos, - "unterminated byte constant".to_string())); + self.fatal_span_verbose(start - BytePos(2), + pos, + "unterminated byte constant".to_string()).raise(); } let id = if valid { @@ -1599,7 +1598,7 @@ impl<'a> StringReader<'a> { while !self.ch_is('"') { if self.is_eof() { let pos = self.pos; - panic!(self.fatal_span_(start, pos, "unterminated double quote byte string")); + self.fatal_span_(start, pos, "unterminated double quote byte string").raise(); } let ch_start = self.pos; @@ -1631,15 +1630,15 @@ impl<'a> StringReader<'a> { if self.is_eof() { let pos = self.pos; - panic!(self.fatal_span_(start_bpos, pos, "unterminated raw string")); + self.fatal_span_(start_bpos, pos, "unterminated raw string").raise(); } else if !self.ch_is('"') { let pos = self.pos; let ch = self.ch.unwrap(); - panic!(self.fatal_span_char(start_bpos, + self.fatal_span_char(start_bpos, pos, "found invalid character; only `#` is allowed in raw \ string delimitation", - ch)); + ch).raise(); } self.bump(); let content_start_bpos = self.pos; @@ -1648,7 +1647,7 @@ impl<'a> StringReader<'a> { match self.ch { None => { let pos = self.pos; - panic!(self.fatal_span_(start_bpos, pos, "unterminated raw string")) + self.fatal_span_(start_bpos, pos, "unterminated raw string").raise() } Some('"') => { content_end_bpos = self.pos; diff --git a/src/libsyntax/parse/mod.rs b/src/libsyntax/parse/mod.rs index a9b1e4aaa6006..b671f81c2a84b 100644 --- a/src/libsyntax/parse/mod.rs +++ b/src/libsyntax/parse/mod.rs @@ -212,8 +212,8 @@ fn file_to_filemap(sess: &ParseSess, path: &Path, spanopt: Option) Err(e) => { let msg = format!("couldn't read {:?}: {}", path.display(), e); match spanopt { - Some(sp) => panic!(sess.span_diagnostic.span_fatal(sp, &msg)), - None => panic!(sess.span_diagnostic.fatal(&msg)) + Some(sp) => sess.span_diagnostic.span_fatal(sp, &msg).raise(), + None => sess.span_diagnostic.fatal(&msg).raise() } } } diff --git a/src/libsyntax/test.rs b/src/libsyntax/test.rs index eff7dd57f08af..e73550d0719a4 100644 --- a/src/libsyntax/test.rs +++ b/src/libsyntax/test.rs @@ -123,7 +123,7 @@ impl<'a> fold::Folder for TestHarnessGenerator<'a> { match i.node { ast::ItemKind::Fn(_, ast::Unsafety::Unsafe, _, _, _, _) => { let diag = self.cx.span_diagnostic; - panic!(diag.span_fatal(i.span, "unsafe functions cannot be used for tests")); + diag.span_fatal(i.span, "unsafe functions cannot be used for tests").raise(); } _ => { debug!("this is a test function"); diff --git a/src/libsyntax_ext/deriving/custom.rs b/src/libsyntax_ext/deriving/custom.rs index f375847e705bc..22e78e9b426b2 100644 --- a/src/libsyntax_ext/deriving/custom.rs +++ b/src/libsyntax_ext/deriving/custom.rs @@ -92,7 +92,7 @@ impl MultiItemModifier for ProcMacroDerive { } err.emit(); - panic!(FatalError); + FatalError.raise(); } }; @@ -103,13 +103,13 @@ impl MultiItemModifier for ProcMacroDerive { // fail if there have been errors emitted Ok(_) if ecx.parse_sess.span_diagnostic.err_count() > error_count_before => { ecx.struct_span_fatal(span, msg).emit(); - panic!(FatalError); + FatalError.raise(); } Ok(new_items) => new_items.into_iter().map(Annotatable::Item).collect(), Err(_) => { // FIXME: handle this better ecx.struct_span_fatal(span, msg).emit(); - panic!(FatalError); + FatalError.raise(); } } }) diff --git a/src/libsyntax_ext/proc_macro_impl.rs b/src/libsyntax_ext/proc_macro_impl.rs index 5fcedbf50c60f..12400e363f4b0 100644 --- a/src/libsyntax_ext/proc_macro_impl.rs +++ b/src/libsyntax_ext/proc_macro_impl.rs @@ -51,7 +51,7 @@ impl base::AttrProcMacro for AttrProcMacro { } err.emit(); - panic!(FatalError); + FatalError.raise(); } } } @@ -86,7 +86,7 @@ impl base::ProcMacro for BangProcMacro { } err.emit(); - panic!(FatalError); + FatalError.raise(); } } }