Unverified Commit 94caeadf authored by Benjamin Woodruff's avatar Benjamin Woodruff Committed by GitHub

Turbopack: chore: Remove mopa dependency in turbo-tasks (2nd attempt) (#85286)

This is a recreation of my _very first_ Turbopack PR in https://github.com/vercel/turborepo/pull/7206 (reverted in https://github.com/vercel/turborepo/pull/7573)

Instead of using a trait upcast helper method, this uses the recently-stabilized trait upcasting compiler feature.

I used claude to help write this, but cleaned it up by hand.
parent 24479b70
...@@ -4105,12 +4105,6 @@ dependencies = [ ...@@ -4105,12 +4105,6 @@ dependencies = [
"swc_ecma_visit", "swc_ecma_visit",
] ]
[[package]]
name = "mopa"
version = "0.2.2"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "a785740271256c230f57462d3b83e52f998433a7062fc18f96d5999474a9f915"
[[package]] [[package]]
name = "more-asserts" name = "more-asserts"
version = "0.2.2" version = "0.2.2"
...@@ -9184,7 +9178,6 @@ dependencies = [ ...@@ -9184,7 +9178,6 @@ dependencies = [
"futures", "futures",
"indexmap 2.9.0", "indexmap 2.9.0",
"inventory", "inventory",
"mopa",
"once_cell", "once_cell",
"parking_lot", "parking_lot",
"pin-project-lite", "pin-project-lite",
......
...@@ -31,7 +31,6 @@ erased-serde = { workspace = true } ...@@ -31,7 +31,6 @@ erased-serde = { workspace = true }
event-listener = "5.4.0" event-listener = "5.4.0"
futures = { workspace = true } futures = { workspace = true }
indexmap = { workspace = true, features = ["serde"] } indexmap = { workspace = true, features = ["serde"] }
mopa = "0.2.0"
once_cell = { workspace = true } once_cell = { workspace = true }
parking_lot = { workspace = true, features = ["serde"]} parking_lot = { workspace = true, features = ["serde"]}
pin-project-lite = { workspace = true } pin-project-lite = { workspace = true }
......
use core::fmt; use std::{any::Any, fmt::Debug, hash::Hash};
use std::{
any::{Any, TypeId},
fmt::Debug,
hash::Hash,
sync::Arc,
};
use serde::{Deserialize, Serialize, de::DeserializeSeed}; use serde::{Deserialize, Serialize, de::DeserializeSeed};
use turbo_dyn_eq_hash::{ use turbo_dyn_eq_hash::{
DynEq, DynHash, DynPartialEq, impl_eq_for_dyn, impl_hash_for_dyn, impl_partial_eq_for_dyn, DynEq, DynHash, impl_eq_for_dyn, impl_hash_for_dyn, impl_partial_eq_for_dyn,
}; };
use crate::trace::{TraceRawVcs, TraceRawVcsContext}; use crate::trace::TraceRawVcs;
pub trait MagicAny: mopa::Any + DynPartialEq + DynEq + DynHash + Send + Sync {
fn magic_any_arc(self: Arc<Self>) -> Arc<dyn Any + Sync + Send>;
fn magic_debug(&self, f: &mut fmt::Formatter) -> fmt::Result;
fn magic_trace_raw_vcs(&self, trace_context: &mut TraceRawVcsContext);
pub trait MagicAny: Debug + DynEq + DynHash + TraceRawVcs + Send + Sync + 'static {
#[cfg(debug_assertions)] #[cfg(debug_assertions)]
fn magic_type_name(&self) -> &'static str; fn magic_type_name(&self) -> &'static str;
} }
#[allow(clippy::transmute_ptr_to_ref)] // can't fix as it's in the macro impl<T> MagicAny for T
mod clippy { where
use mopa::mopafy; T: Debug + Eq + Hash + Send + Sync + TraceRawVcs + 'static,
{
use super::MagicAny;
mopafy!(MagicAny);
}
impl<T: Debug + Eq + Hash + Send + Sync + TraceRawVcs + 'static> MagicAny for T {
fn magic_any_arc(self: Arc<Self>) -> Arc<dyn Any + Sync + Send> {
self
}
fn magic_debug(&self, f: &mut fmt::Formatter) -> fmt::Result {
let mut d = f.debug_tuple("MagicAny");
d.field(&TypeId::of::<Self>());
#[cfg(debug_assertions)]
d.field(&std::any::type_name::<Self>());
d.field(&(self as &Self));
d.finish()
}
fn magic_trace_raw_vcs(&self, trace_context: &mut TraceRawVcsContext) {
self.trace_raw_vcs(trace_context);
}
#[cfg(debug_assertions)] #[cfg(debug_assertions)]
fn magic_type_name(&self) -> &'static str { fn magic_type_name(&self) -> &'static str {
std::any::type_name::<T>() std::any::type_name::<T>()
} }
} }
impl fmt::Debug for dyn MagicAny {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
self.magic_debug(f)
}
}
impl_partial_eq_for_dyn!(dyn MagicAny); impl_partial_eq_for_dyn!(dyn MagicAny);
impl_eq_for_dyn!(dyn MagicAny); impl_eq_for_dyn!(dyn MagicAny);
impl_hash_for_dyn!(dyn MagicAny); impl_hash_for_dyn!(dyn MagicAny);
impl TraceRawVcs for dyn MagicAny {
fn trace_raw_vcs(&self, trace_context: &mut TraceRawVcsContext) {
self.magic_trace_raw_vcs(trace_context)
}
}
impl dyn MagicAny { impl dyn MagicAny {
pub fn as_serialize<T: Debug + Eq + Hash + Serialize + Send + Sync + TraceRawVcs + 'static>( pub fn as_serialize<T: Debug + Eq + Hash + Serialize + Send + Sync + TraceRawVcs + 'static>(
&self, &self,
) -> &dyn erased_serde::Serialize { ) -> &dyn erased_serde::Serialize {
if let Some(r) = self.downcast_ref::<T>() { if let Some(r) = (self as &dyn Any).downcast_ref::<T>() {
r r
} else { } else {
#[cfg(debug_assertions)] #[cfg(debug_assertions)]
panic!( panic!(
"MagicAny::as_serializable broken: got {} but expected {}", "MagicAny::as_serializable broken: got {} but expected {}",
self.magic_type_name(), self.magic_type_name(),
std::any::type_name::<T>() std::any::type_name::<T>(),
); );
#[cfg(not(debug_assertions))] #[cfg(not(debug_assertions))]
panic!("MagicAny::as_serializable bug"); panic!("MagicAny::as_serializable bug");
......
use std::{fmt::Debug, hash::Hash, pin::Pin}; use std::{any::Any, fmt::Debug, hash::Hash, pin::Pin};
use anyhow::Result; use anyhow::Result;
use futures::Future; use futures::Future;
...@@ -105,19 +105,22 @@ fn resolve_functor_impl<T: MagicAny + TaskInput>(value: &dyn MagicAny) -> Resolv ...@@ -105,19 +105,22 @@ fn resolve_functor_impl<T: MagicAny + TaskInput>(value: &dyn MagicAny) -> Resolv
#[cfg(debug_assertions)] #[cfg(debug_assertions)]
#[inline(never)] #[inline(never)]
pub fn debug_downcast_args_error_msg(expected: &str, actual: &dyn MagicAny) -> String { pub fn debug_downcast_args_error_msg(expected: &str, actual: &str) -> String {
format!( format!("Invalid argument type, expected {expected} got {actual}")
"Invalid argument type, expected {expected} got {}",
(*actual).magic_type_name()
)
} }
pub fn downcast_args_owned<T: MagicAny>(args: Box<dyn MagicAny>) -> Box<T> { pub fn downcast_args_owned<T: MagicAny>(args: Box<dyn MagicAny>) -> Box<T> {
#[allow(unused_variables)] #[cfg(debug_assertions)]
args.downcast::<T>() let args_type_name = args.magic_type_name();
.map_err(|args| {
(args as Box<dyn Any>)
.downcast::<T>()
.map_err(|_args| {
#[cfg(debug_assertions)] #[cfg(debug_assertions)]
return debug_downcast_args_error_msg(std::any::type_name::<T>(), &*args); return anyhow::anyhow!(debug_downcast_args_error_msg(
std::any::type_name::<T>(),
args_type_name,
));
#[cfg(not(debug_assertions))] #[cfg(not(debug_assertions))]
return anyhow::anyhow!("Invalid argument type"); return anyhow::anyhow!("Invalid argument type");
}) })
...@@ -125,12 +128,13 @@ pub fn downcast_args_owned<T: MagicAny>(args: Box<dyn MagicAny>) -> Box<T> { ...@@ -125,12 +128,13 @@ pub fn downcast_args_owned<T: MagicAny>(args: Box<dyn MagicAny>) -> Box<T> {
} }
pub fn downcast_args_ref<T: MagicAny>(args: &dyn MagicAny) -> &T { pub fn downcast_args_ref<T: MagicAny>(args: &dyn MagicAny) -> &T {
args.downcast_ref::<T>() (args as &dyn Any)
.downcast_ref::<T>()
.ok_or_else(|| { .ok_or_else(|| {
#[cfg(debug_assertions)] #[cfg(debug_assertions)]
return anyhow::anyhow!(debug_downcast_args_error_msg( return anyhow::anyhow!(debug_downcast_args_error_msg(
std::any::type_name::<T>(), std::any::type_name::<T>(),
args args.magic_type_name(),
)); ));
#[cfg(not(debug_assertions))] #[cfg(not(debug_assertions))]
return anyhow::anyhow!("Invalid argument type"); return anyhow::anyhow!("Invalid argument type");
......
...@@ -172,10 +172,13 @@ macro_rules! task_inputs_impl { ...@@ -172,10 +172,13 @@ macro_rules! task_inputs_impl {
/// gives the compiler more chances to dedupe monomorphized code across small functions with less /// gives the compiler more chances to dedupe monomorphized code across small functions with less
/// typevars. /// typevars.
fn get_args<T: MagicAny + Clone>(arg: &dyn MagicAny) -> Result<T> { fn get_args<T: MagicAny + Clone>(arg: &dyn MagicAny) -> Result<T> {
let value = arg.downcast_ref::<T>().cloned(); let value = (arg as &dyn std::any::Any).downcast_ref::<T>().cloned();
#[cfg(debug_assertions)] #[cfg(debug_assertions)]
return anyhow::Context::with_context(value, || { return anyhow::Context::with_context(value, || {
crate::native_function::debug_downcast_args_error_msg(std::any::type_name::<T>(), arg) crate::native_function::debug_downcast_args_error_msg(
std::any::type_name::<T>(),
arg.magic_type_name(),
)
}); });
#[cfg(not(debug_assertions))] #[cfg(not(debug_assertions))]
return anyhow::Context::context(value, "Invalid argument type"); return anyhow::Context::context(value, "Invalid argument type");
......
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment