turbo_tasks/
macro_helpers.rs

1//! Runtime helpers for [turbo-tasks-macro].
2
3pub use async_trait::async_trait;
4pub use bincode;
5pub use once_cell::sync::{Lazy, OnceCell};
6use rustc_hash::FxHashMap;
7pub use shrink_to_fit;
8pub use tracing;
9
10use crate::{
11    FxDashMap, NonLocalValue, RawVc, TaskInput, TaskPersistence, TraitTypeId, ValueType,
12    ValueTypeId, debug::ValueDebugFormatString,
13};
14pub use crate::{
15    global_name, inventory_submit,
16    magic_any::MagicAny,
17    manager::{find_cell_by_id, find_cell_by_type, spawn_detached_for_testing},
18    native_function::{
19        CollectableFunction, NativeFunction, downcast_args_owned, downcast_args_ref,
20    },
21    value_type::{CollectableTrait, CollectableValueType},
22};
23
24#[inline(never)]
25pub async fn value_debug_format_field(value: ValueDebugFormatString<'_>) -> String {
26    match value.try_to_value_debug_string().await {
27        Ok(result) => match result.await {
28            Ok(result) => result.to_string(),
29            Err(err) => format!("{err:?}"),
30        },
31        Err(err) => format!("{err:?}"),
32    }
33}
34
35pub fn get_persistence_from_inputs(inputs: &impl TaskInput) -> TaskPersistence {
36    if inputs.is_transient() {
37        TaskPersistence::Transient
38    } else {
39        TaskPersistence::Persistent
40    }
41}
42
43pub fn get_persistence_from_inputs_and_this(
44    this: RawVc,
45    inputs: &impl TaskInput,
46) -> TaskPersistence {
47    if this.is_transient() || inputs.is_transient() {
48        TaskPersistence::Transient
49    } else {
50        TaskPersistence::Persistent
51    }
52}
53
54pub fn assert_argument_is_non_local_value<Argument: NonLocalValue>() {}
55
56#[macro_export]
57macro_rules! stringify_path {
58    ($path:path) => {
59        stringify!($path)
60    };
61}
62
63/// Rexport std::ptr::metadata so not every crate needs to enable the feature when they use our
64/// macros.
65#[inline(always)]
66pub const fn metadata<T: ?Sized>(ptr: *const T) -> <T as std::ptr::Pointee>::Metadata {
67    // Ideally we would just `pub use std::ptr::metadata;` but this doesn't seem to work.
68    std::ptr::metadata(ptr)
69}
70
71/// A registry of all the impl vtables for a given VcValue trait
72/// This is constructed in the macro gencode and populated by the registry.
73#[derive(Default)]
74pub struct VTableRegistry<T: ?Sized> {
75    map: FxHashMap<ValueTypeId, <T as std::ptr::Pointee>::Metadata>,
76}
77
78impl<T: ?Sized> VTableRegistry<T> {
79    pub fn new(id: TraitTypeId) -> Self {
80        let mut map = FxHashMap::default();
81        match TRAIT_CAST_FNS.remove(&id) {
82            Some((_, impls)) => {
83                for (value_type_id, RawPtr(raw_fn)) in impls {
84                    // SAFETY: These are generated by the macro gencode in value_impl with this
85                    // signature.
86                    let cast_fn: fn(*const ()) -> *const T = unsafe { std::mem::transmute(raw_fn) };
87                    // Cast a null pointer to a fat pointer using the cast_fn, this allows us to
88                    // capture a vtable Alternatively we could just store the
89                    // cast functions but it will be faster to call 'from_raw_parts' instead of an
90                    // indirect function call.
91                    let ptr = cast_fn(std::ptr::null::<()>());
92                    let metadata = std::ptr::metadata(ptr);
93                    let prev = map.insert(value_type_id, metadata);
94                    debug_assert!(
95                        prev.is_none(),
96                        "multiple cast functions registered for {value_type_id}"
97                    )
98                }
99            }
100            None => {
101                // A trait doesn't have to have any implementations.
102            }
103        }
104
105        Self { map }
106    }
107
108    pub(crate) fn cast(&self, id: ValueTypeId, raw: *const ()) -> *const T {
109        let metadata = self.map.get(&id).unwrap();
110        std::ptr::from_raw_parts(raw, *metadata)
111    }
112}
113
114struct RawPtr(*const ());
115// SAFETY: We only store function pointers in here which are safe to send/sync
116unsafe impl Sync for RawPtr {}
117unsafe impl Send for RawPtr {}
118
119// Accumulate all trait impls by trait id
120static TRAIT_CAST_FNS: Lazy<FxDashMap<TraitTypeId, Vec<(ValueTypeId, RawPtr)>>> = Lazy::new(|| {
121    let map: FxDashMap<TraitTypeId, Vec<(ValueTypeId, RawPtr)>> = FxDashMap::default();
122    for CollectableTraitCastFunctions(trait_id_fn, value_id_fn, cast_fn) in
123        inventory::iter::<CollectableTraitCastFunctions>
124    {
125        map.entry(trait_id_fn())
126            .or_default()
127            .value_mut()
128            .push((value_id_fn(), RawPtr(*cast_fn)));
129    }
130    map
131});
132
133// Holds a raw pointer to a function that can perform a fat pointer cast
134pub struct CollectableTraitCastFunctions(
135    pub fn() -> TraitTypeId,
136    pub fn() -> ValueTypeId,
137    pub *const (),
138);
139// SAFETY: We only store function pointers in here.
140unsafe impl Sync for CollectableTraitCastFunctions {}
141inventory::collect! {CollectableTraitCastFunctions}
142
143#[allow(clippy::type_complexity)]
144pub struct CollectableTraitMethods(
145    // A value type name
146    pub &'static str,
147    pub fn() -> (TraitTypeId, Vec<(&'static str, &'static NativeFunction)>),
148);
149inventory::collect! {CollectableTraitMethods}
150
151// Called when initializing ValueTypes by value_impl
152pub fn register_trait_methods(value: &mut ValueType) {
153    #[allow(clippy::type_complexity)]
154    static TRAIT_METHODS_BY_VALUE: Lazy<
155        FxDashMap<&'static str, Vec<(TraitTypeId, Vec<(&'static str, &'static NativeFunction)>)>>,
156    > = Lazy::new(|| {
157        let map: FxDashMap<&'static str, Vec<_>> = FxDashMap::default();
158        for CollectableTraitMethods(value_name, thunk) in inventory::iter::<CollectableTraitMethods>
159        {
160            map.entry(*value_name).or_default().push(thunk());
161        }
162        map
163    });
164    match TRAIT_METHODS_BY_VALUE.remove(value.global_name) {
165        Some((_, traits)) => {
166            for (trait_type_id, methods) in traits {
167                let trait_type = crate::registry::get_trait(trait_type_id);
168                value.register_trait(trait_type_id);
169                for (name, method) in methods {
170                    value.register_trait_method(trait_type.get(name), method);
171                }
172            }
173        }
174        None => {
175            // do nothing, values don't have to implement any traits
176        }
177    }
178}
179
180/// Submit an item to the inventory.
181///
182/// This macro is a wrapper around `inventory::submit` that adds a `#[not(cfg(rust_analyzer))]`
183/// attribute to the item. This is to avoid warnings about unused items when using Rust Analyzer.
184#[macro_export]
185macro_rules! inventory_submit {
186    ($($item:tt)*) => {
187        #[cfg(not(rust_analyzer))]
188        $crate::macro_helpers::inventory_submit_inner! { $($item)* }
189    }
190}
191
192/// Exported so the above macro can reference it.
193#[doc(hidden)]
194pub use inventory::submit as inventory_submit_inner;
195
196/// Define a global name for a turbo-tasks value.
197#[cfg(not(rust_analyzer))] // ignore-rust-analyzer due to https://github.com/rust-lang/rust-analyzer/issues/19993
198#[macro_export]
199macro_rules! global_name {
200    ($($item:tt)*) => {
201
202        ::std::concat!(::std::env!("CARGO_PKG_NAME"), "@", ::std::module_path!(), "::", $($item)*)
203    }
204}
205/// Define a global name for a turbo-tasks value.
206/// This has a dummy implementation for Rust Analyzer to avoid https://github.com/rust-lang/rust-analyzer/issues/19993
207#[cfg(rust_analyzer)]
208#[macro_export]
209macro_rules! global_name {
210    ($($item:tt)*) => {
211        $($item)*
212    }
213}
turbo_tasks/macro_helpers.rs

turbo_tasks/
macro_helpers.rs
