Unverified Commit 7b52536c authored by Luke Sandberg's avatar Luke Sandberg Committed by GitHub

rename MagicAny (#92918)

s/MagicAny/DynTaskInputs/ essentially
parent 1464f8f1
......@@ -28,7 +28,7 @@ use tracing::{Span, trace_span};
use turbo_bincode::{TurboBincodeBuffer, new_turbo_bincode_decoder, new_turbo_bincode_encoder};
use turbo_tasks::{
CellId, FxDashMap, RawVc, ReadCellOptions, ReadCellTracking, ReadConsistency,
ReadOutputOptions, ReadTracking, SharedReference, StackMagicAny, TRANSIENT_TASK_BIT,
ReadOutputOptions, ReadTracking, SharedReference, StackDynTaskInputs, TRANSIENT_TASK_BIT,
TaskExecutionReason, TaskId, TaskPersistence, TaskPriority, TraitTypeId, TurboTasksBackendApi,
TurboTasksPanic, ValueTypeId,
backend::{
......@@ -1510,7 +1510,7 @@ impl<B: BackingStorage> TurboTasksBackendInner<B> {
&self,
native_fn: &'static NativeFunction,
this: Option<RawVc>,
arg: &mut dyn StackMagicAny,
arg: &mut dyn StackDynTaskInputs,
parent_task: Option<TaskId>,
persistence: TaskPersistence,
turbo_tasks: &dyn TurboTasksBackendApi<TurboTasksBackend<B>>,
......@@ -3449,7 +3449,7 @@ impl<B: BackingStorage> Backend for TurboTasksBackend<B> {
&self,
native_fn: &'static NativeFunction,
this: Option<RawVc>,
arg: &mut dyn StackMagicAny,
arg: &mut dyn StackDynTaskInputs,
parent_task: Option<TaskId>,
persistence: TaskPersistence,
turbo_tasks: &dyn TurboTasksBackendApi<Self>,
......
......@@ -18,7 +18,7 @@ use tracing::info_span;
#[cfg(feature = "trace_prepare_tasks")]
use tracing::trace_span;
use turbo_tasks::{
CellId, FxIndexMap, MagicAny, RawVc, TaskExecutionReason, TaskId, TaskPriority,
CellId, DynTaskInputs, FxIndexMap, RawVc, TaskExecutionReason, TaskId, TaskPriority,
TurboTasksBackendApi, TurboTasksCallApi, TypedSharedReference, backend::CachedTaskType,
macro_helpers::NativeFunction,
};
......@@ -110,7 +110,7 @@ pub trait ExecuteContext<'e>: Sized {
&mut self,
native_fn: &'static NativeFunction,
this: Option<RawVc>,
arg: &dyn MagicAny,
arg: &dyn DynTaskInputs,
) -> Option<(TaskId, Arc<CachedTaskType>)>;
}
......@@ -982,7 +982,7 @@ impl<'e, B: BackingStorage> ExecuteContext<'e> for ExecuteContextImpl<'e, B> {
&mut self,
native_fn: &'static NativeFunction,
this: Option<RawVc>,
arg: &dyn MagicAny,
arg: &dyn DynTaskInputs,
) -> Option<(TaskId, Arc<CachedTaskType>)> {
if !self.backend.should_restore() {
return None;
......
......@@ -5,7 +5,7 @@ use either::Either;
use smallvec::SmallVec;
use turbo_bincode::TurboBincodeBuffer;
use turbo_tasks::{
MagicAny, RawVc, TaskId, backend::CachedTaskType, macro_helpers::NativeFunction,
DynTaskInputs, RawVc, TaskId, backend::CachedTaskType, macro_helpers::NativeFunction,
};
use turbo_tasks_hash::Xxh3Hash64Hasher;
......@@ -52,7 +52,7 @@ pub fn compute_task_type_hash(task_type: &CachedTaskType) -> TaskTypeHash {
pub fn compute_task_type_hash_from_components(
native_fn: &'static NativeFunction,
this: Option<RawVc>,
arg: &dyn MagicAny,
arg: &dyn DynTaskInputs,
) -> TaskTypeHash {
let mut hasher = Xxh3Hash64Hasher::new();
CachedTaskType::hash_encode_components(native_fn, this, arg, &mut hasher);
......@@ -103,7 +103,7 @@ pub trait BackingStorageSealed: 'static + Send + Sync {
&self,
native_fn: &'static NativeFunction,
this: Option<RawVc>,
arg: &dyn MagicAny,
arg: &dyn DynTaskInputs,
) -> Result<SmallVec<[TaskId; 1]>>;
/// Looks up and decodes persisted data for a single task, updating the provided storage with
/// data from the database in the given category.
......@@ -174,7 +174,7 @@ where
&self,
native_fn: &'static NativeFunction,
this: Option<RawVc>,
arg: &dyn MagicAny,
arg: &dyn DynTaskInputs,
) -> Result<SmallVec<[TaskId; 1]>> {
either::for_both!(self, this_impl => this_impl.lookup_task_candidates(native_fn, this, arg))
}
......
......@@ -9,7 +9,7 @@ use anyhow::{Context, Result};
use smallvec::SmallVec;
use turbo_bincode::{new_turbo_bincode_decoder, turbo_bincode_decode, turbo_bincode_encode};
use turbo_tasks::{
MagicAny, RawVc, TaskId,
DynTaskInputs, RawVc, TaskId,
macro_helpers::NativeFunction,
panic_hooks::{PanicHookGuard, register_panic_hook},
parallel,
......@@ -302,7 +302,7 @@ impl<T: KeyValueDatabase + Send + Sync + 'static> BackingStorageSealed
&self,
native_fn: &'static NativeFunction,
this: Option<RawVc>,
arg: &dyn MagicAny,
arg: &dyn DynTaskInputs,
) -> Result<SmallVec<[TaskId; 1]>> {
let inner = &*self.inner;
if inner.database.is_empty() {
......
......@@ -452,20 +452,20 @@ impl TurboFn<'_> {
let exposed_input_types: Vec<_> = self.exposed_input_types().collect();
return Some(FilterTraitCallArgsTokens {
filter_owned: quote! {
|arg: &mut dyn turbo_tasks::StackMagicAny| {
|arg: &mut dyn turbo_tasks::StackDynTaskInputs| {
let (#(#exposed_input_idents,)*) =
turbo_tasks::macro_helpers
::downcast_stack_args_owned::<(#(#exposed_input_types,)*)>(arg);
turbo_tasks::OwnedMagicAny::new(
turbo_tasks::OwnedStackDynTaskInputs::new(
::std::boxed::Box::new((#(#inline_input_idents,)*))
)
}
},
filter_and_resolve: quote! {
|magic_any| {
|dyn_task_inputs: &dyn turbo_tasks::DynTaskInputs| {
Box::pin(async move {
let (#(#exposed_input_idents,)*) = turbo_tasks::macro_helpers
::downcast_args_ref::<(#(#exposed_input_types,)*)>(magic_any);
::downcast_args_ref::<(#(#exposed_input_types,)*)>(dyn_task_inputs);
let resolved = (#(
<_ as turbo_tasks::TaskInput>::resolve_input(
#inline_input_idents
......@@ -473,7 +473,7 @@ impl TurboFn<'_> {
)*);
Ok(
::std::boxed::Box::new(resolved)
as ::std::boxed::Box<dyn turbo_tasks::MagicAny>
as ::std::boxed::Box<dyn turbo_tasks::DynTaskInputs>
)
})
}
......@@ -558,7 +558,7 @@ impl TurboFn<'_> {
let inputs = (#(#inputs,)*);
let this = #converted_this;
let persistence = #persistence;
let mut arg = turbo_tasks::StackMagicAnySlot::new(inputs);
let mut arg = turbo_tasks::StackDynTaskInputsSlot::new(inputs);
static TRAIT_METHOD: turbo_tasks::macro_helpers::Lazy<&'static turbo_tasks::TraitMethod> =
turbo_tasks::macro_helpers::Lazy::new(|| #trait_type_ident.get(stringify!(#ident)));
<#output as turbo_tasks::task::TaskOutput>::try_from_raw_vc(
......@@ -588,7 +588,7 @@ impl TurboFn<'_> {
let this = #converted_this;
let inputs = (#(#inputs,)*);
let persistence = #persistence;
let mut arg = turbo_tasks::StackMagicAnySlot::new(inputs);
let mut arg = turbo_tasks::StackDynTaskInputsSlot::new(inputs);
<#output as turbo_tasks::task::TaskOutput>::try_from_raw_vc(
turbo_tasks::dynamic_call(
&#native_function_ident,
......@@ -606,7 +606,7 @@ impl TurboFn<'_> {
#assertions
let inputs = (#(#inputs,)*);
let persistence = #persistence;
let mut arg = turbo_tasks::StackMagicAnySlot::new(inputs);
let mut arg = turbo_tasks::StackDynTaskInputsSlot::new(inputs);
<#output as turbo_tasks::task::TaskOutput>::try_from_raw_vc(
turbo_tasks::dynamic_call(
&#native_function_ident,
......
......@@ -17,8 +17,8 @@ use rustc_hash::FxHashMap;
use smallvec::SmallVec;
use tokio::sync::mpsc::Receiver;
use turbo_tasks::{
CellId, ExecutionId, InvalidationReason, LocalTaskId, MagicAny, RawVc, ReadCellOptions,
ReadOutputOptions, StackMagicAny, TaskId, TaskPersistence, TraitTypeId, TurboTasksApi,
CellId, DynTaskInputs, ExecutionId, InvalidationReason, LocalTaskId, RawVc, ReadCellOptions,
ReadOutputOptions, StackDynTaskInputs, TaskId, TaskPersistence, TraitTypeId, TurboTasksApi,
TurboTasksCallApi,
backend::{CellContent, TaskCollectiblesMap, TypedCellContent, VerificationMode},
event::{Event, EventListener},
......@@ -48,7 +48,7 @@ impl VcStorage {
&self,
func: &'static turbo_tasks::macro_helpers::NativeFunction,
this_arg: Option<RawVc>,
arg: Box<dyn MagicAny>,
arg: Box<dyn DynTaskInputs>,
) -> RawVc {
let this = self.this.upgrade().unwrap();
let handle = tokio::runtime::Handle::current();
......@@ -97,7 +97,7 @@ impl TurboTasksCallApi for VcStorage {
&self,
func: &'static turbo_tasks::macro_helpers::NativeFunction,
this: Option<RawVc>,
arg: &mut dyn StackMagicAny,
arg: &mut dyn StackDynTaskInputs,
_persistence: TaskPersistence,
) -> RawVc {
self.dynamic_call(func, this, arg.take_box())
......@@ -106,7 +106,7 @@ impl TurboTasksCallApi for VcStorage {
&self,
func: &'static turbo_tasks::macro_helpers::NativeFunction,
this: Option<RawVc>,
arg: &mut dyn StackMagicAny,
arg: &mut dyn StackDynTaskInputs,
_persistence: TaskPersistence,
) -> RawVc {
self.dynamic_call(func, this, arg.take_box())
......@@ -116,7 +116,7 @@ impl TurboTasksCallApi for VcStorage {
&self,
_trait_type: &'static turbo_tasks::TraitMethod,
_this: RawVc,
_arg: &mut dyn StackMagicAny,
_arg: &mut dyn StackDynTaskInputs,
_persistence: TaskPersistence,
) -> RawVc {
unreachable!()
......
......@@ -31,9 +31,9 @@ use crate::{
RawVc, ReadCellOptions, ReadOutputOptions, ReadRef, SharedReference, TaskId, TaskIdSet,
TaskPriority, TraitRef, TraitTypeId, TurboTasksCallApi, TurboTasksPanic, ValueTypeId,
VcValueTrait, VcValueType,
dyn_task_inputs::{DynTaskInputs, StackDynTaskInputs},
event::EventListener,
macro_helpers::NativeFunction,
magic_any::{MagicAny, StackMagicAny},
manager::{TaskPersistence, TurboTasksBackendApi},
raw_vc::CellId,
registry,
......@@ -80,7 +80,7 @@ impl Debug for TransientTaskType {
pub struct CachedTaskType {
pub native_fn: &'static NativeFunction,
pub this: Option<RawVc>,
pub arg: Box<dyn MagicAny>,
pub arg: Box<dyn DynTaskInputs>,
}
impl CachedTaskType {
......@@ -163,7 +163,7 @@ impl CachedTaskType {
hasher: &impl BuildHasher,
native_fn: &'static NativeFunction,
this: Option<RawVc>,
arg: &dyn MagicAny,
arg: &dyn DynTaskInputs,
) -> u64 {
use std::hash::Hasher;
let mut state = hasher.build_hasher();
......@@ -180,7 +180,7 @@ impl CachedTaskType {
pub fn hash_encode_components<H: DeterministicHasher>(
native_fn: &'static NativeFunction,
this: Option<RawVc>,
arg: &dyn MagicAny,
arg: &dyn DynTaskInputs,
hasher: &mut H,
) {
let fn_id = registry::get_function_id(native_fn);
......@@ -197,7 +197,7 @@ impl CachedTaskType {
&self,
native_fn: &'static NativeFunction,
this: Option<RawVc>,
arg: &dyn MagicAny,
arg: &dyn DynTaskInputs,
) -> bool {
std::ptr::eq(self.native_fn, native_fn) && self.this == this && &*self.arg == arg
}
......@@ -655,7 +655,7 @@ pub trait Backend: Sync + Send {
&self,
native_fn: &'static NativeFunction,
this: Option<RawVc>,
arg: &mut dyn StackMagicAny,
arg: &mut dyn StackDynTaskInputs,
parent_task: Option<TaskId>,
persistence: TaskPersistence,
turbo_tasks: &dyn TurboTasksBackendApi<Self>,
......@@ -708,8 +708,8 @@ mod cached_task_type_tests {
use crate::{
RawVc, TaskId,
backend::CachedTaskType,
dyn_task_inputs::DynTaskInputs,
macro_helpers::{ArgMeta, NativeFunction, into_task_fn},
magic_any::MagicAny,
};
// Two distinct static NativeFunctions for testing pointer-based identity.
......@@ -740,8 +740,8 @@ mod cached_task_type_tests {
rs.hash_one(task)
}
/// Build an arg `Box<dyn MagicAny>` for `(i32,)`.
fn make_arg(value: i32) -> Box<dyn MagicAny> {
/// Build an arg `Box<dyn DynTaskInputs>` for `(i32,)`.
fn make_arg(value: i32) -> Box<dyn DynTaskInputs> {
Box::new((value,))
}
......
......@@ -10,24 +10,24 @@ use turbo_dyn_eq_hash::{
use crate::trace::TraceRawVcs;
pub trait MagicAny: Debug + DynEq + DynHash + TraceRawVcs + Send + Sync + 'static {
pub trait DynTaskInputs: Debug + DynEq + DynHash + TraceRawVcs + Send + Sync + 'static {
#[cfg(debug_assertions)]
fn magic_type_name(&self) -> &'static str;
fn dyn_type_name(&self) -> &'static str;
}
impl<T> MagicAny for T
impl<T> DynTaskInputs for T
where
T: Debug + Eq + Hash + Send + Sync + TraceRawVcs + 'static,
{
#[cfg(debug_assertions)]
fn magic_type_name(&self) -> &'static str {
fn dyn_type_name(&self) -> &'static str {
std::any::type_name::<T>()
}
}
impl_partial_eq_for_dyn!(dyn MagicAny);
impl_eq_for_dyn!(dyn MagicAny);
impl_hash_for_dyn!(dyn MagicAny);
impl_partial_eq_for_dyn!(dyn DynTaskInputs);
impl_eq_for_dyn!(dyn DynTaskInputs);
impl_hash_for_dyn!(dyn DynTaskInputs);
pub fn any_as_encode<T: Any>(this: &dyn Any) -> &T {
if let Some(enc) = this.downcast_ref::<T>() {
......@@ -42,14 +42,14 @@ pub fn any_as_encode<T: Any>(this: &dyn Any) -> &T {
/// A trait for task arguments that may reside on the stack.
///
/// This enables deferred boxing: on the cache-hit path (~85%), we only borrow
/// the argument via [`as_ref`](StackMagicAny::as_ref) for hash/equality lookups,
/// avoiding any heap allocation. On cache miss, [`take_box`](StackMagicAny::take_box)
/// the argument via [`as_ref`](StackDynTaskInputs::as_ref) for hash/equality lookups,
/// avoiding any heap allocation. On cache miss, [`take_box`](StackDynTaskInputs::take_box)
/// moves the value into a `Box` with zero clones.
pub trait StackMagicAny {
pub trait StackDynTaskInputs {
/// Borrow the argument as a type-erased reference (for cache lookup).
fn as_ref(&self) -> &dyn MagicAny;
fn as_ref(&self) -> &dyn DynTaskInputs;
/// Move the argument out into a heap-allocated Box (panics if already taken).
fn take_box(&mut self) -> Box<dyn MagicAny>;
fn take_box(&mut self) -> Box<dyn DynTaskInputs>;
/// Downcast to `&mut dyn Any` for concrete type recovery without boxing.
fn as_any_mut(&mut self) -> &mut dyn Any;
}
......@@ -57,13 +57,13 @@ pub trait StackMagicAny {
/// Stack-resident slot wrapping a concrete typed value.
///
/// Created by macro-generated callsites. The value starts in `Some` on the
/// stack; [`take_box`](StackMagicAny::take_box) moves it to the heap on cache miss.
/// stack; [`take_box`](StackDynTaskInputs::take_box) moves it to the heap on cache miss.
#[repr(transparent)]
pub struct StackMagicAnySlot<T> {
pub struct StackDynTaskInputsSlot<T> {
slot: Option<T>,
}
impl<T> StackMagicAnySlot<T> {
impl<T> StackDynTaskInputsSlot<T> {
#[inline]
pub fn new(value: T) -> Self {
Self { slot: Some(value) }
......@@ -73,24 +73,24 @@ impl<T> StackMagicAnySlot<T> {
pub fn take(&mut self) -> T {
self.slot
.take()
.expect("StackMagicAnySlot::take called after value was already taken")
.expect("StackDynTaskInputsSlot::take called after value was already taken")
}
}
impl<T: MagicAny> StackMagicAny for StackMagicAnySlot<T> {
impl<T: DynTaskInputs> StackDynTaskInputs for StackDynTaskInputsSlot<T> {
#[inline]
fn as_ref(&self) -> &dyn MagicAny {
fn as_ref(&self) -> &dyn DynTaskInputs {
self.slot
.as_ref()
.expect("StackMagicAnySlot::as_ref called after take_box")
.expect("StackDynTaskInputsSlot::as_ref called after take_box")
}
#[inline]
fn take_box(&mut self) -> Box<dyn MagicAny> {
fn take_box(&mut self) -> Box<dyn DynTaskInputs> {
Box::new(
self.slot
.take()
.expect("StackMagicAnySlot::take_box called twice"),
.expect("StackDynTaskInputsSlot::take_box called twice"),
)
}
......@@ -101,31 +101,31 @@ impl<T: MagicAny> StackMagicAny for StackMagicAnySlot<T> {
}
/// Adapter for an already-boxed value (e.g., from async resolution tasks).
pub struct OwnedMagicAny {
slot: Option<Box<dyn MagicAny>>,
pub struct OwnedStackDynTaskInputs {
slot: Option<Box<dyn DynTaskInputs>>,
}
impl OwnedMagicAny {
impl OwnedStackDynTaskInputs {
#[inline]
pub fn new(value: Box<dyn MagicAny>) -> Self {
pub fn new(value: Box<dyn DynTaskInputs>) -> Self {
Self { slot: Some(value) }
}
}
impl StackMagicAny for OwnedMagicAny {
impl StackDynTaskInputs for OwnedStackDynTaskInputs {
#[inline]
fn as_ref(&self) -> &dyn MagicAny {
fn as_ref(&self) -> &dyn DynTaskInputs {
&**self
.slot
.as_ref()
.expect("OwnedMagicAny::as_ref called after take_box")
.expect("OwnedStackDynTaskInputs::as_ref called after take_box")
}
#[inline]
fn take_box(&mut self) -> Box<dyn MagicAny> {
fn take_box(&mut self) -> Box<dyn DynTaskInputs> {
self.slot
.take()
.expect("OwnedMagicAny::take_box called twice")
.expect("OwnedStackDynTaskInputs::take_box called twice")
}
#[inline]
......
......@@ -19,6 +19,7 @@ pub mod debug;
#[doc = include_str!("../FORMATTING.md")]
pub mod display;
pub mod duration_span;
mod dyn_task_inputs;
mod effect;
mod error;
pub mod event;
......@@ -30,7 +31,6 @@ mod join_iter_ext;
pub mod keyed;
#[doc(hidden)]
pub mod macro_helpers;
mod magic_any;
mod manager;
pub mod mapped_read_ref;
mod marker_trait;
......@@ -75,6 +75,9 @@ pub use crate::{
collectibles::CollectiblesSource,
completion::{Completion, Completions},
display::{ValueToString, ValueToStringRef},
dyn_task_inputs::{
DynTaskInputs, OwnedStackDynTaskInputs, StackDynTaskInputs, StackDynTaskInputsSlot,
},
effect::{Effect, EffectError, EffectStateStorage, Effects, emit_effect, take_effects},
error::PrettyPrintError,
id::{ExecutionId, LocalTaskId, TRANSIENT_TASK_BIT, TaskId, TraitTypeId, ValueTypeId},
......@@ -83,7 +86,6 @@ pub use crate::{
get_invalidator,
},
join_iter_ext::{JoinIterExt, TryFlatJoinIterExt, TryJoinIterExt},
magic_any::{MagicAny, OwnedMagicAny, StackMagicAny, StackMagicAnySlot},
manager::{
CurrentCellRef, ReadCellTracking, ReadConsistency, ReadTracking, TaskPersistence,
TaskPriority, TurboTasks, TurboTasksApi, TurboTasksBackendApi, TurboTasksCallApi, Unused,
......
......@@ -16,9 +16,9 @@ use crate::{
ValueTypeId,
};
pub use crate::{
dyn_task_inputs::DynTaskInputs,
global_name_for_method, global_name_for_scope, global_name_for_trait_method,
global_name_for_trait_method_impl, global_name_for_type, inventory_submit,
magic_any::MagicAny,
manager::{find_cell_by_id, find_cell_by_type, spawn_detached_for_testing},
native_function::{
ArgMeta, NativeFunction, VTABLE_DEFAULT, downcast_args_owned, downcast_args_ref,
......
......@@ -33,12 +33,12 @@ use crate::{
TurboTasksExecutionError, TypedCellContent, VerificationMode,
},
capture_future::CaptureFuture,
dyn_task_inputs::StackDynTaskInputs,
event::{Event, EventListener},
id::{ExecutionId, LocalTaskId, TRANSIENT_TASK_BIT, TraitTypeId},
id_factory::IdFactoryWithReuse,
keyed::KeyedEq,
macro_helpers::NativeFunction,
magic_any::StackMagicAny,
message_queue::{CompilationEvent, CompilationEventQueue},
priority_runner::{Executor, JoinHandle, PriorityRunner},
raw_vc::{CellId, RawVc},
......@@ -59,7 +59,7 @@ pub trait TurboTasksCallApi: Sync + Send {
&self,
native_fn: &'static NativeFunction,
this: Option<RawVc>,
arg: &mut dyn StackMagicAny,
arg: &mut dyn StackDynTaskInputs,
persistence: TaskPersistence,
) -> RawVc;
/// Call a native function with arguments.
......@@ -68,7 +68,7 @@ pub trait TurboTasksCallApi: Sync + Send {
&self,
native_fn: &'static NativeFunction,
this: Option<RawVc>,
arg: &mut dyn StackMagicAny,
arg: &mut dyn StackDynTaskInputs,
persistence: TaskPersistence,
) -> RawVc;
/// Calls a trait method with arguments. First input is the `self` object.
......@@ -77,7 +77,7 @@ pub trait TurboTasksCallApi: Sync + Send {
&self,
trait_method: &'static TraitMethod,
this: RawVc,
arg: &mut dyn StackMagicAny,
arg: &mut dyn StackDynTaskInputs,
persistence: TaskPersistence,
) -> RawVc;
......@@ -791,7 +791,7 @@ impl<B: Backend + 'static> TurboTasks<B> {
&self,
native_fn: &'static NativeFunction,
this: Option<RawVc>,
arg: &mut dyn StackMagicAny,
arg: &mut dyn StackDynTaskInputs,
persistence: TaskPersistence,
) -> RawVc {
RawVc::TaskOutput(self.backend.get_or_create_task(
......@@ -808,7 +808,7 @@ impl<B: Backend + 'static> TurboTasks<B> {
&self,
native_fn: &'static NativeFunction,
this: Option<RawVc>,
arg: &mut dyn StackMagicAny,
arg: &mut dyn StackDynTaskInputs,
persistence: TaskPersistence,
) -> RawVc {
if this.is_none_or(|this| this.is_resolved())
......@@ -830,7 +830,7 @@ impl<B: Backend + 'static> TurboTasks<B> {
&self,
trait_method: &'static TraitMethod,
this: RawVc,
arg: &mut dyn StackMagicAny,
arg: &mut dyn StackDynTaskInputs,
persistence: TaskPersistence,
) -> RawVc {
// avoid creating a wrapper task if self is already resolved
......@@ -1360,7 +1360,7 @@ impl<B: Backend + 'static> TurboTasksCallApi for TurboTasks<B> {
&self,
native_fn: &'static NativeFunction,
this: Option<RawVc>,
arg: &mut dyn StackMagicAny,
arg: &mut dyn StackDynTaskInputs,
persistence: TaskPersistence,
) -> RawVc {
self.dynamic_call(native_fn, this, arg, persistence)
......@@ -1369,7 +1369,7 @@ impl<B: Backend + 'static> TurboTasksCallApi for TurboTasks<B> {
&self,
native_fn: &'static NativeFunction,
this: Option<RawVc>,
arg: &mut dyn StackMagicAny,
arg: &mut dyn StackDynTaskInputs,
persistence: TaskPersistence,
) -> RawVc {
self.native_call(native_fn, this, arg, persistence)
......@@ -1378,7 +1378,7 @@ impl<B: Backend + 'static> TurboTasksCallApi for TurboTasks<B> {
&self,
trait_method: &'static TraitMethod,
this: RawVc,
arg: &mut dyn StackMagicAny,
arg: &mut dyn StackDynTaskInputs,
persistence: TaskPersistence,
) -> RawVc {
self.trait_call(trait_method, this, arg, persistence)
......@@ -1837,7 +1837,7 @@ pub async fn run_once_with_reason<T: Send + 'static>(
pub fn dynamic_call(
func: &'static NativeFunction,
this: Option<RawVc>,
arg: &mut dyn StackMagicAny,
arg: &mut dyn StackDynTaskInputs,
persistence: TaskPersistence,
) -> RawVc {
with_turbo_tasks(|tt| tt.dynamic_call(func, this, arg, persistence))
......@@ -1847,7 +1847,7 @@ pub fn dynamic_call(
pub fn trait_call(
trait_method: &'static TraitMethod,
this: RawVc,
arg: &mut dyn StackMagicAny,
arg: &mut dyn StackDynTaskInputs,
persistence: TaskPersistence,
) -> RawVc {
with_turbo_tasks(|tt| tt.trait_call(trait_method, this, arg, persistence))
......
......@@ -9,19 +9,23 @@ use turbo_tasks_hash::DeterministicHasher;
use crate::{
RawVc, TaskExecutionReason, TaskInput, TaskPersistence, TaskPriority,
dyn_task_inputs::{
DynTaskInputs, OwnedStackDynTaskInputs, StackDynTaskInputs, StackDynTaskInputsSlot,
any_as_encode,
},
macro_helpers::into_task_fn,
magic_any::{MagicAny, OwnedMagicAny, StackMagicAny, StackMagicAnySlot, any_as_encode},
registry::{RegistryType, turbo_registry},
task::{TaskFn, TaskFnInputs, function::NativeTaskFuture},
};
type ResolveFuture<'a> = Pin<Box<dyn Future<Output = Result<Box<dyn MagicAny>>> + Send + 'a>>;
type ResolveFunctor = for<'a> fn(&'a dyn MagicAny) -> ResolveFuture<'a>;
type ResolveFuture<'a> = Pin<Box<dyn Future<Output = Result<Box<dyn DynTaskInputs>>> + Send + 'a>>;
type ResolveFunctor = for<'a> fn(&'a dyn DynTaskInputs) -> ResolveFuture<'a>;
type IsResolvedFunctor = fn(&dyn MagicAny) -> bool;
type IsResolvedFunctor = fn(&dyn DynTaskInputs) -> bool;
#[doc(hidden)]
pub type FilterOwnedArgsFunctor = for<'a> fn(&'a mut dyn StackMagicAny) -> OwnedMagicAny;
pub type FilterOwnedArgsFunctor =
for<'a> fn(&'a mut dyn StackDynTaskInputs) -> OwnedStackDynTaskInputs;
#[doc(hidden)]
pub type FilterAndResolveFunctor = ResolveFunctor;
......@@ -32,7 +36,7 @@ pub type AnyHashEncodeFn = fn(&dyn Any, &mut dyn DeterministicHasher);
pub struct ArgMeta {
// TODO: This should be an `Option` with `None` for transient tasks. We can skip some codegen.
pub bincode: (AnyEncodeFn, AnyDecodeFn<Box<dyn MagicAny>>),
pub bincode: (AnyEncodeFn, AnyDecodeFn<Box<dyn DynTaskInputs>>),
/// Encodes the argument directly to a hasher, avoiding buffer allocation.
/// Uses the same encoding logic as bincode but writes to a [`DeterministicHasher`].
pub hash_encode: AnyHashEncodeFn,
......@@ -45,10 +49,11 @@ pub struct ArgMeta {
/// resolution in a single operation. `None` when all arguments are used (no filtering needed),
/// in which case the caller should use [`resolve`](ArgMeta::resolve) directly.
//
// When filtering a `&dyn MagicAny` while running a resolution task, we can't return a filtered
// `&dyn MagicAny`, we'd be forced to return a `Box<dyn MagicAny>`. However, the next thing we
// do is resolution, which also accepts a `&dyn MagicAny` and returns a `Box<dyn MagicAny>`.
// This functor combines the two operations to avoid extra cloning.
// When filtering a `&dyn DynTaskInputs` while running a resolution task, we can't return a
// filtered `&dyn DynTaskInputs`, we'd be forced to return a `Box<dyn DynTaskInputs>`.
// However, the next thing we do is resolution, which also accepts a `&dyn DynTaskInputs`
// and returns a `Box<dyn DynTaskInputs>`. This functor combines the two operations to
// avoid extra cloning.
filter_and_resolve: Option<FilterAndResolveFunctor>,
}
......@@ -112,15 +117,18 @@ impl ArgMeta {
}
}
pub fn is_resolved(&self, value: &dyn MagicAny) -> bool {
pub fn is_resolved(&self, value: &dyn DynTaskInputs) -> bool {
(self.is_resolved)(value)
}
pub async fn resolve(&self, value: &dyn MagicAny) -> Result<Box<dyn MagicAny>> {
pub async fn resolve(&self, value: &dyn DynTaskInputs) -> Result<Box<dyn DynTaskInputs>> {
(self.resolve)(value).await
}
pub async fn filter_and_resolve(&self, args: &dyn MagicAny) -> Result<Box<dyn MagicAny>> {
pub async fn filter_and_resolve(
&self,
args: &dyn DynTaskInputs,
) -> Result<Box<dyn DynTaskInputs>> {
if let Some(filter_and_resolve) = self.filter_and_resolve {
(filter_and_resolve)(args).await
} else {
......@@ -129,11 +137,13 @@ impl ArgMeta {
}
}
fn resolve_functor_impl<T: MagicAny + TaskInput>(value: &dyn MagicAny) -> ResolveFuture<'_> {
fn resolve_functor_impl<T: DynTaskInputs + TaskInput>(
value: &dyn DynTaskInputs,
) -> ResolveFuture<'_> {
Box::pin(async move {
let value = downcast_args_ref::<T>(value);
let resolved = value.resolve_input().await?;
Ok(Box::new(resolved) as Box<dyn MagicAny>)
Ok(Box::new(resolved) as Box<dyn DynTaskInputs>)
})
}
......@@ -143,9 +153,9 @@ pub fn debug_downcast_args_error_msg(expected: &str, actual: &str) -> String {
format!("Invalid argument type, expected {expected} got {actual}")
}
pub fn downcast_args_owned<T: MagicAny>(args: Box<dyn MagicAny>) -> Box<T> {
pub fn downcast_args_owned<T: DynTaskInputs>(args: Box<dyn DynTaskInputs>) -> Box<T> {
#[cfg(debug_assertions)]
let args_type_name = args.magic_type_name();
let args_type_name = args.dyn_type_name();
(args as Box<dyn Any>)
.downcast::<T>()
......@@ -161,14 +171,14 @@ pub fn downcast_args_owned<T: MagicAny>(args: Box<dyn MagicAny>) -> Box<T> {
.unwrap()
}
pub fn downcast_args_ref<T: MagicAny>(args: &dyn MagicAny) -> &T {
pub fn downcast_args_ref<T: DynTaskInputs>(args: &dyn DynTaskInputs) -> &T {
(args as &dyn Any)
.downcast_ref::<T>()
.ok_or_else(|| {
#[cfg(debug_assertions)]
return anyhow::anyhow!(debug_downcast_args_error_msg(
std::any::type_name::<T>(),
args.magic_type_name(),
args.dyn_type_name(),
));
#[cfg(not(debug_assertions))]
return anyhow::anyhow!("Invalid argument type");
......@@ -176,15 +186,15 @@ pub fn downcast_args_ref<T: MagicAny>(args: &dyn MagicAny) -> &T {
.unwrap()
}
/// Downcast a `&mut dyn StackMagicAny` to a concrete [`StackMagicAnySlot<T>`] and take the value
/// out, avoiding the intermediate heap allocation that `take_box` + `downcast_args_owned` would
/// require.
pub fn downcast_stack_args_owned<T: MagicAny>(args: &mut dyn StackMagicAny) -> T {
/// Downcast a `&mut dyn StackDynTaskInputs` to a concrete [`StackDynTaskInputsSlot<T>`] and
/// take the value out, avoiding the intermediate heap allocation that `take_box` +
/// `downcast_args_owned` would require.
pub fn downcast_stack_args_owned<T: DynTaskInputs>(args: &mut dyn StackDynTaskInputs) -> T {
args.as_any_mut()
.downcast_mut::<StackMagicAnySlot<T>>()
.downcast_mut::<StackDynTaskInputsSlot<T>>()
.unwrap_or_else(|| {
panic!(
"downcast_stack_args_owned::<{}> called with incorrect StackMagicAny type",
"downcast_stack_args_owned::<{}> called with incorrect StackDynTaskInputs type",
std::any::type_name::<T>(),
)
})
......@@ -249,7 +259,11 @@ impl NativeFunction {
}
/// Executed the function
pub fn execute(&'static self, this: Option<RawVc>, arg: &dyn MagicAny) -> NativeTaskFuture {
pub fn execute(
&'static self,
this: Option<RawVc>,
arg: &dyn DynTaskInputs,
) -> NativeTaskFuture {
match (self.implementation).functor(this, arg) {
Ok(functor) => functor,
Err(err) => Box::pin(async { Err(err) }),
......
......@@ -26,12 +26,12 @@ use std::{future::Future, marker::PhantomData, pin::Pin};
use anyhow::Result;
use super::{TaskInput, TaskOutput};
use crate::{RawVc, Vc, VcRead, VcValueType, magic_any::MagicAny};
use crate::{RawVc, Vc, VcRead, VcValueType, dyn_task_inputs::DynTaskInputs};
pub type NativeTaskFuture = Pin<Box<dyn Future<Output = Result<RawVc>> + Send>>;
pub trait TaskFn: Send + Sync + 'static {
fn functor(&self, this: Option<RawVc>, arg: &dyn MagicAny) -> Result<NativeTaskFuture>;
fn functor(&self, this: Option<RawVc>, arg: &dyn DynTaskInputs) -> Result<NativeTaskFuture>;
}
/// A trait for `TaskFn` implementations that allows task inputs to be extracted as a type.
......@@ -81,7 +81,7 @@ where
Mode: TaskFnMode,
Inputs: TaskInputs,
{
fn functor(&self, _this: Option<RawVc>, arg: &dyn MagicAny) -> Result<NativeTaskFuture> {
fn functor(&self, _this: Option<RawVc>, arg: &dyn DynTaskInputs) -> Result<NativeTaskFuture> {
TaskFnInputFunction::functor(&self.task_fn, arg)
}
}
......@@ -114,7 +114,7 @@ where
This: Sync + Send + 'static,
Inputs: TaskInputs,
{
fn functor(&self, this: Option<RawVc>, arg: &dyn MagicAny) -> Result<NativeTaskFuture> {
fn functor(&self, this: Option<RawVc>, arg: &dyn DynTaskInputs) -> Result<NativeTaskFuture> {
let Some(this) = this else {
panic!("Method needs a `self` argument");
};
......@@ -136,7 +136,7 @@ where
pub trait TaskFnInputFunction<Mode: TaskFnMode, Inputs: TaskInputs>:
Send + Sync + Clone + 'static
{
fn functor(&self, arg: &dyn MagicAny) -> Result<NativeTaskFuture>;
fn functor(&self, arg: &dyn DynTaskInputs) -> Result<NativeTaskFuture>;
}
#[doc(hidden)]
......@@ -146,7 +146,7 @@ pub trait TaskFnInputFunctionWithThis<
Inputs: TaskInputs,
>: Send + Sync + Clone + 'static
{
fn functor(&self, this: RawVc, arg: &dyn MagicAny) -> Result<NativeTaskFuture>;
fn functor(&self, this: RawVc, arg: &dyn DynTaskInputs) -> Result<NativeTaskFuture>;
}
pub trait TaskInputs: Send + Sync + 'static {}
......@@ -184,13 +184,13 @@ macro_rules! task_inputs_impl {
/// This helper function for `task_fn_impl!()` reduces the amount of code inside the macro, and
/// gives the compiler more chances to dedupe monomorphized code across small functions with less
/// typevars.
fn get_args<T: MagicAny + Clone>(arg: &dyn MagicAny) -> Result<T> {
fn get_args<T: DynTaskInputs + Clone>(arg: &dyn DynTaskInputs) -> Result<T> {
let value = (arg as &dyn std::any::Any).downcast_ref::<T>().cloned();
#[cfg(debug_assertions)]
return anyhow::Context::with_context(value, || {
crate::native_function::debug_downcast_args_error_msg(
std::any::type_name::<T>(),
arg.magic_type_name(),
arg.dyn_type_name(),
)
});
#[cfg(not(debug_assertions))]
......@@ -211,7 +211,7 @@ macro_rules! task_fn_impl {
Output: TaskOutput + 'static,
{
#[allow(non_snake_case)]
fn functor(&self, arg: &dyn MagicAny) -> Result<NativeTaskFuture> {
fn functor(&self, arg: &dyn DynTaskInputs) -> Result<NativeTaskFuture> {
let task_fn = self.clone();
let ($($arg,)*) = get_args::<($($arg,)*)>(arg)?;
Ok(Box::pin(async move {
......@@ -229,7 +229,7 @@ macro_rules! task_fn_impl {
Output: TaskOutput + 'static,
{
#[allow(non_snake_case)]
fn functor(&self, arg: &dyn MagicAny) -> Result<NativeTaskFuture> {
fn functor(&self, arg: &dyn DynTaskInputs) -> Result<NativeTaskFuture> {
let task_fn = self.clone();
let ($($arg,)*) = get_args::<($($arg,)*)>(arg)?;
Ok(Box::pin(async move {
......@@ -247,7 +247,7 @@ macro_rules! task_fn_impl {
Output: TaskOutput + 'static,
{
#[allow(non_snake_case)]
fn functor(&self, this: RawVc, arg: &dyn MagicAny) -> Result<NativeTaskFuture> {
fn functor(&self, this: RawVc, arg: &dyn DynTaskInputs) -> Result<NativeTaskFuture> {
let task_fn = self.clone();
let recv = Vc::<Recv>::from(this);
let ($($arg,)*) = get_args::<($($arg,)*)>(arg)?;
......@@ -268,7 +268,7 @@ macro_rules! task_fn_impl {
Output: TaskOutput + 'static,
{
#[allow(non_snake_case)]
fn functor(&self, this: RawVc, arg: &dyn MagicAny) -> Result<NativeTaskFuture> {
fn functor(&self, this: RawVc, arg: &dyn DynTaskInputs) -> Result<NativeTaskFuture> {
let task_fn = self.clone();
let recv = Vc::<Recv>::from(this);
let ($($arg,)*) = get_args::<($($arg,)*)>(arg)?;
......@@ -301,7 +301,7 @@ macro_rules! task_fn_impl {
F: for<'a> $async_fn_trait<&'a Recv, $($arg,)*> + Clone + Send + Sync + 'static,
{
#[allow(non_snake_case)]
fn functor(&self, this: RawVc, arg: &dyn MagicAny) -> Result<NativeTaskFuture> {
fn functor(&self, this: RawVc, arg: &dyn DynTaskInputs) -> Result<NativeTaskFuture> {
let task_fn = self.clone();
let recv = Vc::<Recv>::from(this);
let ($($arg,)*) = get_args::<($($arg,)*)>(arg)?;
......@@ -321,7 +321,7 @@ macro_rules! task_fn_impl {
F: $async_fn_trait<Vc<Recv>, $($arg,)*> + Clone + Send + Sync + 'static,
{
#[allow(non_snake_case)]
fn functor(&self, this: RawVc, arg: &dyn MagicAny) -> Result<NativeTaskFuture> {
fn functor(&self, this: RawVc, arg: &dyn DynTaskInputs) -> Result<NativeTaskFuture> {
let task_fn = self.clone();
let recv = Vc::<Recv>::from(this);
let ($($arg,)*) = get_args::<($($arg,)*)>(arg)?;
......
......@@ -3,8 +3,8 @@ use std::{fmt, sync::Arc};
use anyhow::{Result, bail};
use crate::{
CellId, MagicAny, OutputContent, OwnedMagicAny, RawVc, TaskPersistence, TraitMethod,
TurboTasksBackendApi, ValueTypeId, backend::Backend, event::Event,
CellId, DynTaskInputs, OutputContent, OwnedStackDynTaskInputs, RawVc, TaskPersistence,
TraitMethod, TurboTasksBackendApi, ValueTypeId, backend::Backend, event::Event,
macro_helpers::NativeFunction, registry,
};
......@@ -18,7 +18,7 @@ pub struct LocalTaskSpec {
/// The self value, will always be present for `ResolveTrait` tasks and is optional otherwise
pub(crate) this: Option<RawVc>,
/// Function arguments
pub(crate) arg: Box<dyn MagicAny>,
pub(crate) arg: Box<dyn DynTaskInputs>,
pub(crate) task_type: LocalTaskType,
}
......@@ -53,7 +53,7 @@ impl LocalTaskType {
pub(crate) async fn run_resolve_native<B: Backend + 'static>(
native_fn: &'static NativeFunction,
mut this: Option<RawVc>,
arg: &dyn MagicAny,
arg: &dyn DynTaskInputs,
persistence: TaskPersistence,
turbo_tasks: Arc<dyn TurboTasksBackendApi<B>>,
) -> Result<RawVc> {
......@@ -61,14 +61,14 @@ impl LocalTaskType {
*this = this.resolve().await?;
}
let arg = native_fn.arg_meta.resolve(arg).await?;
let mut arg = OwnedMagicAny::new(arg);
let mut arg = OwnedStackDynTaskInputs::new(arg);
Ok(turbo_tasks.native_call(native_fn, this, &mut arg, persistence))
}
/// Implementation of the LocalTaskType::ResolveTrait task.
pub(crate) async fn run_resolve_trait<B: Backend + 'static>(
trait_method: &'static TraitMethod,
this: RawVc,
arg: &dyn MagicAny,
arg: &dyn DynTaskInputs,
persistence: TaskPersistence,
turbo_tasks: Arc<dyn TurboTasksBackendApi<B>>,
) -> Result<RawVc> {
......@@ -79,7 +79,7 @@ impl LocalTaskType {
let native_fn = Self::resolve_trait_method_from_value(trait_method, type_id)?;
let arg = native_fn.arg_meta.filter_and_resolve(arg).await?;
let mut arg = OwnedMagicAny::new(arg);
let mut arg = OwnedStackDynTaskInputs::new(arg);
Ok(turbo_tasks.native_call(native_fn, Some(this), &mut arg, persistence))
}
......
......@@ -24,7 +24,7 @@ use turbo_tasks_hash::HashAlgorithm;
// name directly.
use crate as turbo_tasks;
use crate::{
MagicAny, ReadRef, ResolvedVc, TaskId, TransientInstance, TransientValue, ValueTypeId, Vc,
DynTaskInputs, ReadRef, ResolvedVc, TaskId, TransientInstance, TransientValue, ValueTypeId, Vc,
trace::TraceRawVcs,
};
......@@ -284,7 +284,7 @@ where
impl<T> TaskInput for TransientValue<T>
where
T: MagicAny + Clone + Debug + Hash + Eq + TraceRawVcs + 'static,
T: DynTaskInputs + Clone + Debug + Hash + Eq + TraceRawVcs + 'static,
{
fn is_transient(&self) -> bool {
true
......
......@@ -11,9 +11,9 @@ use turbo_bincode::{AnyDecodeFn, AnyEncodeFn};
use crate::{
RawVc, SharedReference, TaskPriority, VcValueType,
dyn_task_inputs::any_as_encode,
id::TraitTypeId,
macro_helpers::{CollectableTraitMethods, NativeFunction},
magic_any::any_as_encode,
registry::{RegistryType, get_trait_type_id, trait_type_count, turbo_registry},
task::shared_reference::TypedSharedReference,
vc::VcCellMode,
......
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