Include crate names in global names and enforce uniqueness of global names during registration

Author: lukesandberg

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

@@ -5,6 +5,8 @@
 use std::future::IntoFuture;
 
 use anyhow::Result;
+use once_cell::sync::Lazy;
+use regex::Regex;
 use serde_json::json;
 use turbo_tasks::Vc;
 use turbo_tasks_testing::{Registration, register, run_without_cache_check};
@@ -257,16 +259,12 @@ fn stats_json() -> serde_json::Value {
 
 // Global task identifiers can contain the crate name, remove it to simplify test assertions
 fn remove_crate(mut json: serde_json::Value) -> serde_json::Value {
+    static HASH_RE: Lazy<Regex> = Lazy::new(|| Regex::new("^[^:@]+@[^:]+:+").unwrap());
     match &mut json {
         serde_json::Value::Object(map) => {
             let old_map = std::mem::take(map);
             for (k, v) in old_map {
-                map.insert(
-                    k.strip_prefix(concat!(module_path!(), "::"))
-                        .unwrap()
-                        .to_string(),
-                    v,
-                );
+                map.insert(HASH_RE.replace(&k, "").into_owned(), v);
             }
         }
         _ => unreachable!("expected object"),

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@turbo_tasks::primitives::u64)
   self:
-    Adder::new (read cell of type trace_transient::Adder)
+    Adder::new (read cell of type turbo-tasks-backend@trace_transient::Adder)
       args:
-        unknown transient task (read cell of type turbo_tasks::primitives::())
+        unknown transient task (read cell of type turbo-tasks@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@turbo_tasks::primitives::u16)
+    unknown transient task (read cell of type turbo-tasks@turbo_tasks::primitives::u32)";
 
 #[tokio::test(flavor = "multi_thread", worker_threads = 2)]
 async fn test_trace_transient() {

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

@@ -3,8 +3,9 @@ use quote::quote;
 use syn::{ItemFn, parse_macro_input, parse_quote};
 use turbo_tasks_macros_shared::{get_native_function_ident, is_self_used};
 
-use crate::func::{
-    DefinitionContext, FunctionArguments, NativeFn, TurboFn, filter_inline_attributes,
+use crate::{
+    func::{DefinitionContext, FunctionArguments, NativeFn, TurboFn, filter_inline_attributes},
+    global_name::global_name,
 };
 
 /// This macro generates the virtual function that powers turbo tasks.
@@ -58,7 +59,7 @@ pub fn function(args: TokenStream, input: TokenStream) -> TokenStream {
     let function_path_string = ident.to_string();
 
     let native_fn = NativeFn {
-        function_global_name: quote! { concat!(module_path!(), "::", #function_path_string)},
+        function_global_name: global_name(&function_path_string),
         function_path_string,
         function_path: parse_quote! { #inline_function_ident },
         is_method: turbo_fn.is_method(),

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

@@ -4,7 +4,7 @@ use rustc_hash::FxHashSet;
 use syn::{GenericParam, Lifetime, Type, parse_macro_input, spanned::Spanned, visit_mut::VisitMut};
 use turbo_tasks_macros_shared::{GenericTypeInput, get_type_ident};
 
-use crate::value_macro::value_type_and_register;
+use crate::{global_name::global_name, value_macro::value_type_and_register};
 
 pub fn generic_type(input: TokenStream) -> TokenStream {
     let mut input = parse_macro_input!(input as GenericTypeInput);
@@ -44,10 +44,10 @@ pub fn generic_type(input: TokenStream) -> TokenStream {
 
     let (impl_generics, _, where_clause) = input.generics.split_for_impl();
 
-    let repr = replace_generics_with_unit(input.generics.params.iter(), &input.ty);
+    let ty = &input.ty;
+    let repr = replace_generics_with_unit(input.generics.params.iter(), ty);
 
-    let ty = input.ty;
-    let Some(ident) = get_type_ident(&ty) else {
+    let Some(ident) = get_type_ident(ty) else {
         return quote! {
             // An error occurred while parsing the ident.
         }
@@ -64,6 +64,7 @@ pub fn generic_type(input: TokenStream) -> TokenStream {
         }
     }
 
+    let name = global_name(quote! {stringify!(#repr) });
     let value_type_and_register = value_type_and_register(
         &ident,
         quote! { #ty },
@@ -75,9 +76,7 @@ pub fn generic_type(input: TokenStream) -> TokenStream {
             turbo_tasks::VcCellSharedMode<#ty>
         },
         quote! {
-            turbo_tasks::ValueType::new_with_any_serialization::<#repr>(
-                concat!(module_path!(), "::", stringify!(#repr))
-            )
+            turbo_tasks::ValueType::new_with_any_serialization::<#repr>(#name)
         },
     );
 

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

@@ -0,0 +1,11 @@
+use proc_macro2::TokenStream;
+use quote::quote;
+
+/// Composes an expression that will evaluate to a &'static str of the fully qualified name
+///
+/// The name is prefixed with the current crate name and module path
+pub(crate) fn global_name(local_name: impl quote::ToTokens) -> TokenStream {
+    let crate_name =
+        std::env::var("CARGO_PKG_NAME").unwrap_or_else(|_| "unknown_crate".to_string());
+    quote! { concat!(#crate_name, "@", module_path!(), "::", #local_name)}
+}

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

@@ -8,6 +8,7 @@ mod derive;
 mod func;
 mod function_macro;
 mod generic_type_macro;
+mod global_name;
 mod primitive_macro;
 mod value_impl_macro;
 mod value_macro;

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

@@ -3,7 +3,7 @@ use quote::quote;
 use syn::parse_macro_input;
 use turbo_tasks_macros_shared::{PrimitiveInput, get_type_ident};
 
-use crate::value_macro::value_type_and_register;
+use crate::{global_name::global_name, value_macro::value_type_and_register};
 
 pub fn primitive(input: TokenStream) -> TokenStream {
     let input = parse_macro_input!(input as PrimitiveInput);
@@ -32,7 +32,7 @@ pub fn primitive(input: TokenStream) -> TokenStream {
             }
         }
     };
-
+    let name = global_name(quote! {stringify!(#ty) });
     let value_type_and_register = value_type_and_register(
         &ident,
         quote! { #ty },
@@ -44,9 +44,7 @@ pub fn primitive(input: TokenStream) -> TokenStream {
             turbo_tasks::VcCellSharedMode<#ty>
         },
         quote! {
-            turbo_tasks::ValueType::new_with_any_serialization::<#ty>(
-                concat!(module_path!(), "::", stringify!(#ty))
-            )
+            turbo_tasks::ValueType::new_with_any_serialization::<#ty>(#name)
         },
     );
 

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

@@ -13,9 +13,12 @@ use turbo_tasks_macros_shared::{
     get_trait_impl_function_ident, get_type_ident, is_self_used,
 };
 
-use crate::func::{
-    DefinitionContext, FunctionArguments, NativeFn, TurboFn, filter_inline_attributes,
-    split_function_attributes,
+use crate::{
+    func::{
+        DefinitionContext, FunctionArguments, NativeFn, TurboFn, filter_inline_attributes,
+        split_function_attributes,
+    },
+    global_name::global_name,
 };
 
 struct ValueImplArguments {
@@ -110,7 +113,7 @@ pub fn value_impl(args: TokenStream, input: TokenStream) -> TokenStream {
                 let inline_attrs = filter_inline_attributes(attrs.iter().copied());
                 let function_path_string = format!("{ty}::{ident}", ty = ty.to_token_stream());
                 let native_fn = NativeFn {
-                    function_global_name: quote! { concat!(module_path!(), "::", #function_path_string)},
+                    function_global_name: global_name(&function_path_string),
                     function_path_string,
                     function_path: parse_quote! { <#ty>::#inline_function_ident },
                     is_method: turbo_fn.is_method(),
@@ -224,10 +227,13 @@ pub fn value_impl(args: TokenStream, input: TokenStream) -> TokenStream {
                 let (inline_signature, inline_block) =
                     turbo_fn.inline_signature_and_block(block, is_self_used);
                 let inline_attrs = filter_inline_attributes(attrs.iter().copied());
-
                 let native_fn = NativeFn {
                     // This global name breaks the pattern.  It isn't clear if it is intentional
-                    function_global_name: quote! { concat!(module_path!(), "::", stringify!(#ty), "::", stringify!(#trait_path), "::", stringify!(#ident))},
+                    function_global_name: global_name(format!(
+                        "{ty}::{trait_path}::{ident}",
+                        ty = ty.to_token_stream(),
+                        trait_path = trait_path.to_token_stream()
+                    )),
                     function_path_string: format!(
                         "<{ty} as {trait_path}>::{ident}",
                         ty = ty.to_token_stream(),
@@ -287,7 +293,7 @@ pub fn value_impl(args: TokenStream, input: TokenStream) -> TokenStream {
                 });
             }
         }
-
+        let value_name = global_name(quote! {stringify!(#ty_ident)});
         quote! {
             // Register all the function impls so the ValueType can find them
             // This means objects resolve as
@@ -297,13 +303,13 @@ pub fn value_impl(args: TokenStream, input: TokenStream) -> TokenStream {
             // 4.VTableRegistries (requires ValueTypeIds)
             turbo_tasks::macro_helpers::inventory_submit!{
                 turbo_tasks::macro_helpers::CollectableTraitMethods(
-                    concat!(module_path!(), "::", stringify!(#ty_ident)),
+                    #value_name,
                     || (<::std::boxed::Box<dyn #trait_path> as turbo_tasks::VcValueTrait>::get_trait_type_id(),
                         vec![#(#trait_methods)*])
                 )
             }
 
-            // These can execute later so they can reference value_types during registration
+            // These can execute later so they can reference trait_types during registration
 
             turbo_tasks::macro_helpers::inventory_submit!{
                 turbo_tasks::macro_helpers::CollectableTraitCastFunctions(

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

@@ -13,6 +13,8 @@ use syn::{
 };
 use turbo_tasks_macros_shared::get_value_type_ident;
 
+use crate::global_name::global_name;
+
 enum IntoMode {
     None,
     New,
@@ -384,17 +386,14 @@ pub fn value(args: TokenStream, input: TokenStream) -> TokenStream {
         });
     }
 
+    let name = global_name(quote! {stringify!(#ident) });
     let new_value_type = match serialization_mode {
         SerializationMode::None => quote! {
-            turbo_tasks::ValueType::new::<#ident>(
-                concat!(module_path!(), "::", stringify!(#ident))
-            )
+            turbo_tasks::ValueType::new::<#ident>(#name)
         },
         SerializationMode::Auto | SerializationMode::Custom => {
             quote! {
-                turbo_tasks::ValueType::new_with_any_serialization::<#ident>(
-                    concat!(module_path!(), "::", stringify!(#ident))
-                )
+                turbo_tasks::ValueType::new_with_any_serialization::<#ident>(#name)
             }
         }
     };

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

@@ -8,9 +8,12 @@ use turbo_tasks_macros_shared::{
     ValueTraitArguments, get_trait_default_impl_function_ident, get_trait_type_ident, is_self_used,
 };
 
-use crate::func::{
-    DefinitionContext, FunctionArguments, NativeFn, TurboFn, filter_inline_attributes,
-    split_function_attributes,
+use crate::{
+    func::{
+        DefinitionContext, FunctionArguments, NativeFn, TurboFn, filter_inline_attributes,
+        split_function_attributes,
+    },
+    global_name::global_name,
 };
 
 pub fn value_trait(args: TokenStream, input: TokenStream) -> TokenStream {
@@ -177,7 +180,7 @@ pub fn value_trait(args: TokenStream, input: TokenStream) -> TokenStream {
 
             let function_path_string = format!("{trait_ident}::{ident}");
             let native_function = NativeFn {
-                function_global_name: quote! { concat!(module_path!(), "::", #function_path_string)},
+                function_global_name: global_name(&function_path_string),
                 function_path_string,
                 function_path: parse_quote! {
                     <Box<dyn #trait_ident> as #inline_extension_trait_ident>::#inline_function_ident
@@ -266,6 +269,7 @@ pub fn value_trait(args: TokenStream, input: TokenStream) -> TokenStream {
         extended_supertraits.push(quote!(turbo_tasks::debug::ValueDebug));
     }
 
+    let trait_name = global_name(quote! {stringify!(#trait_ident)});
     let expanded = quote! {
         #[must_use]
         #(#attrs)*
@@ -280,7 +284,7 @@ pub fn value_trait(args: TokenStream, input: TokenStream) -> TokenStream {
             turbo_tasks::macro_helpers::Lazy::new(|| {
                 turbo_tasks::TraitType::new(
                     stringify!(#trait_ident),
-                    concat!(module_path!(), "::", stringify!(#trait_ident)),
+                    #trait_name,
                     vec![#(#trait_methods)*])
             });