Simplify handling of unimplemented stuff

src/abi/mod.rs

@@ -173,7 +173,7 @@ pub fn get_function_name_and_sig<'tcx>(
     let fn_sig =
         tcx.normalize_erasing_late_bound_regions(ParamEnv::reveal_all(), &fn_sig_for_fn_abi(tcx, inst));
     if fn_sig.c_variadic && !support_vararg {
-        unimpl!("Variadic function definitions are not yet supported");
+        unimpl_fatal!(tcx, tcx.def_span(inst.def_id()), "Variadic function definitions are not yet supported");
     }
     let sig = clif_sig_from_fn_sig(tcx, triple, fn_sig, false, inst.def.requires_caller_location(tcx));
     (tcx.symbol_name(inst).name.as_str().to_string(), sig)
@@ -622,7 +622,7 @@ fn codegen_call_inner<'tcx>(
     // FIXME find a cleaner way to support varargs
     if fn_sig.c_variadic {
         if fn_sig.abi != Abi::C {
-            unimpl!("Variadic call for non-C abi {:?}", fn_sig.abi);
+            unimpl_fatal!(fx.tcx, span, "Variadic call for non-C abi {:?}", fn_sig.abi);
         }
         let sig_ref = fx.bcx.func.dfg.call_signature(call_inst).unwrap();
         let abi_params = call_args
@@ -631,7 +631,7 @@ fn codegen_call_inner<'tcx>(
                 let ty = fx.bcx.func.dfg.value_type(arg);
                 if !ty.is_int() {
                     // FIXME set %al to upperbound on float args once floats are supported
-                    unimpl!("Non int ty {:?} for variadic call", ty);
+                    unimpl_fatal!(fx.tcx, span, "Non int ty {:?} for variadic call", ty);
                 }
                 AbiParam::new(ty)
             })

src/base.rs

@@ -700,7 +700,7 @@ fn trans_stmt<'tcx>(
 
                     crate::trap::trap_unimplemented(fx, "_xgetbv arch intrinsic is not supported");
                 }
-                _ => unimpl!("Inline assembly is not supported"),
+                _ => unimpl_fatal!(fx.tcx, stmt.source_info.span, "Inline assembly is not supported"),
             }
         }
     }

src/driver/mod.rs

@@ -52,10 +52,8 @@ fn codegen_mono_items<'tcx>(
     });
 
     for (mono_item, (linkage, visibility)) in mono_items {
-        crate::unimpl::try_unimpl(tcx, || {
-            let linkage = crate::linkage::get_clif_linkage(mono_item, linkage, visibility);
-            trans_mono_item(&mut cx, mono_item, linkage);
-        });
+        let linkage = crate::linkage::get_clif_linkage(mono_item, linkage, visibility);
+        trans_mono_item(&mut cx, mono_item, linkage);
     }
 
     tcx.sess.time("finalize CodegenCx", || cx.finalize());

src/intrinsics/mod.rs

@@ -425,7 +425,7 @@ pub fn codegen_intrinsic_call<'tcx>(
     intrinsic_match! {
         fx, intrinsic, substs, args,
         _ => {
-            unimpl!("unsupported intrinsic {}", intrinsic)
+            unimpl_fatal!(fx.tcx, span, "unsupported intrinsic {}", intrinsic);
         };
 
         assume, (c _a) {};

src/lib.rs

@@ -57,7 +57,6 @@ mod pointer;
 mod pretty_clif;
 mod target_features_whitelist;
 mod trap;
-mod unimpl;
 mod unsize;
 mod value_and_place;
 mod vtable;
@@ -115,7 +114,6 @@ mod prelude {
     pub use crate::debuginfo::{DebugContext, FunctionDebugContext};
     pub use crate::pointer::Pointer;
     pub use crate::trap::*;
-    pub use crate::unimpl::unimpl;
     pub use crate::value_and_place::{CPlace, CPlaceInner, CValue};
     pub use crate::CodegenCx;
 
@@ -127,6 +125,10 @@ mod prelude {
             }
         }
     }
+
+    pub macro unimpl_fatal($tcx:expr, $span:expr, $($tt:tt)*) {
+        $tcx.sess.span_fatal($span, &format!($($tt)*));
+    }
 }
 
 pub struct CodegenCx<'clif, 'tcx, B: Backend + 'static> {

src/unimpl.rs

@@ -1,28 +0,0 @@
-//! The unimpl! macro is defined here. It is used to generate
-//! a non-fatal error on not yet implemented things.
-
-use rustc::ty::TyCtxt;
-
-// Just public, because of the unimpl macro
-#[doc(hidden)]
-pub struct NonFatal(pub String);
-
-/// Use when something in the current function is unimplemented.
-///
-/// This will emit an error and continue codegen at a different function.
-pub macro unimpl($($tt:tt)*) {
-    panic!(NonFatal(format!($($tt)*)));
-}
-
-pub fn try_unimpl(tcx: TyCtxt, f: impl FnOnce()) {
-    let res = ::std::panic::catch_unwind(::std::panic::AssertUnwindSafe(|| f()));
-
-    if let Err(err) = res {
-        match err.downcast::<NonFatal>() {
-            Ok(non_fatal) => {
-                tcx.sess.err(&non_fatal.0);
-            }
-            Err(err) => ::std::panic::resume_unwind(err),
-        }
-    }
-}