Clean up some debugging leftovers add docs

Author: lukesandberg

turbopack/crates/turbo-tasks-fs/src/watcher.rs

@@ -9,7 +9,7 @@ use std::{
     time::Duration,
 };
 
-use anyhow::Result;
+use anyhow::{Context, Result};
 use notify::{
     event::{MetadataKind, ModifyKind, RenameMode},
     Config, EventKind, PollWatcher, RecommendedWatcher, RecursiveMode, Watcher,

turbopack/crates/turbo-tasks-macros-shared/src/primitive_input.rs

@@ -1,7 +1,6 @@
 use proc_macro2::Span;
 use syn::{
     parse::{Parse, ParseStream},
-    punctuated::Punctuated,
     spanned::Spanned,
     Meta, Result, Token, Type,
 };
@@ -20,8 +19,7 @@ impl Parse for PrimitiveInput {
             manual_shrink_to_fit: None,
         };
         if input.parse::<Option<Token![,]>>()?.is_some() {
-            let punctuated: Punctuated<Meta, Token![,]> =
-                input.parse_terminated(Meta::parse, Token![,])?;
+            let punctuated = input.parse_terminated(Meta::parse, Token![,])?;
             for meta in punctuated {
                 match (
                     meta.path()

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

@@ -317,32 +317,6 @@ impl TurboFn<'_> {
         orig_block: &'a Block,
     ) -> (Signature, Cow<'a, Block>) {
         let mut shadow_self = None;
-
-        fn transform_from_task_input(
-            span: Span,
-            arg_id: Cow<'_, Ident>,
-            orig_ty: &Type,
-            pat: Pat,
-        ) -> Stmt {
-            Stmt::Local(Local {
-                attrs: Vec::new(),
-                let_token: Default::default(),
-                pat,
-                init: Some(LocalInit {
-                    eq_token: Default::default(),
-                    // we know the argument implements `FromTaskInput` because
-                    // `expand_task_input_type` returned `Cow::Owned`
-                    expr: parse_quote_spanned! {
-                        span =>
-                        <#orig_ty as turbo_tasks::task::FromTaskInput>::from_task_input(
-                            #arg_id
-                        )
-                    },
-                    diverge: None,
-                }),
-                semi_token: Default::default(),
-            })
-        }
         let (inputs, transform_stmts): (Punctuated<_, _>, Vec<Option<_>>) = self
             .orig_signature
             .inputs
@@ -368,6 +342,27 @@ impl TurboFn<'_> {
                     // common-case: skip if no type conversion is needed
                     return (arg.clone(), None);
                 };
+                // Helper to produce the transform statement
+                let transform_from_task_input = |arg_id: Cow<'_, Ident>, pat: Pat| {
+                    Stmt::Local(Local {
+                        attrs: Vec::new(),
+                        let_token: Default::default(),
+                        pat,
+                        init: Some(LocalInit {
+                            eq_token: Default::default(),
+                            // we know the argument implements `FromTaskInput` because
+                            // `expand_task_input_type` returned `Cow::Owned`
+                            expr: parse_quote_spanned! {
+                                arg.span() =>
+                                <#ty as turbo_tasks::task::FromTaskInput>::from_task_input(
+                                    #arg_id
+                                )
+                            },
+                            diverge: None,
+                        }),
+                        semi_token: Default::default(),
+                    })
+                };
                 match arg {
                     FnArg::Receiver(
                         receiver @ Receiver {
@@ -400,12 +395,8 @@ impl TurboFn<'_> {
                             subpat: None,
                         });
                         let self_ident = Cow::Owned(Ident::new("self", self_token.span()));
-                        let transform_stmt = transform_from_task_input(
-                            receiver.span(),
-                            self_ident,
-                            ty,
-                            shadow_self_pattern,
-                        );
+                        let transform_stmt =
+                            transform_from_task_input(self_ident, shadow_self_pattern);
 
                         (arg, Some(transform_stmt))
                     }
@@ -435,10 +426,8 @@ impl TurboFn<'_> {
 
                         // convert an argument of type `FromTaskInput<T>::TaskInput` into `T`.
                         // essentially, replace any instances of `Vc` with `ResolvedVc`.
-                        let orig_ty = &*pat_type.ty;
                         let pat = (&*pat_type.pat).clone();
-                        let transform_stmt =
-                            transform_from_task_input(pat_type.span(), arg_id, orig_ty, pat);
+                        let transform_stmt = transform_from_task_input(arg_id, pat);
 
                         (arg, Some(transform_stmt))
                     }
@@ -716,6 +705,7 @@ enum IoMarker {
     Network,
 }
 
+// Optionally parses `T` from a parethensized attributes, returns `T::default` otherwise.
 pub fn parse_with_optional_parens<T: Parse + Default>(attr: &Attribute) -> syn::Result<T> {
     match &attr.meta {
         Meta::Path(_) => Ok(T::default()),

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

@@ -29,7 +29,6 @@ use crate::func::{
 pub fn function(args: TokenStream, input: TokenStream) -> TokenStream {
     let mut errors = Vec::new();
 
-    // log_syntax!(args);
     let ItemFn {
         attrs,
         vis,

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

@@ -2,7 +2,6 @@
 #![feature(proc_macro_diagnostic)]
 #![feature(allow_internal_unstable)]
 #![feature(box_patterns)]
-#![feature(log_syntax)]
 
 mod assert_fields;
 mod derive;

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

@@ -6,7 +6,7 @@ use syn::{
     parse_macro_input, parse_quote,
     spanned::Spanned,
     Attribute, Error, Expr, ExprLit, Generics, ImplItem, ImplItemFn, ItemImpl, Lit, LitStr, Meta,
-    MetaNameValue, Path, Result, Token, Type,
+    MetaNameValue, Path, Token, Type,
 };
 use turbo_tasks_macros_shared::{
     get_inherent_impl_function_id_ident, get_inherent_impl_function_ident, get_path_ident,
@@ -65,7 +65,7 @@ struct ValueImplArguments {
 }
 
 impl Parse for ValueImplArguments {
-    fn parse(input: ParseStream) -> Result<Self> {
+    fn parse(input: ParseStream) -> syn::Result<Self> {
         let mut result = ValueImplArguments { ident: None };
         let punctuated = input.parse_terminated(Meta::parse, Token![,])?;
         for meta in punctuated {