Fix global names for values

Author: lukesandberg

turbopack/crates/turbo-tasks-backend/tests/trace_transient.rs

@@ -9,14 +9,14 @@ use turbo_tasks_testing::{Registration, register, run_without_cache_check};
 static REGISTRATION: Registration = register!();
 
 const EXPECTED_TRACE: &str = "\
-Adder::add_method (read cell of type turbo-tasks::primitives::u64)
+Adder::add_method (read cell of type turbo_tasks::primitives::u64)
   self:
-    Adder::new (read cell of type turbo-tasks-backend::Adder)
+    Adder::new (read cell of type trace_transient::Adder)
       args:
-        unknown transient task (read cell of type turbo-tasks::primitives::unit)
+        unknown transient task (read cell of type turbo_tasks::primitives::())
   args:
-    unknown transient task (read cell of type turbo-tasks::primitives::u16)
-    unknown transient task (read cell of type turbo-tasks::primitives::u32)";
+    unknown transient task (read cell of type turbo_tasks::primitives::u16)
+    unknown transient task (read cell of type turbo_tasks::primitives::u32)";
 
 #[tokio::test(flavor = "multi_thread", worker_threads = 2)]
 async fn test_trace_transient() {

turbopack/crates/turbo-tasks-macros/src/generic_type_macro.rs

@@ -75,7 +75,9 @@ pub fn generic_type(input: TokenStream) -> TokenStream {
             turbo_tasks::VcCellSharedMode<#ty>
         },
         quote! {
-            turbo_tasks::ValueType::new_with_any_serialization::<#repr>()
+            turbo_tasks::ValueType::new_with_any_serialization::<#repr>(
+                concat!(module_path!(), "::", stringify!(#repr))
+            )
         },
     );
 

turbopack/crates/turbo-tasks-macros/src/primitive_macro.rs

@@ -44,7 +44,9 @@ pub fn primitive(input: TokenStream) -> TokenStream {
             turbo_tasks::VcCellSharedMode<#ty>
         },
         quote! {
-            turbo_tasks::ValueType::new_with_any_serialization::<#ty>()
+            turbo_tasks::ValueType::new_with_any_serialization::<#ty>(
+                concat!(module_path!(), "::", stringify!(#ty))
+            )
         },
     );
 

turbopack/crates/turbo-tasks-macros/src/value_macro.rs

@@ -386,11 +386,15 @@ pub fn value(args: TokenStream, input: TokenStream) -> TokenStream {
 
     let new_value_type = match serialization_mode {
         SerializationMode::None => quote! {
-            turbo_tasks::ValueType::new::<#ident>()
+            turbo_tasks::ValueType::new::<#ident>(
+                concat!(module_path!(), "::", stringify!(#ident))
+            )
         },
         SerializationMode::Auto | SerializationMode::Custom => {
             quote! {
-                turbo_tasks::ValueType::new_with_any_serialization::<#ident>()
+                turbo_tasks::ValueType::new_with_any_serialization::<#ident>(
+                    concat!(module_path!(), "::", stringify!(#ident))
+                )
             }
         }
     };

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

@@ -41,11 +41,13 @@ struct Values {
 static VALUES: Lazy<Values> = Lazy::new(|| {
     // Inventory does not guarantee an order. So we sort by the global name to get a stable order
     // This ensures that assigned ids are also stable.
+    // We don't currently take advantage of this but we could in the future.  The remaining issue is
+    // ensuring the set of values is the same across runs.
     let mut all_values = inventory::iter::<CollectableValueType>
         .into_iter()
         .map(|t| &**t.0)
         .collect::<Vec<_>>();
-    all_values.sort_by_key(|t| t.name);
+    all_values.sort_by_key(|t| t.global_name);
 
     let mut value_to_id = FxHashMap::default();
     value_to_id.reserve(all_values.len());
@@ -56,11 +58,11 @@ static VALUES: Lazy<Values> = Lazy::new(|| {
         // SAFETY: as a usize, usize+1 is definitely non-zero.
         let id = unsafe { ValueTypeId::new_unchecked((index + 1).try_into().unwrap()) };
         value_to_id.insert(value_type, id);
-        let prev = global_name_to_value.insert(value_type.name, (id, value_type));
+        let prev = global_name_to_value.insert(value_type.global_name, (id, value_type));
         debug_assert!(
             prev.is_none(),
             "two traits registered with the same name: {}",
-            value_type.name
+            value_type.global_name
         );
     }
 
@@ -92,7 +94,7 @@ pub fn get_value_type(id: ValueTypeId) -> &'static ValueType {
 }
 
 pub fn get_value_type_global_name(id: ValueTypeId) -> &'static str {
-    get_value_type(id).name
+    get_value_type(id).global_name
 }
 
 struct Traits {

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

@@ -35,6 +35,8 @@ type RawCellFactoryFn = fn(TypedSharedReference) -> RawVc;
 pub struct ValueType {
     /// A readable name of the type
     pub name: &'static str,
+    /// The fully qualitifed global name of the type.
+    pub global_name: &'static str,
     /// Set of traits available
     traits: AutoSet<TraitTypeId>,
     /// List of trait methods available
@@ -105,9 +107,10 @@ pub fn any_as_serialize<T: Any + Serialize + Send + Sync + 'static>(
 
 impl ValueType {
     /// This is internally used by `#[turbo_tasks::value]`
-    pub fn new<T: VcValueType>() -> Self {
+    pub fn new<T: VcValueType>(global_name: &'static str) -> Self {
         Self {
             name: std::any::type_name::<T>(),
+            global_name,
             traits: AutoSet::new(),
             trait_methods: AutoMap::new(),
             magic_serialization: None,
@@ -119,9 +122,12 @@ impl ValueType {
     /// This is internally used by `#[turbo_tasks::value]`
     pub fn new_with_any_serialization<
         T: VcValueType + Any + Serialize + for<'de> Deserialize<'de>,
-    >() -> Self {
+    >(
+        global_name: &'static str,
+    ) -> Self {
         Self {
             name: std::any::type_name::<T>(),
+            global_name,
             traits: AutoSet::new(),
             trait_methods: AutoMap::new(),
             magic_serialization: None,