Remove logfile support from unimpl.rs

I haven't used it in months

Author: bjorn3

src/base.rs

@@ -53,10 +53,8 @@ pub fn trans_fn<'clif, 'tcx, B: Backend + 'static>(
         source_info_set: indexmap::IndexSet::new(),
     };
 
-    with_unimpl_span(fx.mir.span, || {
-        crate::abi::codegen_fn_prelude(&mut fx, start_ebb);
-        codegen_fn_content(&mut fx);
-    });
+    crate::abi::codegen_fn_prelude(&mut fx, start_ebb);
+    codegen_fn_content(&mut fx);
 
     // Recover all necessary data from fx, before accessing func will prevent future access to it.
     let instance = fx.instance;
@@ -500,7 +498,7 @@ fn trans_stmt<'tcx>(
                             to.write_cvalue(fx, operand);
                         }
                     }
-                    _ => unimpl!("shouldn't exist at trans {:?}", to_place_and_rval.1),
+                    _ => unreachable!("shouldn't exist at trans {:?}", to_place_and_rval.1),
                 },
             }
         }

src/driver.rs

@@ -1,6 +1,5 @@
 use std::any::Any;
 use std::ffi::CString;
-use std::fs::File;
 use std::os::raw::{c_char, c_int};
 
 use rustc::middle::cstore::EncodedMetadata;
@@ -20,27 +19,21 @@ pub fn codegen_crate(
 ) -> Box<dyn Any> {
     tcx.sess.abort_if_errors();
 
-    let mut log = if cfg!(debug_assertions) {
-        Some(File::create(concat!(env!("CARGO_MANIFEST_DIR"), "/target/out/log.txt")).unwrap())
-    } else {
-        None
-    };
-
     if std::env::var("SHOULD_RUN").is_ok()
         && tcx.sess.crate_types.get().contains(&CrateType::Executable)
     {
         #[cfg(not(target_arch = "wasm32"))]
-        let _: ! = run_jit(tcx, &mut log);
+        let _: ! = run_jit(tcx);
 
         #[cfg(target_arch = "wasm32")]
         panic!("jit not supported on wasm");
     }
 
-    run_aot(tcx, metadata, need_metadata_module, &mut log)
+    run_aot(tcx, metadata, need_metadata_module)
 }
 
 #[cfg(not(target_arch = "wasm32"))]
-fn run_jit(tcx: TyCtxt<'_>, log: &mut Option<File>) -> ! {
+fn run_jit(tcx: TyCtxt<'_>) -> ! {
     use cranelift_simplejit::{SimpleJITBackend, SimpleJITBuilder};
 
     let imported_symbols = load_imported_symbols_for_jit(tcx);
@@ -67,7 +60,7 @@ fn run_jit(tcx: TyCtxt<'_>, log: &mut Option<File>) -> ! {
         .declare_function("main", Linkage::Import, &sig)
         .unwrap();
 
-    codegen_cgus(tcx, &mut jit_module, &mut None, log);
+    codegen_cgus(tcx, &mut jit_module, &mut None);
     crate::allocator::codegen(tcx, &mut jit_module);
     jit_module.finalize_definitions();
 
@@ -152,7 +145,6 @@ fn run_aot(
     tcx: TyCtxt<'_>,
     metadata: EncodedMetadata,
     need_metadata_module: bool,
-    log: &mut Option<File>,
 ) -> Box<CodegenResults> {
     let new_module = |name: String| {
         let module: Module<FaerieBackend> = Module::new(
@@ -207,7 +199,7 @@ fn run_aot(
         None
     };
 
-    codegen_cgus(tcx, &mut faerie_module, &mut debug, log);
+    codegen_cgus(tcx, &mut faerie_module, &mut debug);
 
     tcx.sess.abort_if_errors();
 
@@ -285,7 +277,6 @@ fn codegen_cgus<'tcx>(
     tcx: TyCtxt<'tcx>,
     module: &mut Module<impl Backend + 'static>,
     debug: &mut Option<DebugContext<'tcx>>,
-    log: &mut Option<File>,
 ) {
     let (_, cgus) = tcx.collect_and_partition_mono_items(LOCAL_CRATE);
     let mono_items = cgus
@@ -294,7 +285,7 @@ fn codegen_cgus<'tcx>(
         .flatten()
         .collect::<FxHashMap<_, (_, _)>>();
 
-    codegen_mono_items(tcx, module, debug.as_mut(), log, mono_items);
+    codegen_mono_items(tcx, module, debug.as_mut(), mono_items);
 
     crate::main_shim::maybe_create_entry_wrapper(tcx, module);
 }
@@ -303,7 +294,6 @@ fn codegen_mono_items<'tcx>(
     tcx: TyCtxt<'tcx>,
     module: &mut Module<impl Backend + 'static>,
     debug_context: Option<&mut DebugContext<'tcx>>,
-    log: &mut Option<File>,
     mono_items: FxHashMap<MonoItem<'tcx>, (RLinkage, Visibility)>,
 ) {
     let mut cx = CodegenCx::new(tcx, module, debug_context);
@@ -321,7 +311,7 @@ fn codegen_mono_items<'tcx>(
         }
 
         for (mono_item, (linkage, visibility)) in mono_items {
-            crate::unimpl::try_unimpl(tcx, log, || {
+            crate::unimpl::try_unimpl(tcx, mono_item.to_string(tcx, true), || {
                 let linkage = crate::linkage::get_clif_linkage(mono_item, linkage, visibility);
                 trans_mono_item(&mut cx, mono_item, linkage);
             });

src/lib.rs

@@ -105,7 +105,7 @@ mod prelude {
     pub use crate::common::*;
     pub use crate::debuginfo::{DebugContext, FunctionDebugContext};
     pub use crate::trap::*;
-    pub use crate::unimpl::{unimpl, with_unimpl_span};
+    pub use crate::unimpl::unimpl;
     pub use crate::value_and_place::{CPlace, CPlaceInner, CValue};
     pub use crate::{Caches, CodegenCx};
 

src/unimpl.rs

@@ -2,15 +2,11 @@
 //! a non-fatal error on not yet implemented things.
 
 use std::cell::RefCell;
-use std::fs::File;
-use std::io::Write;
-
-use syntax::source_map::Span;
 
 use rustc::ty::TyCtxt;
 
 thread_local! {
-    static SPAN_STACK: RefCell<Vec<Span>> = RefCell::new(vec![]);
+    static CURRENT_MSG: RefCell<String> = RefCell::new(String::new());
 }
 
 // Just public, because of the unimpl macro
@@ -24,35 +20,21 @@ pub macro unimpl($($tt:tt)*) {
     panic!(NonFatal(format!($($tt)*)));
 }
 
-pub fn try_unimpl(tcx: TyCtxt, log: &mut Option<File>, f: impl FnOnce()) {
-    let res = ::std::panic::catch_unwind(::std::panic::AssertUnwindSafe(|| f()));
+pub fn try_unimpl(tcx: TyCtxt, msg: String, f: impl FnOnce()) {
+    CURRENT_MSG.with(|current_msg| {
+        let old = std::mem::replace(&mut *current_msg.borrow_mut(), msg);
+
+        let res = ::std::panic::catch_unwind(::std::panic::AssertUnwindSafe(|| f()));
 
-    if let Err(err) = res {
-        SPAN_STACK.with(|span_stack| {
+        if let Err(err) = res {
             match err.downcast::<NonFatal>() {
                 Ok(non_fatal) => {
-                    if cfg!(debug_assertions) {
-                        writeln!(
-                            log.as_mut().unwrap(),
-                            "{} at {:?}",
-                            &non_fatal.0,
-                            span_stack.borrow()
-                        )
-                        .unwrap();
-                    }
-                    tcx.sess.err(&non_fatal.0)
+                    tcx.sess.err(&format!("at {}: {}", current_msg.borrow(), non_fatal.0));
                 }
                 Err(err) => ::std::panic::resume_unwind(err),
             }
-            span_stack.borrow_mut().clear();
-        });
-    }
-}
+        }
 
-pub fn with_unimpl_span(span: Span, f: impl FnOnce()) {
-    SPAN_STACK.with(|span_stack| {
-        span_stack.borrow_mut().push(span);
-        f();
-        span_stack.borrow_mut().pop();
+        *current_msg.borrow_mut() = old;
     });
 }

test.sh

@@ -100,5 +100,3 @@ hyperfine --runs ${COMPILE_RUNS:-100} "$COMPILE_MOD_BENCH_INLINE" "$COMPILE_MOD_
 echo
 echo "[BENCH RUN] mod_bench"
 hyperfine --runs ${RUN_RUNS:-10} ./target/out/mod_bench{,_inline} ./target/out/mod_bench_llvm_*
-
-cat target/out/log.txt | sort | uniq -c