turbo_tasks/
serialization_invalidation.rs

1use std::{
2    hash::Hash,
3    sync::{Arc, Weak},
4};
5
6use serde::{Deserialize, Serialize, de::Visitor};
7use tokio::runtime::Handle;
8
9use crate::{TaskId, TurboTasksApi, manager::with_turbo_tasks, trace::TraceRawVcs};
10
11#[derive(Clone)]
12pub struct SerializationInvalidator {
13    task: TaskId,
14    turbo_tasks: Weak<dyn TurboTasksApi>,
15    handle: Handle,
16}
17
18impl Hash for SerializationInvalidator {
19    fn hash<H: std::hash::Hasher>(&self, state: &mut H) {
20        self.task.hash(state);
21    }
22}
23
24impl PartialEq for SerializationInvalidator {
25    fn eq(&self, other: &Self) -> bool {
26        self.task == other.task
27    }
28}
29
30impl Eq for SerializationInvalidator {}
31
32impl SerializationInvalidator {
33    pub fn invalidate(&self) {
34        let SerializationInvalidator {
35            task,
36            turbo_tasks,
37            handle,
38        } = self;
39        let _guard = handle.enter();
40        if let Some(turbo_tasks) = turbo_tasks.upgrade() {
41            turbo_tasks.invalidate_serialization(*task);
42        }
43    }
44
45    pub(crate) fn new(task_id: TaskId) -> Self {
46        Self {
47            task: task_id,
48            turbo_tasks: with_turbo_tasks(Arc::downgrade),
49            handle: Handle::current(),
50        }
51    }
52}
53
54impl TraceRawVcs for SerializationInvalidator {
55    fn trace_raw_vcs(&self, _context: &mut crate::trace::TraceRawVcsContext) {
56        // nothing here
57    }
58}
59
60impl Serialize for SerializationInvalidator {
61    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
62    where
63        S: serde::Serializer,
64    {
65        serializer.serialize_newtype_struct("SerializationInvalidator", &self.task)
66    }
67}
68
69impl<'de> Deserialize<'de> for SerializationInvalidator {
70    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
71    where
72        D: serde::Deserializer<'de>,
73    {
74        struct V;
75
76        impl<'de> Visitor<'de> for V {
77            type Value = SerializationInvalidator;
78
79            fn expecting(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
80                write!(f, "an SerializationInvalidator")
81            }
82
83            fn visit_newtype_struct<D>(self, deserializer: D) -> Result<Self::Value, D::Error>
84            where
85                D: serde::Deserializer<'de>,
86            {
87                Ok(SerializationInvalidator {
88                    task: TaskId::deserialize(deserializer)?,
89                    turbo_tasks: with_turbo_tasks(Arc::downgrade),
90                    handle: tokio::runtime::Handle::current(),
91                })
92            }
93        }
94        deserializer.deserialize_newtype_struct("SerializationInvalidator", V)
95    }
96}
turbo_tasks/serialization_invalidation.rs

turbo_tasks/
serialization_invalidation.rs
