use std::cell::RefCell;
use std::rc::Rc;
type Handler = Rc<dyn Fn(&str)>;
thread_local! {
static WARNING_HANDLER: RefCell<Option<Handler>> = const { RefCell::new(None) };
}
pub(crate) fn console_warn(message: &str) {
let handler = WARNING_HANDLER.with(|h| h.borrow().clone());
match handler {
Some(handler) => handler(message),
None => eprintln!("lexical: {message}"),
}
}
#[cfg_attr(not(any(feature = "code", feature = "selection")), allow(dead_code))]
pub(crate) fn warn_only_once(message: &'static str) {
thread_local! {
static WARNED: RefCell<Vec<&'static str>> = const { RefCell::new(Vec::new()) };
}
let first = WARNED.with(|w| {
let mut w = w.borrow_mut();
let first = !w.contains(&message);
if first {
w.push(message);
}
first
});
if first {
console_warn(message);
}
}
pub fn with_warning_handler<R>(handler: impl Fn(&str) + 'static, f: impl FnOnce() -> R) -> R {
struct Restore(Option<Handler>);
impl Drop for Restore {
fn drop(&mut self) {
let previous = self.0.take();
WARNING_HANDLER.with(|h| *h.borrow_mut() = previous);
}
}
let handler: Handler = Rc::new(handler);
let previous = WARNING_HANDLER.with(|h| h.borrow_mut().replace(handler));
let _restore = Restore(previous);
f()
}
#[cfg(test)]
mod tests {
use super::*;
use std::cell::RefCell;
#[test]
fn a_handler_receives_warnings_and_is_restored() {
let outer = Rc::new(RefCell::new(Vec::<String>::new()));
let inner = Rc::new(RefCell::new(Vec::<String>::new()));
let (o, i) = (outer.clone(), inner.clone());
with_warning_handler(
move |m| o.borrow_mut().push(m.to_owned()),
|| {
console_warn("one");
with_warning_handler(
move |m| i.borrow_mut().push(m.to_owned()),
|| {
console_warn("two");
},
);
console_warn("three");
},
);
assert_eq!(*outer.borrow(), ["one", "three"]);
assert_eq!(*inner.borrow(), ["two"]);
}
}