And even when embedded in a Vc/ReadRef

Author: lukesandberg

turbopack/crates/turbo-tasks-backend/src/backend/mod.rs

@@ -36,7 +36,7 @@ use turbo_tasks::{
     },
     event::{Event, EventListener},
     message_queue::TimingEvent,
-    registry::{self, get_value_type_global_name},
+    registry::get_value_type_global_name,
     task_statistics::TaskStatisticsApi,
     trace::TraceRawVcs,
     turbo_tasks,
@@ -867,7 +867,7 @@ impl<B: BackingStorage> TurboTasksBackendInner<B> {
 
         let _span = tracing::trace_span!(
             "recomputation",
-            cell_type = registry::get_value_type_global_name(cell.type_id),
+            cell_type = get_value_type_global_name(cell.type_id),
             cell_index = cell.index
         )
         .entered();

turbopack/crates/turbo-tasks/src/backend.rs

@@ -127,7 +127,7 @@ mod ser {
                 None
             };
             let mut state = serializer.serialize_tuple(3)?;
-            state.serialize_element(registry::get_value_type_global_name(self.0))?;
+            state.serialize_element(&self.0)?;
             if let Some(serializable) = serializable {
                 state.serialize_element(&true)?;
                 state.serialize_element(serializable)?;
@@ -157,11 +157,9 @@ mod ser {
                 where
                     A: de::SeqAccess<'de>,
                 {
-                    let value_type = seq
+                    let value_type: ValueTypeId = seq
                         .next_element()?
                         .ok_or_else(|| de::Error::invalid_length(0, &self))?;
-                    let value_type = registry::get_value_type_id_by_global_name(value_type)
-                        .ok_or_else(|| de::Error::custom("Unknown value type"))?;
                     let has_value: bool = seq
                         .next_element()?
                         .ok_or_else(|| de::Error::invalid_length(1, &self))?;

turbopack/crates/turbo-tasks/src/id.rs

@@ -160,7 +160,7 @@ impl TaskId {
 }
 
 macro_rules! make_serializable {
-    ($ty:ty, $get_global_name:path, $visitor_name:ident) => {
+    ($ty:ty, $get_object:path, $visitor_name:ident) => {
         impl Serialize for $ty {
             fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
             where
@@ -201,20 +201,12 @@ macro_rules! make_serializable {
             fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
                 f.debug_struct(stringify!($ty))
                     .field("id", &self.id)
-                    .field("name", &$get_global_name(*self))
+                    .field("name", &$get_object(*self))
                     .finish()
             }
         }
     };
 }
 
-make_serializable!(
-    ValueTypeId,
-    registry::get_value_type_global_name,
-    ValueTypeVisitor
-);
-make_serializable!(
-    TraitTypeId,
-    registry::get_trait_type_global_name,
-    TraitTypeVisitor
-);
+make_serializable!(ValueTypeId, registry::get_value_type, ValueTypeVisitor);
+make_serializable!(TraitTypeId, registry::get_trait, TraitTypeVisitor);

turbopack/crates/turbo-tasks/src/registry.rs

@@ -35,7 +35,6 @@ pub fn get_function_by_global_name(global_name: &str) -> &'static NativeFunction
 struct Values {
     id_to_value: Box<[&'static ValueType]>,
     value_to_id: FxHashMap<&'static ValueType, ValueTypeId>,
-    global_name_to_value: FxHashMap<&'static str, (ValueTypeId, &'static ValueType)>,
 }
 
 static VALUES: Lazy<Values> = Lazy::new(|| {
@@ -67,11 +66,9 @@ static VALUES: Lazy<Values> = Lazy::new(|| {
     }
 
     value_to_id.shrink_to_fit();
-    global_name_to_value.shrink_to_fit();
     Values {
         value_to_id,
         id_to_value: all_values.into_boxed_slice(),
-        global_name_to_value,
     }
 });
 
@@ -82,13 +79,6 @@ pub fn get_value_type_id(value: &'static ValueType) -> ValueTypeId {
     }
 }
 
-pub fn get_value_type_id_by_global_name(global_name: &str) -> Option<ValueTypeId> {
-    VALUES
-        .global_name_to_value
-        .get(global_name)
-        .map(|(id, _)| *id)
-}
-
 pub fn get_value_type(id: ValueTypeId) -> &'static ValueType {
     VALUES.id_to_value[*id as usize - 1]
 }
@@ -100,7 +90,6 @@ pub fn get_value_type_global_name(id: ValueTypeId) -> &'static str {
 struct Traits {
     id_to_trait: Box<[&'static TraitType]>,
     trait_to_id: FxHashMap<&'static TraitType, TraitTypeId>,
-    global_name_to_trait: FxHashMap<&'static str, (TraitTypeId, &'static TraitType)>,
 }
 
 static TRAITS: Lazy<Traits> = Lazy::new(|| {
@@ -130,11 +119,9 @@ static TRAITS: Lazy<Traits> = Lazy::new(|| {
         );
     }
     trait_to_id.shrink_to_fit();
-    global_name_to_trait.shrink_to_fit();
     Traits {
         trait_to_id,
         id_to_trait: all_traits.into_boxed_slice(),
-        global_name_to_trait,
     }
 });
 

turbopack/crates/turbo-tasks/src/task/shared_reference.rs

@@ -110,7 +110,7 @@ impl Serialize for TypedSharedReference {
         let value_type = registry::get_value_type(*ty);
         if let Some(serializable) = value_type.any_as_serializable(arc) {
             let mut t = serializer.serialize_tuple(2)?;
-            t.serialize_element(registry::get_value_type_global_name(*ty))?;
+            t.serialize_element(ty)?;
             t.serialize_element(serializable)?;
             t.end()
         } else {
@@ -156,29 +156,25 @@ impl<'de> Deserialize<'de> for TypedSharedReference {
             where
                 A: serde::de::SeqAccess<'de>,
             {
-                if let Some(global_name) = seq.next_element()? {
-                    if let Some(ty) = registry::get_value_type_id_by_global_name(global_name) {
-                        if let Some(seed) = registry::get_value_type(ty).get_any_deserialize_seed()
-                        {
-                            if let Some(value) = seq.next_element_seed(seed)? {
-                                let arc = triomphe::Arc::<dyn Any + Send + Sync>::from(value);
-                                Ok(TypedSharedReference {
-                                    type_id: ty,
-                                    reference: SharedReference(arc),
-                                })
-                            } else {
-                                Err(serde::de::Error::invalid_length(
-                                    1,
-                                    &"tuple with type and value",
-                                ))
-                            }
+                if let Some(type_id) = seq.next_element()? {
+                    let value_type = registry::get_value_type(type_id);
+                    if let Some(seed) = value_type.get_any_deserialize_seed() {
+                        if let Some(value) = seq.next_element_seed(seed)? {
+                            let arc = triomphe::Arc::<dyn Any + Send + Sync>::from(value);
+                            Ok(TypedSharedReference {
+                                type_id,
+                                reference: SharedReference(arc),
+                            })
                         } else {
-                            Err(serde::de::Error::custom(format!(
-                                "{ty} is not deserializable"
-                            )))
+                            Err(serde::de::Error::invalid_length(
+                                1,
+                                &"tuple with type and value",
+                            ))
                         }
                     } else {
-                        Err(serde::de::Error::unknown_variant(global_name, &[]))
+                        Err(serde::de::Error::custom(format!(
+                            "{value_type} is not deserializable"
+                        )))
                     }
                 } else {
                     Err(serde::de::Error::invalid_length(