rust-analyzer

diff --git a/crates/query-group-macro/src/lib.rs b/crates/query-group-macro/src/lib.rs
index 6e89e0875e..a2cac3688c 100644
--- a/crates/query-group-macro/src/lib.rs
+++ b/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,61 +272,23 @@ 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

@@ -398,8 +296,6 @@ pub(crate) fn query_group_impl(

DB: #supertraits,

{

#(#trait_methods)*

- #(#setter_methods)*

}

};

RemoveAttrsFromTraitMethods.visit_item_trait_mut(&mut item_trait);

diff --git a/crates/query-group-macro/src/queries.rs b/crates/query-group-macro/src/queries.rs
index 4221068828..7eea85f7af 100644
--- a/crates/query-group-macro/src/queries.rs
+++ b/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,7 +144,6 @@ impl ToTokens for Transparent {

#[allow(clippy::large_enum_variant)]

pub(crate) enum Queries {

TrackedQuery(TrackedQuery),

- InputQuery(InputQuery),

Transparent(Transparent),

}

@@ -278,7 +151,6 @@ 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),

}

diff --git a/crates/query-group-macro/tests/hello_world.rs b/crates/query-group-macro/tests/hello_world.rs
index b0aec8dc53..7184b9bd1c 100644
--- a/crates/query-group-macro/tests/hello_world.rs
+++ b/crates/query-group-macro/tests/hello_world.rs

@@ -4,13 +4,13 @@ use query_group_macro::query_group;

mod logger_db;

use logger_db::LoggerDb;

+#[salsa::input(singleton)]

+struct InputString {

+ inner: String,

#[query_group]

pub trait HelloWorldDatabase: salsa::Database {

- // input

- // // input with no params

- #[salsa::input]

- fn input_string(&self) -> String;

// unadorned query

#[salsa::invoke_interned(length_query)]

fn length_query(&self, key: ()) -> usize;

@@ -32,98 +32,83 @@ pub trait HelloWorldDatabase: salsa::Database {

}

fn length_query(db: &dyn HelloWorldDatabase, _key: ()) -> usize {

- db.input_string().len()

+ InputString::get(db).inner(db).len()

}

fn length_query_with_no_params(db: &dyn HelloWorldDatabase) -> usize {

- db.input_string().len()

+ InputString::get(db).inner(db).len()

}

fn invoke_length_query_actual(db: &dyn HelloWorldDatabase, _key: ()) -> usize {

- db.input_string().len()

+ InputString::get(db).inner(db).len()

}

fn transparent_length(db: &dyn HelloWorldDatabase, _key: ()) -> usize {

- db.input_string().len()

+ InputString::get(db).inner(db).len()

}

fn transparent_and_invoke_length_actual(db: &dyn HelloWorldDatabase, _key: ()) -> usize {

- db.input_string().len()

+ InputString::get(db).inner(db).len()

}

#[test]

fn unadorned_query() {

- let mut db = LoggerDb::default();

+ let db = LoggerDb::default();

- db.set_input_string(String::from("Hello, world!"));

+ InputString::new(&db, String::from("Hello, world!"));

let len = db.length_query(());

assert_eq!(len, 13);

db.assert_logs(expect![[r#"

[

"salsa_event(WillCheckCancellation)",

- "salsa_event(WillExecute { database_key: create_data_HelloWorldDatabase(Id(0)) })",

- "salsa_event(WillCheckCancellation)",

- "salsa_event(DidValidateMemoizedValue { database_key: create_data_HelloWorldDatabase(Id(0)) })",

- "salsa_event(WillCheckCancellation)",

- "salsa_event(WillExecute { database_key: length_query_shim(Id(800)) })",

+ "salsa_event(WillExecute { database_key: create_data_HelloWorldDatabase(Id(400)) })",

"salsa_event(WillCheckCancellation)",

+ "salsa_event(WillExecute { database_key: length_query_shim(Id(c00)) })",

]"#]]);

}

#[test]

fn invoke_query() {

- let mut db = LoggerDb::default();

+ let db = LoggerDb::default();

- db.set_input_string(String::from("Hello, world!"));

+ InputString::new(&db, String::from("Hello, world!"));

let len = db.invoke_length_query(());

assert_eq!(len, 13);

db.assert_logs(expect![[r#"

[

"salsa_event(WillCheckCancellation)",

- "salsa_event(WillExecute { database_key: create_data_HelloWorldDatabase(Id(0)) })",

- "salsa_event(WillCheckCancellation)",

- "salsa_event(DidValidateMemoizedValue { database_key: create_data_HelloWorldDatabase(Id(0)) })",

- "salsa_event(WillCheckCancellation)",

- "salsa_event(WillExecute { database_key: invoke_length_query_shim(Id(800)) })",

+ "salsa_event(WillExecute { database_key: create_data_HelloWorldDatabase(Id(400)) })",

"salsa_event(WillCheckCancellation)",

+ "salsa_event(WillExecute { database_key: invoke_length_query_shim(Id(c00)) })",

]"#]]);

}

#[test]

fn transparent() {

- let mut db = LoggerDb::default();

+ let db = LoggerDb::default();

- db.set_input_string(String::from("Hello, world!"));

+ InputString::new(&db, String::from("Hello, world!"));

let len = db.transparent_length(());

assert_eq!(len, 13);

- db.assert_logs(expect![[r#"

- [

- "salsa_event(WillCheckCancellation)",

- "salsa_event(WillExecute { database_key: create_data_HelloWorldDatabase(Id(0)) })",

- "salsa_event(WillCheckCancellation)",

- "salsa_event(DidValidateMemoizedValue { database_key: create_data_HelloWorldDatabase(Id(0)) })",

- ]"#]]);

+ db.assert_logs(expect!["[]"]);

}

#[test]

fn transparent_invoke() {

- let mut db = LoggerDb::default();

+ let db = LoggerDb::default();

- db.set_input_string(String::from("Hello, world!"));

+ InputString::new(&db, String::from("Hello, world!"));

let len = db.transparent_and_invoke_length(());

assert_eq!(len, 13);

db.assert_logs(expect![[r#"

[

"salsa_event(WillCheckCancellation)",

- "salsa_event(WillExecute { database_key: create_data_HelloWorldDatabase(Id(0)) })",

- "salsa_event(WillCheckCancellation)",

- "salsa_event(DidValidateMemoizedValue { database_key: create_data_HelloWorldDatabase(Id(0)) })",

- "salsa_event(WillCheckCancellation)",

- "salsa_event(WillExecute { database_key: transparent_and_invoke_length_shim(Id(800)) })",

+ "salsa_event(WillExecute { database_key: create_data_HelloWorldDatabase(Id(400)) })",

"salsa_event(WillCheckCancellation)",

+ "salsa_event(WillExecute { database_key: transparent_and_invoke_length_shim(Id(c00)) })",

]"#]]);

}

diff --git a/crates/query-group-macro/tests/lru.rs b/crates/query-group-macro/tests/lru.rs
index f56dd5c2f9..a0817c4013 100644
--- a/crates/query-group-macro/tests/lru.rs
+++ b/crates/query-group-macro/tests/lru.rs

@@ -4,12 +4,13 @@ mod logger_db;

use logger_db::LoggerDb;

use query_group_macro::query_group;

+#[salsa::input(singleton)]

+struct InputString {

+ inner: String,

#[query_group]

pub trait LruDB: salsa::Database {

- // // input with no params

- #[salsa::input]

- fn input_string(&self) -> String;

#[salsa::lru(16)]

#[salsa::invoke_interned(length_query)]

fn length_query(&self, key: ()) -> usize;

@@ -20,49 +21,43 @@ pub trait LruDB: salsa::Database {

}

fn length_query(db: &dyn LruDB, _key: ()) -> usize {

- db.input_string().len()

+ InputString::get(db).inner(db).len()

}

fn invoked_query(db: &dyn LruDB, _key: ()) -> usize {

- db.input_string().len()

+ InputString::get(db).inner(db).len()

}

#[test]

fn plain_lru() {

- let mut db = LoggerDb::default();

+ let db = LoggerDb::default();

- db.set_input_string(String::from("Hello, world!"));

+ InputString::new(&db, String::from("Hello, world!"));

let len = db.length_query(());

assert_eq!(len, 13);

db.assert_logs(expect![[r#"

[

"salsa_event(WillCheckCancellation)",

- "salsa_event(WillExecute { database_key: create_data_LruDB(Id(0)) })",

- "salsa_event(WillCheckCancellation)",

- "salsa_event(DidValidateMemoizedValue { database_key: create_data_LruDB(Id(0)) })",

- "salsa_event(WillCheckCancellation)",

- "salsa_event(WillExecute { database_key: length_query_shim(Id(800)) })",

+ "salsa_event(WillExecute { database_key: create_data_LruDB(Id(400)) })",

"salsa_event(WillCheckCancellation)",

+ "salsa_event(WillExecute { database_key: length_query_shim(Id(c00)) })",

]"#]]);

}

#[test]

fn invoke_lru() {

- let mut db = LoggerDb::default();

+ let db = LoggerDb::default();

- db.set_input_string(String::from("Hello, world!"));

+ InputString::new(&db, String::from("Hello, world!"));

let len = db.length_query_invoke(());

assert_eq!(len, 13);

db.assert_logs(expect![[r#"

[

"salsa_event(WillCheckCancellation)",

- "salsa_event(WillExecute { database_key: create_data_LruDB(Id(0)) })",

- "salsa_event(WillCheckCancellation)",

- "salsa_event(DidValidateMemoizedValue { database_key: create_data_LruDB(Id(0)) })",

- "salsa_event(WillCheckCancellation)",

- "salsa_event(WillExecute { database_key: length_query_invoke_shim(Id(800)) })",

+ "salsa_event(WillExecute { database_key: create_data_LruDB(Id(400)) })",

"salsa_event(WillCheckCancellation)",

+ "salsa_event(WillExecute { database_key: length_query_invoke_shim(Id(c00)) })",

]"#]]);

}

diff --git a/crates/query-group-macro/tests/multiple_dbs.rs b/crates/query-group-macro/tests/multiple_dbs.rs
index f36e7fdbeb..e0faa6a961 100644
--- a/crates/query-group-macro/tests/multiple_dbs.rs
+++ b/crates/query-group-macro/tests/multiple_dbs.rs

@@ -1,10 +1,12 @@

use query_group_macro::query_group;

+#[salsa::input(singleton)]

+struct InputString {

+ inner: String,

#[query_group]

pub trait DatabaseOne: salsa::Database {

- #[salsa::input]

- fn input_string(&self) -> String;

// unadorned query

#[salsa::invoke_interned(length)]

fn length(&self, key: ()) -> usize;

@@ -17,9 +19,9 @@ pub trait DatabaseTwo: DatabaseOne {

}

fn length(db: &dyn DatabaseOne, _key: ()) -> usize {

- db.input_string().len()

+ InputString::get(db).inner(db).len()

}

fn second_length(db: &dyn DatabaseTwo, _key: ()) -> usize {

- db.input_string().len()

+ InputString::get(db).inner(db).len()

}

diff --git a/crates/query-group-macro/tests/result.rs b/crates/query-group-macro/tests/result.rs
index 06f7f403c7..ad7d8ae0a1 100644
--- a/crates/query-group-macro/tests/result.rs
+++ b/crates/query-group-macro/tests/result.rs

@@ -7,11 +7,13 @@ use query_group_macro::query_group;

#[derive(Clone, Debug, PartialEq, Eq)]

pub struct Error;

+#[salsa::input(singleton)]

+struct InputString {

+ inner: String,

#[query_group]

pub trait ResultDatabase: salsa::Database {

- #[salsa::input]

- fn input_string(&self) -> String;

#[salsa::invoke_interned(length)]

fn length(&self, key: ()) -> Result<usize, Error>;

@@ -20,33 +22,29 @@ pub trait ResultDatabase: salsa::Database {

}

fn length(db: &dyn ResultDatabase, _key: ()) -> Result<usize, Error> {

- Ok(db.input_string().len())

+ Ok(InputString::get(db).inner(db).len())

}

fn length2(db: &dyn ResultDatabase, _key: ()) -> Result<usize, Error> {

- Ok(db.input_string().len())

+ Ok(InputString::get(db).inner(db).len())

}

#[test]

fn test_queries_with_results() {

- let mut db = LoggerDb::default();

+ let db = LoggerDb::default();

let input = "hello";

- db.set_input_string(input.to_owned());

+ _ = InputString::new(&db, input.to_owned());

assert_eq!(db.length(()), Ok(input.len()));

assert_eq!(db.length2(()), Ok(input.len()));

db.assert_logs(expect![[r#"

[

"salsa_event(WillCheckCancellation)",

- "salsa_event(WillExecute { database_key: create_data_ResultDatabase(Id(0)) })",

- "salsa_event(WillCheckCancellation)",

- "salsa_event(DidValidateMemoizedValue { database_key: create_data_ResultDatabase(Id(0)) })",

- "salsa_event(WillCheckCancellation)",

- "salsa_event(WillExecute { database_key: length_shim(Id(800)) })",

- "salsa_event(WillCheckCancellation)",

+ "salsa_event(WillExecute { database_key: create_data_ResultDatabase(Id(400)) })",

"salsa_event(WillCheckCancellation)",

+ "salsa_event(WillExecute { database_key: length_shim(Id(c00)) })",

"salsa_event(WillCheckCancellation)",

- "salsa_event(WillExecute { database_key: length2_shim(Id(c00)) })",

"salsa_event(WillCheckCancellation)",

+ "salsa_event(WillExecute { database_key: length2_shim(Id(1000)) })",

]"#]]);

}

diff --git a/crates/query-group-macro/tests/tuples.rs b/crates/query-group-macro/tests/tuples.rs
index af0e852695..b38ac2ed2b 100644
--- a/crates/query-group-macro/tests/tuples.rs
+++ b/crates/query-group-macro/tests/tuples.rs

@@ -4,36 +4,35 @@ mod logger_db;

use expect_test::expect;

use logger_db::LoggerDb;

+#[salsa::input(singleton)]

+struct InputString {

+ inner: String,

#[query_group]

pub trait HelloWorldDatabase: salsa::Database {

- #[salsa::input]

- fn input_string(&self) -> String;

#[salsa::invoke_interned(length_query)]

fn length_query(&self, key: ()) -> (usize, usize);

}

fn length_query(db: &dyn HelloWorldDatabase, _key: ()) -> (usize, usize) {

- let len = db.input_string().len();

+ let len = InputString::get(db).inner(db).len();

(len, len)

}

#[test]

fn query() {

- let mut db = LoggerDb::default();

+ let db = LoggerDb::default();

- db.set_input_string(String::from("Hello, world!"));

+ _ = InputString::new(&db, String::from("Hello, world!"));

let len = db.length_query(());

assert_eq!(len, (13, 13));

db.assert_logs(expect![[r#"

[

"salsa_event(WillCheckCancellation)",

- "salsa_event(WillExecute { database_key: create_data_HelloWorldDatabase(Id(0)) })",

- "salsa_event(WillCheckCancellation)",

- "salsa_event(DidValidateMemoizedValue { database_key: create_data_HelloWorldDatabase(Id(0)) })",

- "salsa_event(WillCheckCancellation)",

- "salsa_event(WillExecute { database_key: length_query_shim(Id(800)) })",

+ "salsa_event(WillExecute { database_key: create_data_HelloWorldDatabase(Id(400)) })",

"salsa_event(WillCheckCancellation)",

+ "salsa_event(WillExecute { database_key: length_query_shim(Id(c00)) })",

]"#]]);

}