remove #[salsa::input] support in #[query_group]

Author: ada4a

crates/query-group-macro/src/lib.rs

@@ -1,14 +1,10 @@
 //! A macro that mimics the old Salsa-style `#[query_group]` macro.
 
-use core::fmt;
 use std::vec;
 
 use proc_macro::TokenStream;
 use proc_macro2::Span;
-use queries::{
-    GeneratedInputStruct, InputQuery, InputSetter, InputSetterWithDurability, Queries, SetterKind,
-    TrackedQuery, Transparent,
-};
+use queries::{GeneratedInputStruct, Queries, TrackedQuery, Transparent};
 use quote::{ToTokens, format_ident, quote};
 use syn::parse::{Parse, ParseStream};
 use syn::punctuated::Punctuated;
@@ -26,18 +22,6 @@ pub fn query_group(args: TokenStream, input: TokenStream) -> TokenStream {
     }
 }
 
-#[derive(Debug)]
-struct InputStructField {
-    name: proc_macro2::TokenStream,
-    ty: proc_macro2::TokenStream,
-}
-
-impl fmt::Display for InputStructField {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        write!(f, "{}", self.name)
-    }
-}
-
 struct SalsaAttr {
     name: String,
     tts: TokenStream,
@@ -99,7 +83,6 @@ fn filter_attrs(attrs: Vec<Attribute>) -> (Vec<Attribute>, Vec<SalsaAttr>) {
 
 #[derive(Debug, Clone, PartialEq, Eq)]
 enum QueryKind {
-    Input,
     Tracked,
     TrackedWithSalsaStruct,
     Transparent,
@@ -182,14 +165,10 @@ pub(crate) fn query_group_impl(
     let input_struct_name = format_ident!("{}Data", trait_name_ident);
     let create_data_ident = format_ident!("create_data_{}", trait_name_ident);
 
-    let mut input_struct_fields: Vec<InputStructField> = vec![];
     let mut trait_methods = vec![];
-    let mut setter_trait_methods = vec![];
-    let mut lookup_signatures = vec![];
 
     for item in &mut item_trait.items {
         if let syn::TraitItem::Fn(method) = item {
-            let method_name = &method.sig.ident;
             let signature = &method.sig;
 
             let (_attrs, salsa_attrs) = filter_attrs(method.attrs.clone());
@@ -215,15 +194,6 @@ pub(crate) fn query_group_impl(
                         let c = syn::parse::<Parenthesized<Cycle>>(tts)?;
                         cycle = Some(c.0);
                     }
-                    "input" => {
-                        if !pat_and_tys.is_empty() {
-                            return Err(syn::Error::new(
-                                span,
-                                "input methods cannot have a parameter",
-                            ));
-                        }
-                        query_kind = QueryKind::Input;
-                    }
                     "invoke_interned" => {
                         let path = syn::parse::<Parenthesized<Path>>(tts)?;
                         invoke = Some(path.0.clone());
@@ -252,49 +222,15 @@ pub(crate) fn query_group_impl(
                 }
             }
 
-            let syn::ReturnType::Type(_, return_ty) = signature.output.clone() else {
+            let syn::ReturnType::Type(_, _) = signature.output.clone() else {
                 return Err(syn::Error::new(signature.span(), "Queries must have a return type"));
             };
 
-            if let syn::Type::Path(ref ty_path) = *return_ty
-                && matches!(query_kind, QueryKind::Input)
-            {
-                let field = InputStructField {
-                    name: method_name.to_token_stream(),
-                    ty: ty_path.path.to_token_stream(),
-                };
-
-                input_struct_fields.push(field);
-            }
-
             if let Some(block) = &mut method.default {
                 SelfToDbRewriter.visit_block_mut(block);
             }
 
             match (query_kind, invoke) {
-                // input
-                (QueryKind::Input, None) => {
-                    let query = InputQuery {
-                        signature: method.sig.clone(),
-                        create_data_ident: create_data_ident.clone(),
-                    };
-                    let value = Queries::InputQuery(query);
-                    trait_methods.push(value);
-
-                    let setter = InputSetter {
-                        signature: method.sig.clone(),
-                        return_type: *return_ty.clone(),
-                        create_data_ident: create_data_ident.clone(),
-                    };
-                    setter_trait_methods.push(SetterKind::Plain(setter));
-
-                    let setter = InputSetterWithDurability {
-                        signature: method.sig.clone(),
-                        return_type: *return_ty.clone(),
-                        create_data_ident: create_data_ident.clone(),
-                    };
-                    setter_trait_methods.push(SetterKind::WithDurability(setter));
-                }
                 // tracked function. it might have an invoke, or might not.
                 (QueryKind::Tracked, invoke) => {
                     let method = TrackedQuery {
@@ -336,70 +272,30 @@ pub(crate) fn query_group_impl(
                     };
                     trait_methods.push(Queries::Transparent(method));
                 }
-                (QueryKind::Input, Some(path)) => {
-                    return Err(syn::Error::new(
-                        path.span(),
-                        "Inputs cannot be used with an `#[invoke]`".to_string(),
-                    ));
-                }
             }
         }
     }
 
-    let fields = input_struct_fields
-        .into_iter()
-        .map(|input| {
-            let name = input.name;
-            let ret = input.ty;
-            quote! { #name: Option<#ret> }
-        })
-        .collect::<Vec<proc_macro2::TokenStream>>();
-
     let input_struct = quote! {
         #[salsa_macros::input]
-        pub(crate) struct #input_struct_name {
-            #(#fields),*
-        }
+        pub(crate) struct #input_struct_name {}
     };
 
-    let field_params = std::iter::repeat_n(quote! { None }, fields.len())
-        .collect::<Vec<proc_macro2::TokenStream>>();
-
     let create_data_method = quote! {
         #[allow(non_snake_case)]
         #[salsa_macros::tracked]
         fn #create_data_ident(db: &dyn #trait_name_ident) -> #input_struct_name {
-            #input_struct_name::new(db, #(#field_params),*)
+            #input_struct_name::new(db)
         }
     };
 
-    let mut setter_signatures = vec![];
-    let mut setter_methods = vec![];
-    for trait_item in setter_trait_methods
-        .iter()
-        .map(|method| method.to_token_stream())
-        .map(|tokens| syn::parse2::<syn::TraitItemFn>(tokens).unwrap())
-    {
-        let mut methods_sans_body = trait_item.clone();
-        methods_sans_body.default = None;
-        methods_sans_body.semi_token = Some(syn::Token![;](trait_item.span()));
-
-        setter_signatures.push(TraitItem::Fn(methods_sans_body));
-        setter_methods.push(TraitItem::Fn(trait_item));
-    }
-
-    item_trait.items.append(&mut setter_signatures);
-    item_trait.items.append(&mut lookup_signatures);
-
     let trait_impl = quote! {
         #[salsa_macros::db]
         impl<DB> #trait_name_ident for DB
         where
             DB: #supertraits,
         {
             #(#trait_methods)*
-
-            #(#setter_methods)*
         }
     };
     RemoveAttrsFromTraitMethods.visit_item_trait_mut(&mut item_trait);

crates/query-group-macro/src/queries.rs

@@ -1,7 +1,7 @@
 //! The IR of the `#[query_group]` macro.
 
 use quote::{ToTokens, format_ident, quote, quote_spanned};
-use syn::{FnArg, Ident, PatType, Path, Receiver, ReturnType, parse_quote, spanned::Spanned};
+use syn::{Ident, PatType, Path, spanned::Spanned};
 
 use crate::Cycle;
 
@@ -104,132 +104,6 @@ impl ToTokens for TrackedQuery {
     }
 }
 
-pub(crate) struct InputQuery {
-    pub(crate) signature: syn::Signature,
-    pub(crate) create_data_ident: Ident,
-}
-
-impl ToTokens for InputQuery {
-    fn to_tokens(&self, tokens: &mut proc_macro2::TokenStream) {
-        let sig = &self.signature;
-        let fn_ident = &sig.ident;
-        let create_data_ident = &self.create_data_ident;
-
-        let method = quote! {
-            #sig {
-                let data = #create_data_ident(self);
-                data.#fn_ident(self).unwrap()
-            }
-        };
-        method.to_tokens(tokens);
-    }
-}
-
-pub(crate) struct InputSetter {
-    pub(crate) signature: syn::Signature,
-    pub(crate) return_type: syn::Type,
-    pub(crate) create_data_ident: Ident,
-}
-
-impl ToTokens for InputSetter {
-    fn to_tokens(&self, tokens: &mut proc_macro2::TokenStream) {
-        let sig = &mut self.signature.clone();
-
-        let ty = &self.return_type;
-        let fn_ident = &sig.ident;
-        let create_data_ident = &self.create_data_ident;
-
-        let setter_ident = format_ident!("set_{}", fn_ident);
-        sig.ident = setter_ident.clone();
-
-        let value_argument: PatType = parse_quote!(__value: #ty);
-        sig.inputs.push(FnArg::Typed(value_argument.clone()));
-
-        // make `&self` `&mut self` instead.
-        let mut_receiver: Receiver = parse_quote!(&mut self);
-        if let Some(og) = sig.inputs.first_mut() {
-            *og = FnArg::Receiver(mut_receiver)
-        }
-
-        // remove the return value.
-        sig.output = ReturnType::Default;
-
-        let value = &value_argument.pat;
-        let method = quote! {
-            #sig {
-                use salsa::Setter;
-                let data = #create_data_ident(self);
-                data.#setter_ident(self).to(Some(#value));
-            }
-        };
-        method.to_tokens(tokens);
-    }
-}
-
-pub(crate) struct InputSetterWithDurability {
-    pub(crate) signature: syn::Signature,
-    pub(crate) return_type: syn::Type,
-    pub(crate) create_data_ident: Ident,
-}
-
-impl ToTokens for InputSetterWithDurability {
-    fn to_tokens(&self, tokens: &mut proc_macro2::TokenStream) {
-        let sig = &mut self.signature.clone();
-
-        let ty = &self.return_type;
-        let fn_ident = &sig.ident;
-        let setter_ident = format_ident!("set_{}", fn_ident);
-
-        let create_data_ident = &self.create_data_ident;
-
-        sig.ident = format_ident!("set_{}_with_durability", fn_ident);
-
-        let value_argument: PatType = parse_quote!(__value: #ty);
-        sig.inputs.push(FnArg::Typed(value_argument.clone()));
-
-        let durability_argument: PatType = parse_quote!(durability: salsa::Durability);
-        sig.inputs.push(FnArg::Typed(durability_argument.clone()));
-
-        // make `&self` `&mut self` instead.
-        let mut_receiver: Receiver = parse_quote!(&mut self);
-        if let Some(og) = sig.inputs.first_mut() {
-            *og = FnArg::Receiver(mut_receiver)
-        }
-
-        // remove the return value.
-        sig.output = ReturnType::Default;
-
-        let value = &value_argument.pat;
-        let durability = &durability_argument.pat;
-        let method = quote! {
-            #sig {
-                use salsa::Setter;
-                let data = #create_data_ident(self);
-                data.#setter_ident(self)
-                    .with_durability(#durability)
-                    .to(Some(#value));
-            }
-        };
-        method.to_tokens(tokens);
-    }
-}
-
-pub(crate) enum SetterKind {
-    Plain(InputSetter),
-    WithDurability(InputSetterWithDurability),
-}
-
-impl ToTokens for SetterKind {
-    fn to_tokens(&self, tokens: &mut proc_macro2::TokenStream) {
-        match self {
-            SetterKind::Plain(input_setter) => input_setter.to_tokens(tokens),
-            SetterKind::WithDurability(input_setter_with_durability) => {
-                input_setter_with_durability.to_tokens(tokens)
-            }
-        }
-    }
-}
-
 pub(crate) struct Transparent {
     pub(crate) signature: syn::Signature,
     pub(crate) pat_and_tys: Vec<PatType>,
@@ -270,15 +144,13 @@ impl ToTokens for Transparent {
 #[allow(clippy::large_enum_variant)]
 pub(crate) enum Queries {
     TrackedQuery(TrackedQuery),
-    InputQuery(InputQuery),
     Transparent(Transparent),
 }
 
 impl ToTokens for Queries {
     fn to_tokens(&self, tokens: &mut proc_macro2::TokenStream) {
         match self {
             Queries::TrackedQuery(tracked_query) => tracked_query.to_tokens(tokens),
-            Queries::InputQuery(input_query) => input_query.to_tokens(tokens),
             Queries::Transparent(transparent) => transparent.to_tokens(tokens),
         }
     }