Remove support for interning in query_group

Author: ChayimFriedman2

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

@@ -6,18 +6,15 @@ use std::vec;
 use proc_macro::TokenStream;
 use proc_macro2::Span;
 use queries::{
-    GeneratedInputStruct, InputQuery, InputSetter, InputSetterWithDurability, Intern, Lookup,
-    Queries, SetterKind, TrackedQuery, Transparent,
+    GeneratedInputStruct, InputQuery, InputSetter, InputSetterWithDurability, Queries, SetterKind,
+    TrackedQuery, Transparent,
 };
 use quote::{ToTokens, format_ident, quote};
 use syn::parse::{Parse, ParseStream};
 use syn::punctuated::Punctuated;
 use syn::spanned::Spanned;
 use syn::visit_mut::VisitMut;
-use syn::{
-    Attribute, FnArg, ItemTrait, Path, Token, TraitItem, TraitItemFn, parse_quote,
-    parse_quote_spanned,
-};
+use syn::{Attribute, FnArg, ItemTrait, Path, Token, TraitItem, parse_quote, parse_quote_spanned};
 
 mod queries;
 
@@ -106,7 +103,6 @@ enum QueryKind {
     Tracked,
     TrackedWithSalsaStruct,
     Transparent,
-    Interned,
 }
 
 #[derive(Default, Debug, Clone)]
@@ -190,7 +186,6 @@ pub(crate) fn query_group_impl(
     let mut trait_methods = vec![];
     let mut setter_trait_methods = vec![];
     let mut lookup_signatures = vec![];
-    let mut lookup_methods = vec![];
 
     for item in &mut item_trait.items {
         if let syn::TraitItem::Fn(method) = item {
@@ -202,7 +197,6 @@ pub(crate) fn query_group_impl(
             let mut query_kind = QueryKind::TrackedWithSalsaStruct;
             let mut invoke = None;
             let mut cycle = None;
-            let mut interned_struct_path = None;
             let mut lru = None;
 
             let params: Vec<FnArg> = signature.inputs.clone().into_iter().collect();
@@ -230,22 +224,6 @@ pub(crate) fn query_group_impl(
                         }
                         query_kind = QueryKind::Input;
                     }
-                    "interned" => {
-                        let syn::ReturnType::Type(_, ty) = &signature.output else {
-                            return Err(syn::Error::new(
-                                span,
-                                "interned queries must have return type",
-                            ));
-                        };
-                        let syn::Type::Path(path) = &**ty else {
-                            return Err(syn::Error::new(
-                                span,
-                                "interned queries must have return type",
-                            ));
-                        };
-                        interned_struct_path = Some(path.path.clone());
-                        query_kind = QueryKind::Interned;
-                    }
                     "invoke_interned" => {
                         let path = syn::parse::<Parenthesized<Path>>(tts)?;
                         invoke = Some(path.0.clone());
@@ -317,28 +295,6 @@ pub(crate) fn query_group_impl(
                     };
                     setter_trait_methods.push(SetterKind::WithDurability(setter));
                 }
-                (QueryKind::Interned, None) => {
-                    let interned_struct_path = interned_struct_path.unwrap();
-                    let method = Intern {
-                        signature: signature.clone(),
-                        pat_and_tys: pat_and_tys.clone(),
-                        interned_struct_path: interned_struct_path.clone(),
-                    };
-
-                    trait_methods.push(Queries::Intern(method));
-
-                    let mut method = Lookup {
-                        signature: signature.clone(),
-                        pat_and_tys: pat_and_tys.clone(),
-                        return_ty: *return_ty,
-                        interned_struct_path,
-                    };
-                    method.prepare_signature();
-
-                    lookup_signatures
-                        .push(TraitItem::Fn(make_trait_method(method.signature.clone())));
-                    lookup_methods.push(method);
-                }
                 // tracked function. it might have an invoke, or might not.
                 (QueryKind::Tracked, invoke) => {
                     let method = TrackedQuery {
@@ -380,13 +336,6 @@ pub(crate) fn query_group_impl(
                     };
                     trait_methods.push(Queries::Transparent(method));
                 }
-                // error/invalid constructions
-                (QueryKind::Interned, Some(path)) => {
-                    return Err(syn::Error::new(
-                        path.span(),
-                        "Interned queries cannot be used with an `#[invoke]`".to_string(),
-                    ));
-                }
                 (QueryKind::Input, Some(path)) => {
                     return Err(syn::Error::new(
                         path.span(),
@@ -451,8 +400,6 @@ pub(crate) fn query_group_impl(
             #(#trait_methods)*
 
             #(#setter_methods)*
-
-            #(#lookup_methods)*
         }
     };
     RemoveAttrsFromTraitMethods.visit_item_trait_mut(&mut item_trait);
@@ -485,15 +432,6 @@ where
     }
 }
 
-fn make_trait_method(sig: syn::Signature) -> TraitItemFn {
-    TraitItemFn {
-        attrs: vec![],
-        sig: sig.clone(),
-        semi_token: Some(syn::Token![;](sig.span())),
-        default: None,
-    }
-}
-
 struct RemoveAttrsFromTraitMethods;
 
 impl VisitMut for RemoveAttrsFromTraitMethods {

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, Type, parse_quote, spanned::Spanned};
+use syn::{FnArg, Ident, PatType, Path, Receiver, ReturnType, parse_quote, spanned::Spanned};
 
 use crate::Cycle;
 
@@ -266,80 +266,11 @@ impl ToTokens for Transparent {
         method.to_tokens(tokens);
     }
 }
-pub(crate) struct Intern {
-    pub(crate) signature: syn::Signature,
-    pub(crate) pat_and_tys: Vec<PatType>,
-    pub(crate) interned_struct_path: Path,
-}
-
-impl ToTokens for Intern {
-    fn to_tokens(&self, tokens: &mut proc_macro2::TokenStream) {
-        let sig = &self.signature;
-
-        let ty = self.pat_and_tys.to_vec();
-
-        let interned_pat = ty.first().expect("at least one pat; this is a bug");
-        let interned_pat = &interned_pat.pat;
-
-        let wrapper_struct = self.interned_struct_path.to_token_stream();
-
-        let method = quote! {
-            #sig {
-                #wrapper_struct::new(self, #interned_pat)
-            }
-        };
-
-        method.to_tokens(tokens);
-    }
-}
-
-pub(crate) struct Lookup {
-    pub(crate) signature: syn::Signature,
-    pub(crate) pat_and_tys: Vec<PatType>,
-    pub(crate) return_ty: Type,
-    pub(crate) interned_struct_path: Path,
-}
-
-impl Lookup {
-    pub(crate) fn prepare_signature(&mut self) {
-        let sig = &self.signature;
-
-        let ident = format_ident!("lookup_{}", sig.ident);
-
-        let ty = self.pat_and_tys.to_vec();
-
-        let interned_key = &self.return_ty;
-
-        let interned_pat = ty.first().expect("at least one pat; this is a bug");
-        let interned_return_ty = &interned_pat.ty;
-
-        self.signature = parse_quote!(
-            fn #ident(&self, id: #interned_key) -> #interned_return_ty
-        );
-    }
-}
-
-impl ToTokens for Lookup {
-    fn to_tokens(&self, tokens: &mut proc_macro2::TokenStream) {
-        let sig = &self.signature;
-
-        let wrapper_struct = self.interned_struct_path.to_token_stream();
-        let method = quote! {
-            #sig {
-                let zalsa = self.zalsa();
-                #wrapper_struct::ingredient(zalsa).data(zalsa, id.as_id()).0.clone()
-            }
-        };
-
-        method.to_tokens(tokens);
-    }
-}
 
 #[allow(clippy::large_enum_variant)]
 pub(crate) enum Queries {
     TrackedQuery(TrackedQuery),
     InputQuery(InputQuery),
-    Intern(Intern),
     Transparent(Transparent),
 }
 
@@ -349,7 +280,6 @@ impl ToTokens for Queries {
             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),
-            Queries::Intern(intern) => intern.to_tokens(tokens),
         }
     }
 }