remove ConcreteTaskInput in favor of the original rust datatypes

crates/turbo-tasks-build/src/lib.rs

@@ -18,7 +18,7 @@ use turbo_tasks_macros_shared::{
  get_impl_function_ident, get_native_function_ident, get_path_ident,
  get_register_trait_methods_ident, get_register_value_type_ident,
  get_trait_default_impl_function_ident, get_trait_impl_function_ident, get_trait_type_ident,
- get_type_ident, GenericTypeInput, PrimitiveInput, ValueTraitArguments,
+ get_type_ident, GenericTypeInput, PrimitiveInput,
 };
 
 pub fn generate_register() {
@@ -361,10 +361,10 @@ impl<'a> RegisterContext<'a> {
  }
 
  fn process_trait_inner(&mut self, trait_item: &ItemTrait) -> Result<()> {
- if let Some(attr) = trait_item
+ if trait_item
  .attrs
  .iter()
- .find(|a| is_turbo_attribute(a, "value_trait"))
+ .any(|a| is_turbo_attribute(a, "value_trait"))
  {
  let trait_ident = &trait_item.ident;
 
@@ -388,16 +388,6 @@ impl<'a> RegisterContext<'a> {
 
  let trait_type_ident = get_trait_type_ident(trait_ident);
  self.register(trait_type_ident, self.get_global_name(&[trait_ident]))?;
-
- let trait_args: ValueTraitArguments = parse_attr_args(attr)?.unwrap_or_default();
- if trait_args.debug {
- self.register_debug_impl(
- &get_type_ident(&parse_quote! {
- Box<dyn #trait_ident>
- })
- .unwrap(),
- )?;
- }
  }
  Ok(())
  }
@@ -610,14 +600,3 @@ fn is_cfg_attribute(attr: &Attribute) -> bool {
  .get_ident()
  .is_some_and(|ident| ident == "cfg" || ident == "cfg_attr")
 }
-
-fn parse_attr_args<T>(attr: &Attribute) -> syn::Result<Option<T>>
-where
- T: syn::parse::Parse,
-{
- if attr.tokens.is_empty() {
- Ok(None)
- } else {
- Ok(Some(attr.parse_args_with(T::parse)?))
- }
-}

crates/turbo-tasks-macros-shared/src/expand.rs

@@ -20,9 +20,9 @@ use syn::{
 /// These helpers should themselves call [generate_destructuring] to generate
 /// the destructure necessary to access the fields of the value.
 pub fn match_expansion<
- EN: Fn(&Ident, &FieldsNamed) -> (TokenStream, TokenStream),
- EU: Fn(&Ident, &FieldsUnnamed) -> (TokenStream, TokenStream),
- U: Fn(&Ident) -> TokenStream,
+ EN: Fn(TokenStream, &FieldsNamed) -> (TokenStream, TokenStream),
+ EU: Fn(TokenStream, &FieldsUnnamed) -> (TokenStream, TokenStream),
+ U: Fn(TokenStream) -> TokenStream,
 >(
  derive_input: &DeriveInput,
  expand_named: &EN,
@@ -33,36 +33,48 @@ pub fn match_expansion<
  let expand_unit = move |ident| (TokenStream::new(), expand_unit(ident));
  match &derive_input.data {
  Data::Enum(DataEnum { variants, .. }) => {
- let (variants_idents, (variants_fields_capture, expansion)): (
- Vec<_>,
- (Vec<_>, Vec<_>),
- ) = variants
- .iter()
- .map(|variant| {
- (
- &variant.ident,
- expand_fields(
- &variant.ident,
- &variant.fields,
- expand_named,
- expand_unnamed,
- expand_unit,
- ),
- )
- })
- .unzip();
+ let (idents, (variants_fields_capture, expansion)): (Vec<_>, (Vec<_>, Vec<_>)) =
+ variants
+  .iter()
+  .map(|variant| {
+  let variants_idents = &variant.ident;
+  let ident = quote! { #ident::#variants_idents };
+  (
+  ident.clone(),
+  expand_fields(
+  ident,
+  &variant.fields,
+  expand_named,
+  expand_unnamed,
+  expand_unit,
+  ),
+  )
+  })
+  .unzip();
 
- quote! {
- match self {
- #(
- #ident::#variants_idents #variants_fields_capture => #expansion,
- )*
+ if idents.is_empty() {
+ let (_, expansion) = expand_unit(quote! { #ident });
+ quote! {
+ #expansion
+ }
+ } else {
+ quote! {
+ match self {
+ #(
+ #idents #variants_fields_capture => #expansion,
+ )*
+ }
  }
  }
  }
  Data::Struct(DataStruct { fields, .. }) => {
- let (captures, expansion) =
- expand_fields(ident, fields, expand_named, expand_unnamed, expand_unit);
+ let (captures, expansion) = expand_fields(
+ quote! { #ident },
+ fields,
+ expand_named,
+ expand_unnamed,
+ expand_unit,
+ );
 
  if fields.is_empty() {
  assert!(captures.is_empty());
@@ -100,12 +112,12 @@ pub fn match_expansion<
 pub fn expand_fields<
  'ident,
  'fields,
- EN: Fn(&'ident Ident, &'fields FieldsNamed) -> R,
- EU: Fn(&'ident Ident, &'fields FieldsUnnamed) -> R,
- U: Fn(&'ident Ident) -> R,
+ EN: Fn(TokenStream, &'fields FieldsNamed) -> R,
+ EU: Fn(TokenStream, &'fields FieldsUnnamed) -> R,
+ U: Fn(TokenStream) -> R,
  R,
 >(
- ident: &'ident Ident,
+ ident: TokenStream,
  fields: &'fields Fields,
  expand_named: EN,
  expand_unnamed: EU,

crates/turbo-tasks-macros-tests/Cargo.toml

@@ -7,6 +7,7 @@ edition = "2021"
 
 [dev-dependencies]
 anyhow = { workspace = true }
+serde = { workspace = true }
 tokio = { workspace = true }
 turbo-tasks = { workspace = true }
 turbo-tasks-memory = { workspace = true }

crates/turbo-tasks-macros-tests/tests/task_input.rs

@@ -2,12 +2,13 @@
 //! However, we keep one test here as an integration test between the derive
 //! macro and the `#[turbo_tasks::function]` macro.
 
+use serde::{Deserialize, Serialize};
 use turbo_tasks::{Completion, TaskInput, Vc};
 use turbo_tasks_testing::{register, run};
 
 register!();
 
-#[derive(Clone, TaskInput)]
+#[derive(Clone, TaskInput, Debug, PartialEq, Eq, Hash, Serialize, Deserialize)]
 struct OneUnnamedField(u32);
 
 #[turbo_tasks::function]

crates/turbo-tasks-macros/src/derive/deterministic_hash_macro.rs

@@ -1,5 +1,5 @@
 use proc_macro::TokenStream;
-use proc_macro2::{Ident, TokenStream as TokenStream2};
+use proc_macro2::TokenStream as TokenStream2;
 use quote::quote;
 use syn::{parse_macro_input, Data, DeriveInput, FieldsNamed, FieldsUnnamed};
 use turbo_tasks_macros_shared::{generate_exhaustive_destructuring, match_expansion};
@@ -35,7 +35,7 @@ pub fn derive_deterministic_hash(input: TokenStream) -> TokenStream {
 
 /// Hashes a struct or enum variant with named fields (e.g. `struct Foo {
 /// bar: u32 }`, `Foo::Bar { baz: u32 }`).
-fn hash_named(_ident: &Ident, fields: &FieldsNamed) -> (TokenStream2, TokenStream2) {
+fn hash_named(_ident: TokenStream2, fields: &FieldsNamed) -> (TokenStream2, TokenStream2) {
  let (captures, fields_idents) = generate_exhaustive_destructuring(fields.named.iter());
  (
  captures,
@@ -49,7 +49,7 @@ fn hash_named(_ident: &Ident, fields: &FieldsNamed) -> (TokenStream2, TokenStrea
 
 /// Hashes a struct or enum variant with unnamed fields (e.g. `struct
 /// Foo(u32)`, `Foo::Bar(u32)`).
-fn hash_unnamed(_ident: &Ident, fields: &FieldsUnnamed) -> (TokenStream2, TokenStream2) {
+fn hash_unnamed(_ident: TokenStream2, fields: &FieldsUnnamed) -> (TokenStream2, TokenStream2) {
  let (captures, fields_idents) = generate_exhaustive_destructuring(fields.unnamed.iter());
  (
  captures,
@@ -62,6 +62,6 @@ fn hash_unnamed(_ident: &Ident, fields: &FieldsUnnamed) -> (TokenStream2, TokenS
 }
 
 /// Hashes a unit struct or enum variant (e.g. `struct Foo;`, `Foo::Bar`).
-fn hash_unit(_ident: &Ident) -> TokenStream2 {
+fn hash_unit(_ident: TokenStream2) -> TokenStream2 {
  quote! { { } }
 }