Implement an !Update bound escape hatch for tracked fn (#867)

Author: Veykril

components/salsa-macros/src/accumulator.rs

@@ -33,7 +33,7 @@ impl AllowedOptions for Accumulator {
     const SPECIFY: bool = false;
     const NO_EQ: bool = false;
     const DEBUG: bool = false;
-    const NO_CLONE: bool = false;
+    const NON_UPDATE_RETURN_TYPE: bool = false;
     const NO_LIFETIME: bool = false;
     const SINGLETON: bool = false;
     const DATA: bool = false;

components/salsa-macros/src/input.rs

@@ -43,7 +43,7 @@ impl crate::options::AllowedOptions for InputStruct {
 
     const NO_LIFETIME: bool = false;
 
-    const NO_CLONE: bool = false;
+    const NON_UPDATE_RETURN_TYPE: bool = false;
 
     const SINGLETON: bool = true;
 

components/salsa-macros/src/interned.rs

@@ -43,7 +43,7 @@ impl crate::options::AllowedOptions for InternedStruct {
 
     const NO_LIFETIME: bool = true;
 
-    const NO_CLONE: bool = false;
+    const NON_UPDATE_RETURN_TYPE: bool = false;
 
     const SINGLETON: bool = true;
 

components/salsa-macros/src/options.rs

@@ -33,11 +33,6 @@ pub(crate) struct Options<A: AllowedOptions> {
     /// If this is `Some`, the value is the `no_lifetime` identifier.
     pub no_lifetime: Option<syn::Ident>,
 
-    /// Signal we should not generate a `Clone` impl.
-    ///
-    /// If this is `Some`, the value is the `no_clone` identifier.
-    pub no_clone: Option<syn::Ident>,
-
     /// The `singleton` option is used on input with only one field
     /// It allows the creation of convenient methods
     pub singleton: Option<syn::Ident>,
@@ -48,6 +43,13 @@ pub(crate) struct Options<A: AllowedOptions> {
     /// If this is `Some`, the value is the `specify` identifier.
     pub specify: Option<syn::Ident>,
 
+    /// The `non_update_return_type` option is used to signal that a tracked function's
+    /// return type does not require `Update` to be implemented. This is unsafe and
+    /// generally discouraged as it allows for dangling references.
+    ///
+    /// If this is `Some`, the value is the `non_update_return_type` identifier.
+    pub non_update_return_type: Option<syn::Ident>,
+
     /// The `db = <path>` option is used to indicate the db.
     ///
     /// If this is `Some`, the value is the `<path>`.
@@ -100,10 +102,10 @@ impl<A: AllowedOptions> Default for Options<A> {
         Self {
             returns: Default::default(),
             specify: Default::default(),
+            non_update_return_type: Default::default(),
             no_eq: Default::default(),
             debug: Default::default(),
             no_lifetime: Default::default(),
-            no_clone: Default::default(),
             db_path: Default::default(),
             cycle_fn: Default::default(),
             cycle_initial: Default::default(),
@@ -125,7 +127,7 @@ pub(crate) trait AllowedOptions {
     const NO_EQ: bool;
     const DEBUG: bool;
     const NO_LIFETIME: bool;
-    const NO_CLONE: bool;
+    const NON_UPDATE_RETURN_TYPE: bool;
     const SINGLETON: bool;
     const DATA: bool;
     const DB: bool;
@@ -199,18 +201,28 @@ impl<A: AllowedOptions> syn::parse::Parse for Options<A> {
                         "`no_lifetime` option not allowed here",
                     ));
                 }
-            } else if ident == "no_clone" {
-                if A::NO_CLONE {
-                    if let Some(old) = options.no_clone.replace(ident) {
+            } else if ident == "unsafe" {
+                if A::NON_UPDATE_RETURN_TYPE {
+                    let content;
+                    parenthesized!(content in input);
+                    let ident = syn::Ident::parse_any(&content)?;
+                    if ident == "non_update_return_type" {
+                        if let Some(old) = options.non_update_return_type.replace(ident) {
+                            return Err(syn::Error::new(
+                                old.span(),
+                                "option `non_update_return_type` provided twice",
+                            ));
+                        }
+                    } else {
                         return Err(syn::Error::new(
-                            old.span(),
-                            "option `no_clone` provided twice",
+                            ident.span(),
+                            "expected `non_update_return_type`",
                         ));
                     }
                 } else {
                     return Err(syn::Error::new(
                         ident.span(),
-                        "`no_clone` option not allowed here",
+                        "`unsafe` options not allowed here",
                     ));
                 }
             } else if ident == "singleton" {

components/salsa-macros/src/tracked_fn.rs

@@ -36,7 +36,7 @@ impl crate::options::AllowedOptions for TrackedFn {
 
     const NO_LIFETIME: bool = false;
 
-    const NO_CLONE: bool = false;
+    const NON_UPDATE_RETURN_TYPE: bool = true;
 
     const SINGLETON: bool = false;
 
@@ -84,6 +84,7 @@ impl Macro {
         let (cycle_recovery_fn, cycle_recovery_initial, cycle_recovery_strategy) =
             self.cycle_recovery()?;
         let is_specifiable = self.args.specify.is_some();
+        let requires_update = self.args.non_update_return_type.is_none();
         let eq = if let Some(token) = &self.args.no_eq {
             if self.args.cycle_fn.is_some() {
                 return Err(syn::Error::new_spanned(
@@ -172,12 +173,16 @@ impl Macro {
         let maybe_update_path = quote_spanned! {output_ty.span() =>
             UpdateDispatch::<#output_ty>::maybe_update
         };
-        let assert_return_type_is_update = quote! {
-            #[allow(clippy::all, warnings)]
-            fn _assert_return_type_is_update<#db_lt>()  {
-                use #zalsa::{UpdateFallback, UpdateDispatch};
-                #maybe_update_path;
+        let assert_return_type_is_update = if requires_update {
+            quote! {
+                #[allow(clippy::all, warnings)]
+                fn _assert_return_type_is_update<#db_lt>()  {
+                    use #zalsa::{UpdateFallback, UpdateDispatch};
+                    #maybe_update_path;
+                }
             }
+        } else {
+            quote! {}
         };
 
         Ok(crate::debug::dump_tokens(

components/salsa-macros/src/tracked_struct.rs

@@ -38,7 +38,7 @@ impl crate::options::AllowedOptions for TrackedStruct {
 
     const NO_LIFETIME: bool = false;
 
-    const NO_CLONE: bool = false;
+    const NON_UPDATE_RETURN_TYPE: bool = false;
 
     const SINGLETON: bool = true;
 

tests/tracked_fn_orphan_escape_hatch.rs

@@ -0,0 +1,25 @@
+//! Test that a `tracked` fn on a `salsa::input`
+//! compiles and executes successfully.
+#![allow(warnings)]
+
+use std::marker::PhantomData;
+
+#[salsa::input]
+struct MyInput {
+    field: u32,
+}
+
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+struct NotUpdate<'a>(PhantomData<fn() -> &'a ()>);
+
+#[salsa::tracked(unsafe(non_update_return_type))]
+fn tracked_fn(db: &dyn salsa::Database, input: MyInput) -> NotUpdate<'_> {
+    NotUpdate(PhantomData)
+}
+
+#[test]
+fn execute() {
+    let mut db = salsa::DatabaseImpl::new();
+    let input = MyInput::new(&db, 22);
+    tracked_fn(&db, input);
+}