perf(turbo-tasks): Filter out and do not cache unused arguments

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

@@ -27,7 +27,7 @@
 
     output: Type,
     this: Option<Input>,
-    inputs: Vec<Input>,
+    exposed_inputs: Vec<Input>,
     /// Should we return `OperationVc` and require that all arguments are `NonLocalValue`s?
     operation: bool,
     /// Should this function use `TaskPersistence::LocalCells`?
@@ -75,7 +75,7 @@
 
         let mut raw_inputs = orig_signature.inputs.iter();
         let mut this = None;
-        let mut inputs = Vec::with_capacity(raw_inputs.len());
+        let mut exposed_inputs = Vec::with_capacity(raw_inputs.len());
 
         if let Some(possibly_receiver) = raw_inputs.next() {
             match possibly_receiver {
@@ -218,7 +218,7 @@
                             }
                             let ident = ident.ident.clone();
 
-                            inputs.push(Input {
+                            exposed_inputs.push(Input {
                                 ident,
                                 ty: (*typed.ty).clone(),
                             });
@@ -227,7 +227,7 @@
                         // We can't support destructuring patterns (or other kinds of patterns).
                         let ident = Ident::new("arg1", typed.pat.span());
 
-                        inputs.push(Input {
+                        exposed_inputs.push(Input {
                             ident,
                             ty: (*typed.ty).clone(),
                         });
@@ -249,7 +249,7 @@
                         Ident::new(&format!("arg{}", i + 2), typed.pat.span())
                     };
 
-                    inputs.push(Input {
+                    exposed_inputs.push(Input {
                         ident,
                         ty: (*typed.ty).clone(),
                     });
@@ -272,7 +272,7 @@
             ident: orig_ident,
             output,
             this,
-            inputs,
+            exposed_inputs,
             operation: args.operation.is_some(),
             local: args.local.is_some(),
             inline_ident,
@@ -286,7 +286,7 @@
             .this
             .as_ref()
             .into_iter()
-            .chain(self.inputs.iter())
+            .chain(self.exposed_inputs.iter())
             .map(|input| {
                 FnArg::Typed(PatType {
                     attrs: Vec::new(),
@@ -348,6 +348,15 @@
             .orig_signature
             .inputs
             .iter()
+            .filter(|arg| {
+                let FnArg::Typed(pat_type) = arg else {
+                    return true;
+                };
+                let Pat::Ident(pat_id) = &*pat_type.pat else {
+                    return true;
+                };
+                inline_inputs_identifier_filter(&pat_id.ident)
+            })
             .enumerate()
             .map(|(idx, arg)| match arg {
                 FnArg::Receiver(_) => (arg.clone(), None),
@@ -470,12 +479,18 @@
         &self.inline_ident
     }
 
-    fn input_idents(&self) -> impl Iterator<Item = &Ident> {
-        self.inputs.iter().map(|Input { ident, .. }| ident)
+    fn inline_input_idents(&self) -> impl Iterator<Item = &Ident> {
+        self.exposed_inputs
+            .iter()
+            .map(|Input { ident, .. }| ident)
+            .filter(|id| inline_inputs_identifier_filter(id))
     }
 
     pub fn input_types(&self) -> Vec<&Type> {
-        self.inputs.iter().map(|Input { ty, .. }| ty).collect()
+        self.exposed_inputs
+            .iter()
+            .map(|Input { ty, .. }| ty)
+            .collect()
     }
 
     pub fn persistence(&self) -> impl ToTokens {
@@ -557,7 +572,7 @@
         let ident = &self.ident;
         let output = &self.output;
         let assertions = self.get_assertions();
-        let inputs = self.input_idents();
+        let inputs = self.inline_input_idents();
         let persistence = self.persistence_with_this();
         parse_quote! {
             {
@@ -582,7 +597,7 @@
     /// given native function.
     pub fn static_block(&self, native_function_id_ident: &Ident) -> Block {
         let output = &self.output;
-        let inputs = self.input_idents();
+        let inputs = self.inline_input_idents();
         let assertions = self.get_assertions();
         let mut block = if let Some(converted_this) = self.converted_this() {
             let persistence = self.persistence_with_this();
@@ -1036,17 +1051,18 @@
     pub function_path_string: String,
     pub function_path: ExprPath,
     pub is_method: bool,
+    pub filter_trait_call_args: Option<TokenStream>,
     pub local: bool,
     pub local_cells: bool,
 }
 
 impl NativeFn {
     pub fn ty(&self) -> Type {
-        parse_quote! { turbo_tasks::NativeFunction }
+        parse_quote! { turbo_tasks::macro_helpers::NativeFunction }
     }
 
     pub fn definition(&self) -> TokenStream {
         let Self {
             function_path_string,
             function_path,
             is_method,
@@ -1055,24 +1071,40 @@
         } = self;
 
         let constructor = if *is_method {
-            quote! { new_method }
+            let arg_meta = if let Some(filter) = self.filter_trait_call_args {
+                quote! { turbo_tasks::macro_helpers::ArgMeta::with_filter_trait_call_args(#filter) }
+            } else {
+                quote! { turbo_tasks::macro_helpers::ArgMeta::new() }
+            };
+            quote! {
+                {
+                    #[allow(deprecated)]
+                    turbo_tasks::macro_helpers::NativeFunction::new_method(
+                        #function_path_string.to_owned(),
+                        turbo_tasks::macro_helpers::FunctionMeta {
+                            local: #local,
+                            local_cells: #local_cells,
+                        },
+                        turbo_tasks::macro_helpers::ArgMeta::new(),
+                        #function_path,
+                    )
+                }
+            }
         } else {
-            quote! { new_function }
-        };
-
-        quote! {
-            {
-                #[allow(deprecated)]
-                turbo_tasks::NativeFunction::#constructor(
-                    #function_path_string.to_owned(),
-                    turbo_tasks::FunctionMeta {
-                        local: #local,
-                        local_cells: #local_cells,
-                    },
-                    #function_path,
-                )
+            quote! {
+                {
+                    #[allow(deprecated)]
+                    turbo_tasks::macro_helpers::NativeFunction::new_function(
+                        #function_path_string.to_owned(),
+                        turbo_tasks::macro_helpers::FunctionMeta {
+                            local: #local,
+                            local_cells: #local_cells,
+                        },
+                        #function_path,
+                    )
+                }
             }
-        }
+        };
     }
 
     pub fn id_ty(&self) -> Type {
@@ -1095,3 +1127,8 @@
         .filter(|attr| attr.path.get_ident().is_none_or(|id| id != "doc"))
         .collect()
 }
+
+pub fn inline_inputs_identifier_filter(arg_ident: &Ident) -> bool {
+    // filter out underscore-prefixed (unused) arguments, we don't need to cache these
+    !arg_ident.to_string().starts_with('_')
+}

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

@@ -107,7 +107,6 @@ pub use manager::{
     CurrentCellRef, ReadConsistency, TaskPersistence, TurboTasks, TurboTasksApi,
     TurboTasksBackendApi, TurboTasksBackendApiExt, TurboTasksCallApi, Unused, UpdateInfo,
 };
-pub use native_function::{FunctionMeta, NativeFunction};
 pub use output::OutputContent;
 pub use raw_vc::{CellId, RawVc, ReadRawVcFuture, ResolveTypeError};
 pub use read_ref::ReadRef;

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

@@ -11,8 +11,11 @@ pub use super::{
     manager::{find_cell_by_type, notify_scheduled_tasks, spawn_detached_for_testing},
 };
 use crate::{
-    debug::ValueDebugFormatString, shrink_to_fit::ShrinkToFit, task::TaskOutput, NonLocalValue,
-    RawVc, TaskInput, TaskPersistence, Vc,
+    debug::ValueDebugFormatString,
+    native_function::{ArgMeta, FunctionMeta, NativeFunction},
+    shrink_to_fit::ShrinkToFit,
+    task::TaskOutput,
+    NonLocalValue, RawVc, TaskInput, TaskPersistence, Vc,
 };
 
 #[inline(never)]

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

@@ -37,6 +37,7 @@ use crate::{
     },
     id_factory::{IdFactory, IdFactoryWithReuse},
     magic_any::MagicAny,
+    native_function::FunctionMeta,
     raw_vc::{CellId, RawVc},
     registry::{self, get_function},
     serialization_invalidation::SerializationInvalidator,
@@ -48,8 +49,8 @@ use crate::{
     trait_helpers::get_trait_method,
     util::StaticOrArc,
     vc::ReadVcFuture,
-    Completion, FunctionMeta, InvalidationReason, InvalidationReasonSet, ResolvedVc,
-    SharedReference, TaskId, TaskIdSet, ValueTypeId, Vc, VcRead, VcValueTrait, VcValueType,
+    Completion, InvalidationReason, InvalidationReasonSet, ResolvedVc, SharedReference, TaskId,
+    TaskIdSet, ValueTypeId, Vc, VcRead, VcValueTrait, VcValueType,
 };
 
 pub trait TurboTasksCallApi: Sync + Send {

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

@@ -1,4 +1,4 @@
-use std::{fmt::Debug, hash::Hash, pin::Pin};
+use std::{env::args, fmt::Debug, hash::Hash, pin::Pin};
 
 use anyhow::{Context, Result};
 use futures::Future;
@@ -23,15 +23,28 @@ type ResolveFunctor =
 
 type IsResolvedFunctor = fn(&dyn MagicAny) -> bool;
 
+type FilterArgsFunctor = for<'a> fn(Box<dyn MagicAny>) -> Box<dyn MagicAny>;
+
 pub struct ArgMeta {
     serializer: MagicAnySerializeSeed,
     deserializer: MagicAnyDeserializeSeed,
     is_resolved: IsResolvedFunctor,
     resolve: ResolveFunctor,
+    filter_trait_call_args: FilterArgsFunctor,
 }
 
 impl ArgMeta {
     pub fn new<T>() -> Self
+    where
+        T: TaskInput + Serialize + for<'de> Deserialize<'de> + 'static,
+    {
+        fn noop_filter_args(args: Box<dyn MagicAny>) -> Box<dyn MagicAny> {
+            args
+        }
+        Self::with_filter_trait_call_args::<T>(noop_filter_args)
+    }
+
+    pub fn with_filter_trait_call_args<T>(filter_trait_call_args: FilterArgsFunctor) -> Self
     where
         T: TaskInput + Serialize + for<'de> Deserialize<'de> + 'static,
     {
@@ -64,6 +77,7 @@ impl ArgMeta {
                     Ok(Box::new(resolved) as Box<dyn MagicAny>)
                 })
             },
+            filter_trait_call_args,
         }
     }
 
@@ -144,6 +158,7 @@ impl NativeFunction {
     pub fn new_method<Mode, This, Inputs, I>(
         name: String,
         function_meta: FunctionMeta,
+        arg_meta: ArgMeta,
         implementation: I,
     ) -> Self
     where

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

@@ -12,8 +12,9 @@ use rustc_hash::FxHasher;
 use crate::{
     id::{FunctionId, TraitTypeId, ValueTypeId},
     id_factory::IdFactory,
+    native_function::NativeFunction,
     no_move_vec::NoMoveVec,
-    NativeFunction, TraitType, ValueType,
+    TraitType, ValueType,
 };
 
 type FxDashMap<K, V> = DashMap<K, V, BuildHasherDefault<FxHasher>>;