feat(solc): add scoped reporter (#1000)

* feat(solc): add scoped reporter

* fix: race in tests
This commit is contained in:
Matthias Seitz 2022-03-09 21:00:16 +01:00 committed by GitHub
parent 0c42c23746
commit 1ac0b49ac3
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
1 changed files with 217 additions and 16 deletions

View File

@ -1,17 +1,52 @@
//! Subscribe to events in the compiler pipeline
//!
//! The _reporter_ is the component of the [`Project::compile()`] pipeline which is responsible
//! for reporting on specific steps in the process.
//!
//! By default, the current reporter is a noop that does
//! nothing.
//!
//! To use another report implementation, it must be set as the current reporter.
//! There are two methods for doing so: [`with_scoped`] and
//! [`set_global`]. `with_scoped` sets the reporter for the
//! duration of a scope, while `set_global` sets a global default report
//! for the entire process.
// https://github.com/tokio-rs/tracing/blob/master/tracing-core/src/dispatch.rs
use crate::{CompilerInput, CompilerOutput, Solc};
use semver::Version;
use std::{
any::{Any, TypeId},
cell::RefCell,
error::Error,
fmt,
path::Path,
ptr::NonNull,
sync::{
atomic::{AtomicUsize, Ordering},
atomic::{AtomicBool, AtomicUsize, Ordering},
Arc,
},
};
thread_local! {
static CURRENT_STATE: State = State {
scoped: RefCell::new(Report::none()),
};
}
static EXISTS: AtomicBool = AtomicBool::new(false);
static SCOPED_COUNT: AtomicUsize = AtomicUsize::new(0);
// tracks the state of `GLOBAL_REPORTER`
static GLOBAL_REPORTER_STATE: AtomicUsize = AtomicUsize::new(UN_SET);
const UN_SET: usize = 0;
const SETTING: usize = 1;
const SET: usize = 2;
static mut GLOBAL_REPORTER: Option<Report> = None;
/// Install this `Reporter` as the global default if one is
/// not already set.
///
@ -69,28 +104,70 @@ pub trait Reporter: 'static {
/// Invoked if the import couldn't be resolved
fn on_unresolved_import(&self, _import: &Path) {}
/// If `self` is the same type as the provided `TypeId`, returns an untyped
/// [`NonNull`] pointer to that type. Otherwise, returns `None`.
///
/// If you wish to downcast a `Reporter`, it is strongly advised to use
/// the safe API provided by [`downcast_ref`] instead.
///
/// This API is required for `downcast_raw` to be a trait method; a method
/// signature like [`downcast_ref`] (with a generic type parameter) is not
/// object-safe, and thus cannot be a trait method for `Reporter`. This
/// means that if we only exposed `downcast_ref`, `Reporter`
/// implementations could not override the downcasting behavior
///
/// # Safety
///
/// The [`downcast_ref`] method expects that the pointer returned by
/// `downcast_raw` points to a valid instance of the type
/// with the provided `TypeId`. Failure to ensure this will result in
/// undefined behaviour, so implementing `downcast_raw` is unsafe.
unsafe fn downcast_raw(&self, id: TypeId) -> Option<NonNull<()>> {
if id == TypeId::of::<Self>() {
Some(NonNull::from(self).cast())
} else {
None
}
}
}
impl dyn Reporter {
/// Returns `true` if this `Reporter` is the same type as `T`.
pub fn is<T: Any>(&self) -> bool {
self.downcast_ref::<T>().is_some()
}
/// Returns some reference to this `Reporter` value if it is of type `T`,
/// or `None` if it isn't.
pub fn downcast_ref<T: Any>(&self) -> Option<&T> {
unsafe {
let raw = self.downcast_raw(TypeId::of::<T>())?;
Some(&*(raw.cast().as_ptr()))
}
}
}
pub(crate) fn solc_spawn(solc: &Solc, version: &Version, input: &CompilerInput) {
with_global(|r| r.reporter.on_solc_spawn(solc, version, input));
get_default(|r| r.reporter.on_solc_spawn(solc, version, input));
}
pub(crate) fn solc_success(solc: &Solc, version: &Version, output: &CompilerOutput) {
with_global(|r| r.reporter.on_solc_success(solc, version, output));
get_default(|r| r.reporter.on_solc_success(solc, version, output));
}
#[allow(unused)]
pub(crate) fn solc_installation_start(version: &Version) {
with_global(|r| r.reporter.on_solc_installation_start(version));
get_default(|r| r.reporter.on_solc_installation_start(version));
}
#[allow(unused)]
pub(crate) fn solc_installation_success(version: &Version) {
with_global(|r| r.reporter.on_solc_installation_success(version));
get_default(|r| r.reporter.on_solc_installation_success(version));
}
pub(crate) fn unresolved_import(import: &Path) {
with_global(|r| r.reporter.on_unresolved_import(import));
get_default(|r| r.reporter.on_unresolved_import(import));
}
fn get_global() -> Option<&'static Report> {
@ -106,10 +183,97 @@ fn get_global() -> Option<&'static Report> {
}
}
/// Executes a closure with a reference to this thread's current [reporter].
#[inline(always)]
pub fn get_default<T, F>(mut f: F) -> T
where
F: FnMut(&Report) -> T,
{
if SCOPED_COUNT.load(Ordering::Acquire) == 0 {
// fast path if no scoped reporter has been set; use the global
// default.
return if let Some(glob) = get_global() { f(glob) } else { f(&Report::none()) }
}
get_default_scoped(f)
}
#[inline(never)]
fn get_default_scoped<T, F>(mut f: F) -> T
where
F: FnMut(&Report) -> T,
{
CURRENT_STATE
.try_with(|state| {
let scoped = state.scoped.borrow_mut();
f(&*scoped)
})
.unwrap_or_else(|_| f(&Report::none()))
}
/// Executes a closure with a reference to the `Reporter`.
pub fn with_global<T>(f: impl FnOnce(&Report) -> T) -> Option<T> {
let dispatch = get_global()?;
Some(f(dispatch))
let report = get_global()?;
Some(f(report))
}
/// Sets this reporter as the scoped reporter for the duration of a closure.
pub fn with_scoped<T>(report: &Report, f: impl FnOnce() -> T) -> T {
// When this guard is dropped, the scoped reporter will be reset to the
// prior reporter. Using this (rather than simply resetting after calling
// `f`) ensures that we always reset to the prior reporter even if `f`
// panics.
let _guard = set_scoped(report);
f()
}
/// The report state of a thread.
struct State {
/// This thread's current scoped reporter.
scoped: RefCell<Report>,
}
impl State {
/// Replaces the current scoped reporter on this thread with the provided
/// reporter.
///
/// Dropping the returned `ResetGuard` will reset the scoped reporter to
/// the previous value.
#[inline]
fn set_scoped(new_report: Report) -> ScopeGuard {
let prior = CURRENT_STATE.try_with(|state| state.scoped.replace(new_report)).ok();
EXISTS.store(true, Ordering::Release);
SCOPED_COUNT.fetch_add(1, Ordering::Release);
ScopeGuard(prior)
}
}
/// A guard that resets the current scoped reporter to the prior
/// scoped reporter when dropped.
#[derive(Debug)]
pub struct ScopeGuard(Option<Report>);
impl Drop for ScopeGuard {
#[inline]
fn drop(&mut self) {
SCOPED_COUNT.fetch_sub(1, Ordering::Release);
if let Some(report) = self.0.take() {
// Replace the reporter and then drop the old one outside
// of the thread-local context.
let prev = CURRENT_STATE.try_with(|state| state.scoped.replace(report));
drop(prev)
}
}
}
/// Sets the reporter as the scoped reporter for the duration of the lifetime
/// of the returned DefaultGuard
#[must_use = "Dropping the guard unregisters the reporter."]
pub fn set_scoped(reporter: &Report) -> ScopeGuard {
// When this guard is dropped, the scoped reporter will be reset to the
// prior default. Using this ensures that we always reset to the prior
// reporter even if the thread calling this function panics.
State::set_scoped(reporter.clone())
}
/// A no-op [`Reporter`] that does nothing.
@ -165,6 +329,7 @@ impl fmt::Display for SetGlobalReporterError {
impl Error for SetGlobalReporterError {}
/// `Report` trace data to a [`Reporter`].
#[derive(Clone)]
pub struct Report {
reporter: Arc<dyn Reporter + Send + Sync>,
}
@ -184,16 +349,20 @@ impl Report {
{
Self { reporter: Arc::new(reporter) }
}
/// Returns `true` if this `Report` forwards to a reporter of type
/// `T`.
#[inline]
pub fn is<T: Any>(&self) -> bool {
<dyn Reporter>::is::<T>(&*self.reporter)
}
}
// tracks the state of `GLOBAL_REPORTER`
static GLOBAL_REPORTER_STATE: AtomicUsize = AtomicUsize::new(UN_SET);
const UN_SET: usize = 0;
const SETTING: usize = 1;
const SET: usize = 2;
static mut GLOBAL_REPORTER: Option<Report> = None;
impl fmt::Debug for Report {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
f.pad("Report(...)")
}
}
/// Sets this report as the global default for the duration of the entire program.
///
@ -216,3 +385,35 @@ fn set_global_reporter(report: Report) -> Result<(), SetGlobalReporterError> {
Err(SetGlobalReporterError { _priv: () })
}
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn scoped_reporter_works() {
struct TestReporter;
impl Reporter for TestReporter {}
with_scoped(&Report::new(TestReporter), || {
get_default(|reporter| assert!(reporter.is::<TestReporter>()))
});
}
#[test]
fn global_and_scoped_reporter_works() {
get_default(|reporter| {
assert!(reporter.is::<NoReporter>());
});
set_global_reporter(Report::new(BasicStdoutReporter::default())).unwrap();
struct TestReporter;
impl Reporter for TestReporter {}
with_scoped(&Report::new(TestReporter), || {
get_default(|reporter| assert!(reporter.is::<TestReporter>()))
});
get_default(|reporter| assert!(reporter.is::<BasicStdoutReporter>()))
}
}