mirror of
https://github.com/salsa-rs/salsa.git
synced 2025-01-23 05:07:27 +00:00
WIP: temporarily add expanded version of test
This commit is contained in:
Niko Matsakis
parent
ce88a8f9ca
commit
a7b2805b06
1 changed files with 997 additions and 0 deletions
997
salsa-2022-tests/tests/tracked_with_struct_db_expanded.rs
Normal file
997
salsa-2022-tests/tests/tracked_with_struct_db_expanded.rs
Normal file
|
|
@ -0,0 +1,997 @@
|
||||||
|
#![feature(prelude_import)]
|
||||||
|
#![feature(panic_internals)]
|
||||||
|
#![feature(fmt_helpers_for_derive)]
|
||||||
|
#![allow(warnings)]
|
||||||
|
#![feature(test)]
|
||||||
|
#![feature(derive_eq)]
|
||||||
|
#![feature(derive_clone_copy)]
|
||||||
|
#![feature(core_intrinsics)]
|
||||||
|
#![feature(structural_match)]
|
||||||
|
#![feature(coverage_attribute)]
|
||||||
|
#![feature(rustc_attrs)]
|
||||||
|
#![feature(raw_ref_op)]
|
||||||
|
|
||||||
|
//! Test that a setting a field on a `#[salsa::input]`
|
||||||
|
//! overwrites and returns the old value.
|
||||||
|
#[prelude_import]
|
||||||
|
use std::prelude::rust_2021::*;
|
||||||
|
#[macro_use]
|
||||||
|
extern crate std;
|
||||||
|
use salsa::DebugWithDb;
|
||||||
|
use test_log::test;
|
||||||
|
struct Jar(
|
||||||
|
<MyInput as salsa::storage::IngredientsFor>::Ingredients,
|
||||||
|
<MyTracked<'static> as salsa::storage::IngredientsFor>::Ingredients,
|
||||||
|
<create_tracked_list as salsa::storage::IngredientsFor>::Ingredients,
|
||||||
|
);
|
||||||
|
impl salsa::storage::HasIngredientsFor<MyInput> for Jar {
|
||||||
|
fn ingredient(&self) -> &<MyInput as salsa::storage::IngredientsFor>::Ingredients {
|
||||||
|
&self.0
|
||||||
|
}
|
||||||
|
fn ingredient_mut(&mut self) -> &mut <MyInput as salsa::storage::IngredientsFor>::Ingredients {
|
||||||
|
&mut self.0
|
||||||
|
}
|
||||||
|
}
|
||||||
|
impl salsa::storage::HasIngredientsFor<MyTracked<'_>> for Jar {
|
||||||
|
fn ingredient(&self) -> &<MyTracked<'_> as salsa::storage::IngredientsFor>::Ingredients {
|
||||||
|
&self.1
|
||||||
|
}
|
||||||
|
fn ingredient_mut(
|
||||||
|
&mut self,
|
||||||
|
) -> &mut <MyTracked<'_> as salsa::storage::IngredientsFor>::Ingredients {
|
||||||
|
&mut self.1
|
||||||
|
}
|
||||||
|
}
|
||||||
|
impl salsa::storage::HasIngredientsFor<create_tracked_list> for Jar {
|
||||||
|
fn ingredient(&self) -> &<create_tracked_list as salsa::storage::IngredientsFor>::Ingredients {
|
||||||
|
&self.2
|
||||||
|
}
|
||||||
|
fn ingredient_mut(
|
||||||
|
&mut self,
|
||||||
|
) -> &mut <create_tracked_list as salsa::storage::IngredientsFor>::Ingredients {
|
||||||
|
&mut self.2
|
||||||
|
}
|
||||||
|
}
|
||||||
|
unsafe impl<'salsa_db> salsa::jar::Jar<'salsa_db> for Jar {
|
||||||
|
type DynDb = dyn Db + 'salsa_db;
|
||||||
|
unsafe fn init_jar<DB>(place: *mut Self, routes: &mut salsa::routes::Routes<DB>)
|
||||||
|
where
|
||||||
|
DB: salsa::storage::JarFromJars<Self> + salsa::storage::DbWithJar<Self>,
|
||||||
|
{
|
||||||
|
unsafe {
|
||||||
|
(&raw mut (*place).0)
|
||||||
|
.write(<MyInput as salsa::storage::IngredientsFor>::create_ingredients(routes));
|
||||||
|
}
|
||||||
|
unsafe {
|
||||||
|
(&raw mut (*place).1).write(
|
||||||
|
<MyTracked<'_> as salsa::storage::IngredientsFor>::create_ingredients(routes),
|
||||||
|
);
|
||||||
|
}
|
||||||
|
unsafe {
|
||||||
|
(&raw mut (*place).2).write(
|
||||||
|
<create_tracked_list as salsa::storage::IngredientsFor>::create_ingredients(routes),
|
||||||
|
);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
trait Db: salsa::DbWithJar<Jar> {}
|
||||||
|
struct Database {
|
||||||
|
storage: salsa::Storage<Self>,
|
||||||
|
}
|
||||||
|
#[automatically_derived]
|
||||||
|
impl ::core::default::Default for Database {
|
||||||
|
#[inline]
|
||||||
|
fn default() -> Database {
|
||||||
|
Database {
|
||||||
|
storage: ::core::default::Default::default(),
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
impl salsa::database::AsSalsaDatabase for Database {
|
||||||
|
fn as_salsa_database(&self) -> &dyn salsa::Database {
|
||||||
|
self
|
||||||
|
}
|
||||||
|
}
|
||||||
|
impl salsa::storage::HasJars for Database {
|
||||||
|
type Jars = (Jar,);
|
||||||
|
fn jars(&self) -> (&Self::Jars, &salsa::Runtime) {
|
||||||
|
self.storage.jars()
|
||||||
|
}
|
||||||
|
fn jars_mut(&mut self) -> (&mut Self::Jars, &mut salsa::Runtime) {
|
||||||
|
self.storage.jars_mut()
|
||||||
|
}
|
||||||
|
fn create_jars(routes: &mut salsa::routes::Routes<Self>) -> Box<Self::Jars> {
|
||||||
|
unsafe {
|
||||||
|
salsa::plumbing::create_jars_inplace::<Database>(|jars| unsafe {
|
||||||
|
let place = &raw mut (*jars).0;
|
||||||
|
<Jar as salsa::jar::Jar>::init_jar(place, routes);
|
||||||
|
})
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
impl salsa::storage::HasJarsDyn for Database {
|
||||||
|
fn runtime(&self) -> &salsa::Runtime {
|
||||||
|
self.storage.runtime()
|
||||||
|
}
|
||||||
|
fn runtime_mut(&mut self) -> &mut salsa::Runtime {
|
||||||
|
self.storage.runtime_mut()
|
||||||
|
}
|
||||||
|
fn maybe_changed_after(
|
||||||
|
&self,
|
||||||
|
input: salsa::key::DependencyIndex,
|
||||||
|
revision: salsa::Revision,
|
||||||
|
) -> bool {
|
||||||
|
let ingredient = self.storage.ingredient(input.ingredient_index());
|
||||||
|
ingredient.maybe_changed_after(self, input, revision)
|
||||||
|
}
|
||||||
|
fn cycle_recovery_strategy(
|
||||||
|
&self,
|
||||||
|
ingredient_index: salsa::IngredientIndex,
|
||||||
|
) -> salsa::cycle::CycleRecoveryStrategy {
|
||||||
|
let ingredient = self.storage.ingredient(ingredient_index);
|
||||||
|
ingredient.cycle_recovery_strategy()
|
||||||
|
}
|
||||||
|
fn origin(
|
||||||
|
&self,
|
||||||
|
index: salsa::DatabaseKeyIndex,
|
||||||
|
) -> Option<salsa::runtime::local_state::QueryOrigin> {
|
||||||
|
let ingredient = self.storage.ingredient(index.ingredient_index());
|
||||||
|
ingredient.origin(index.key_index())
|
||||||
|
}
|
||||||
|
fn mark_validated_output(
|
||||||
|
&self,
|
||||||
|
executor: salsa::DatabaseKeyIndex,
|
||||||
|
output: salsa::key::DependencyIndex,
|
||||||
|
) {
|
||||||
|
let ingredient = self.storage.ingredient(output.ingredient_index());
|
||||||
|
ingredient.mark_validated_output(self, executor, output.key_index());
|
||||||
|
}
|
||||||
|
fn remove_stale_output(
|
||||||
|
&self,
|
||||||
|
executor: salsa::DatabaseKeyIndex,
|
||||||
|
stale_output: salsa::key::DependencyIndex,
|
||||||
|
) {
|
||||||
|
let ingredient = self.storage.ingredient(stale_output.ingredient_index());
|
||||||
|
ingredient.remove_stale_output(self, executor, stale_output.key_index());
|
||||||
|
}
|
||||||
|
fn salsa_struct_deleted(&self, ingredient: salsa::IngredientIndex, id: salsa::Id) {
|
||||||
|
let ingredient = self.storage.ingredient(ingredient);
|
||||||
|
ingredient.salsa_struct_deleted(self, id);
|
||||||
|
}
|
||||||
|
fn fmt_index(
|
||||||
|
&self,
|
||||||
|
index: salsa::key::DependencyIndex,
|
||||||
|
fmt: &mut std::fmt::Formatter<'_>,
|
||||||
|
) -> std::fmt::Result {
|
||||||
|
let ingredient = self.storage.ingredient(index.ingredient_index());
|
||||||
|
ingredient.fmt_index(index.key_index(), fmt)
|
||||||
|
}
|
||||||
|
}
|
||||||
|
impl salsa::storage::DbWithJar<Jar> for Database {
|
||||||
|
fn as_jar_db<'db>(&'db self) -> &'db <Jar as salsa::jar::Jar<'db>>::DynDb
|
||||||
|
where
|
||||||
|
'db: 'db,
|
||||||
|
{
|
||||||
|
self as &'db <Jar as salsa::jar::Jar<'db>>::DynDb
|
||||||
|
}
|
||||||
|
}
|
||||||
|
impl salsa::storage::HasJar<Jar> for Database {
|
||||||
|
fn jar(&self) -> (&Jar, &salsa::Runtime) {
|
||||||
|
let (__jars, __runtime) = self.storage.jars();
|
||||||
|
(&__jars.0, __runtime)
|
||||||
|
}
|
||||||
|
fn jar_mut(&mut self) -> (&mut Jar, &mut salsa::Runtime) {
|
||||||
|
let (__jars, __runtime) = self.storage.jars_mut();
|
||||||
|
(&mut __jars.0, __runtime)
|
||||||
|
}
|
||||||
|
}
|
||||||
|
impl salsa::storage::JarFromJars<Jar> for Database {
|
||||||
|
fn jar_from_jars<'db>(jars: &Self::Jars) -> &Jar {
|
||||||
|
&jars.0
|
||||||
|
}
|
||||||
|
fn jar_from_jars_mut<'db>(jars: &mut Self::Jars) -> &mut Jar {
|
||||||
|
&mut jars.0
|
||||||
|
}
|
||||||
|
}
|
||||||
|
impl salsa::Database for Database {}
|
||||||
|
impl Db for Database {}
|
||||||
|
struct MyInput(salsa::Id);
|
||||||
|
#[automatically_derived]
|
||||||
|
impl ::core::marker::Copy for MyInput {}
|
||||||
|
#[automatically_derived]
|
||||||
|
impl ::core::clone::Clone for MyInput {
|
||||||
|
#[inline]
|
||||||
|
fn clone(&self) -> MyInput {
|
||||||
|
let _: ::core::clone::AssertParamIsClone<salsa::Id>;
|
||||||
|
*self
|
||||||
|
}
|
||||||
|
}
|
||||||
|
#[automatically_derived]
|
||||||
|
impl ::core::marker::StructuralPartialEq for MyInput {}
|
||||||
|
#[automatically_derived]
|
||||||
|
impl ::core::cmp::PartialEq for MyInput {
|
||||||
|
#[inline]
|
||||||
|
fn eq(&self, other: &MyInput) -> bool {
|
||||||
|
self.0 == other.0
|
||||||
|
}
|
||||||
|
}
|
||||||
|
#[automatically_derived]
|
||||||
|
impl ::core::cmp::PartialOrd for MyInput {
|
||||||
|
#[inline]
|
||||||
|
fn partial_cmp(&self, other: &MyInput) -> ::core::option::Option<::core::cmp::Ordering> {
|
||||||
|
::core::cmp::PartialOrd::partial_cmp(&self.0, &other.0)
|
||||||
|
}
|
||||||
|
}
|
||||||
|
#[automatically_derived]
|
||||||
|
impl ::core::cmp::Eq for MyInput {
|
||||||
|
#[inline]
|
||||||
|
#[doc(hidden)]
|
||||||
|
#[coverage(off)]
|
||||||
|
fn assert_receiver_is_total_eq(&self) -> () {
|
||||||
|
let _: ::core::cmp::AssertParamIsEq<salsa::Id>;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
#[automatically_derived]
|
||||||
|
impl ::core::cmp::Ord for MyInput {
|
||||||
|
#[inline]
|
||||||
|
fn cmp(&self, other: &MyInput) -> ::core::cmp::Ordering {
|
||||||
|
::core::cmp::Ord::cmp(&self.0, &other.0)
|
||||||
|
}
|
||||||
|
}
|
||||||
|
#[automatically_derived]
|
||||||
|
impl ::core::hash::Hash for MyInput {
|
||||||
|
#[inline]
|
||||||
|
fn hash<__H: ::core::hash::Hasher>(&self, state: &mut __H) -> () {
|
||||||
|
::core::hash::Hash::hash(&self.0, state)
|
||||||
|
}
|
||||||
|
}
|
||||||
|
#[allow(dead_code, clippy::pedantic, clippy::complexity, clippy::style)]
|
||||||
|
impl MyInput {
|
||||||
|
pub fn new(__db: &<crate::Jar as salsa::jar::Jar<'_>>::DynDb, field: String) -> Self {
|
||||||
|
let (__jar, __runtime) = <_ as salsa::storage::HasJar<crate::Jar>>::jar(__db);
|
||||||
|
let __ingredients =
|
||||||
|
<crate::Jar as salsa::storage::HasIngredientsFor<MyInput>>::ingredient(__jar);
|
||||||
|
let __id = __ingredients.1.new_input(__runtime);
|
||||||
|
__ingredients
|
||||||
|
.0
|
||||||
|
.store_new(__runtime, __id, field, salsa::Durability::LOW);
|
||||||
|
__id
|
||||||
|
}
|
||||||
|
fn field<'db>(self, __db: &'db <crate::Jar as salsa::jar::Jar<'_>>::DynDb) -> String {
|
||||||
|
let (__jar, __runtime) = <_ as salsa::storage::HasJar<crate::Jar>>::jar(__db);
|
||||||
|
let __ingredients =
|
||||||
|
<crate::Jar as salsa::storage::HasIngredientsFor<MyInput>>::ingredient(__jar);
|
||||||
|
__ingredients.0.fetch(__runtime, self).clone()
|
||||||
|
}
|
||||||
|
fn set_field<'db>(
|
||||||
|
self,
|
||||||
|
__db: &'db mut <crate::Jar as salsa::jar::Jar<'_>>::DynDb,
|
||||||
|
) -> salsa::setter::Setter<'db, MyInput, String> {
|
||||||
|
let (__jar, __runtime) = <_ as salsa::storage::HasJar<crate::Jar>>::jar_mut(__db);
|
||||||
|
let __ingredients =
|
||||||
|
<crate::Jar as salsa::storage::HasIngredientsFor<MyInput>>::ingredient_mut(__jar);
|
||||||
|
salsa::setter::Setter::new(__runtime, self, &mut __ingredients.0)
|
||||||
|
}
|
||||||
|
pub fn salsa_id(&self) -> salsa::Id {
|
||||||
|
self.0
|
||||||
|
}
|
||||||
|
}
|
||||||
|
impl salsa::storage::IngredientsFor for MyInput {
|
||||||
|
type Jar = crate::Jar;
|
||||||
|
type Ingredients = (
|
||||||
|
salsa::input_field::InputFieldIngredient<MyInput, String>,
|
||||||
|
salsa::input::InputIngredient<MyInput>,
|
||||||
|
);
|
||||||
|
fn create_ingredients<DB>(routes: &mut salsa::routes::Routes<DB>) -> Self::Ingredients
|
||||||
|
where
|
||||||
|
DB: salsa::DbWithJar<Self::Jar> + salsa::storage::JarFromJars<Self::Jar>,
|
||||||
|
{
|
||||||
|
(
|
||||||
|
{
|
||||||
|
let index = routes.push(
|
||||||
|
|jars| {
|
||||||
|
let jar =
|
||||||
|
<DB as salsa::storage::JarFromJars<Self::Jar>>::jar_from_jars(jars);
|
||||||
|
let ingredients =
|
||||||
|
<_ as salsa::storage::HasIngredientsFor<Self>>::ingredient(jar);
|
||||||
|
&ingredients.0
|
||||||
|
},
|
||||||
|
|jars| {
|
||||||
|
let jar =
|
||||||
|
<DB as salsa::storage::JarFromJars<Self::Jar>>::jar_from_jars_mut(jars);
|
||||||
|
let ingredients =
|
||||||
|
<_ as salsa::storage::HasIngredientsFor<Self>>::ingredient_mut(jar);
|
||||||
|
&mut ingredients.0
|
||||||
|
},
|
||||||
|
);
|
||||||
|
salsa::input_field::InputFieldIngredient::new(index, "field")
|
||||||
|
},
|
||||||
|
{
|
||||||
|
let index = routes.push(
|
||||||
|
|jars| {
|
||||||
|
let jar =
|
||||||
|
<DB as salsa::storage::JarFromJars<Self::Jar>>::jar_from_jars(jars);
|
||||||
|
let ingredients =
|
||||||
|
<_ as salsa::storage::HasIngredientsFor<Self>>::ingredient(jar);
|
||||||
|
&ingredients.1
|
||||||
|
},
|
||||||
|
|jars| {
|
||||||
|
let jar =
|
||||||
|
<DB as salsa::storage::JarFromJars<Self::Jar>>::jar_from_jars_mut(jars);
|
||||||
|
let ingredients =
|
||||||
|
<_ as salsa::storage::HasIngredientsFor<Self>>::ingredient_mut(jar);
|
||||||
|
&mut ingredients.1
|
||||||
|
},
|
||||||
|
);
|
||||||
|
salsa::input::InputIngredient::new(index, "MyInput")
|
||||||
|
},
|
||||||
|
)
|
||||||
|
}
|
||||||
|
}
|
||||||
|
impl salsa::id::AsId for MyInput {
|
||||||
|
fn as_id(&self) -> salsa::Id {
|
||||||
|
self.0
|
||||||
|
}
|
||||||
|
}
|
||||||
|
impl salsa::id::FromId for MyInput {
|
||||||
|
fn from_id(id: salsa::Id) -> Self {
|
||||||
|
MyInput(id)
|
||||||
|
}
|
||||||
|
}
|
||||||
|
impl ::salsa::DebugWithDb<<crate::Jar as salsa::jar::Jar<'_>>::DynDb> for MyInput {
|
||||||
|
fn fmt(
|
||||||
|
&self,
|
||||||
|
f: &mut ::std::fmt::Formatter<'_>,
|
||||||
|
_db: &<crate::Jar as salsa::jar::Jar<'_>>::DynDb,
|
||||||
|
) -> ::std::fmt::Result {
|
||||||
|
#[allow(unused_imports)]
|
||||||
|
use ::salsa::debug::helper::Fallback;
|
||||||
|
#[allow(unused_mut)]
|
||||||
|
let mut debug_struct = &mut f.debug_struct("MyInput");
|
||||||
|
debug_struct = debug_struct.field("[salsa id]", &self.salsa_id().as_u32());
|
||||||
|
debug_struct =
|
||||||
|
debug_struct.field(
|
||||||
|
"field",
|
||||||
|
&::salsa::debug::helper::SalsaDebug::<
|
||||||
|
String,
|
||||||
|
<crate::Jar as salsa::jar::Jar<'_>>::DynDb,
|
||||||
|
>::salsa_debug(
|
||||||
|
#[allow(clippy::needless_borrow)]
|
||||||
|
&self.field(_db),
|
||||||
|
_db,
|
||||||
|
),
|
||||||
|
);
|
||||||
|
debug_struct.finish()
|
||||||
|
}
|
||||||
|
}
|
||||||
|
impl<DB> salsa::salsa_struct::SalsaStructInDb<DB> for MyInput
|
||||||
|
where
|
||||||
|
DB: ?Sized + salsa::DbWithJar<crate::Jar>,
|
||||||
|
{
|
||||||
|
fn register_dependent_fn(_db: &DB, _index: salsa::routes::IngredientIndex) {}
|
||||||
|
}
|
||||||
|
impl ::std::fmt::Debug for MyInput {
|
||||||
|
fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
|
||||||
|
f.debug_struct("MyInput")
|
||||||
|
.field("[salsa id]", &self.salsa_id().as_u32())
|
||||||
|
.finish()
|
||||||
|
}
|
||||||
|
}
|
||||||
|
struct __MyTrackedConfig {
|
||||||
|
_uninhabited: std::convert::Infallible,
|
||||||
|
}
|
||||||
|
impl salsa::tracked_struct::Configuration for __MyTrackedConfig {
|
||||||
|
type Fields<'db> = (MyInput, MyList<'db>);
|
||||||
|
type Revisions = [salsa::Revision; 2];
|
||||||
|
#[allow(clippy::unused_unit)]
|
||||||
|
fn id_fields(fields: &Self::Fields<'_>) -> impl std::hash::Hash {
|
||||||
|
()
|
||||||
|
}
|
||||||
|
fn revision(revisions: &Self::Revisions, field_index: u32) -> salsa::Revision {
|
||||||
|
revisions[field_index as usize]
|
||||||
|
}
|
||||||
|
fn new_revisions(current_revision: salsa::Revision) -> Self::Revisions {
|
||||||
|
[current_revision; 2]
|
||||||
|
}
|
||||||
|
unsafe fn update_fields<'db>(
|
||||||
|
current_revision_: salsa::Revision,
|
||||||
|
revisions_: &mut Self::Revisions,
|
||||||
|
old_fields_: *mut Self::Fields<'db>,
|
||||||
|
new_fields_: Self::Fields<'db>,
|
||||||
|
) {
|
||||||
|
use salsa::update::helper::Fallback as _;
|
||||||
|
if salsa::update::helper::Dispatch::<MyInput>::maybe_update(
|
||||||
|
&raw mut (*old_fields_).0,
|
||||||
|
new_fields_.0,
|
||||||
|
) {
|
||||||
|
revisions_[0] = current_revision_;
|
||||||
|
}
|
||||||
|
if salsa::update::helper::Dispatch::<MyList<'db>>::maybe_update(
|
||||||
|
&raw mut (*old_fields_).1,
|
||||||
|
new_fields_.1,
|
||||||
|
) {
|
||||||
|
revisions_[1] = current_revision_;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
struct MyTracked<'db>(
|
||||||
|
*const salsa::tracked_struct::ValueStruct<__MyTrackedConfig>,
|
||||||
|
std::marker::PhantomData<&'db salsa::tracked_struct::ValueStruct<__MyTrackedConfig>>,
|
||||||
|
);
|
||||||
|
#[automatically_derived]
|
||||||
|
impl<'db> ::core::marker::Copy for MyTracked<'db> {}
|
||||||
|
#[automatically_derived]
|
||||||
|
impl<'db> ::core::clone::Clone for MyTracked<'db> {
|
||||||
|
#[inline]
|
||||||
|
fn clone(&self) -> MyTracked<'db> {
|
||||||
|
let _: ::core::clone::AssertParamIsClone<
|
||||||
|
*const salsa::tracked_struct::ValueStruct<__MyTrackedConfig>,
|
||||||
|
>;
|
||||||
|
let _: ::core::clone::AssertParamIsClone<
|
||||||
|
std::marker::PhantomData<&'db salsa::tracked_struct::ValueStruct<__MyTrackedConfig>>,
|
||||||
|
>;
|
||||||
|
*self
|
||||||
|
}
|
||||||
|
}
|
||||||
|
#[automatically_derived]
|
||||||
|
impl<'db> ::core::marker::StructuralPartialEq for MyTracked<'db> {}
|
||||||
|
#[automatically_derived]
|
||||||
|
impl<'db> ::core::cmp::PartialEq for MyTracked<'db> {
|
||||||
|
#[inline]
|
||||||
|
fn eq(&self, other: &MyTracked<'db>) -> bool {
|
||||||
|
self.0 == other.0 && self.1 == other.1
|
||||||
|
}
|
||||||
|
}
|
||||||
|
#[automatically_derived]
|
||||||
|
impl<'db> ::core::cmp::PartialOrd for MyTracked<'db> {
|
||||||
|
#[inline]
|
||||||
|
fn partial_cmp(&self, other: &MyTracked<'db>) -> ::core::option::Option<::core::cmp::Ordering> {
|
||||||
|
match ::core::cmp::PartialOrd::partial_cmp(&self.0, &other.0) {
|
||||||
|
::core::option::Option::Some(::core::cmp::Ordering::Equal) => {
|
||||||
|
::core::cmp::PartialOrd::partial_cmp(&self.1, &other.1)
|
||||||
|
}
|
||||||
|
cmp => cmp,
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
#[automatically_derived]
|
||||||
|
impl<'db> ::core::cmp::Eq for MyTracked<'db> {
|
||||||
|
#[inline]
|
||||||
|
#[doc(hidden)]
|
||||||
|
#[coverage(off)]
|
||||||
|
fn assert_receiver_is_total_eq(&self) -> () {
|
||||||
|
let _: ::core::cmp::AssertParamIsEq<
|
||||||
|
*const salsa::tracked_struct::ValueStruct<__MyTrackedConfig>,
|
||||||
|
>;
|
||||||
|
let _: ::core::cmp::AssertParamIsEq<
|
||||||
|
std::marker::PhantomData<&'db salsa::tracked_struct::ValueStruct<__MyTrackedConfig>>,
|
||||||
|
>;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
#[automatically_derived]
|
||||||
|
impl<'db> ::core::cmp::Ord for MyTracked<'db> {
|
||||||
|
#[inline]
|
||||||
|
fn cmp(&self, other: &MyTracked<'db>) -> ::core::cmp::Ordering {
|
||||||
|
match ::core::cmp::Ord::cmp(&self.0, &other.0) {
|
||||||
|
::core::cmp::Ordering::Equal => ::core::cmp::Ord::cmp(&self.1, &other.1),
|
||||||
|
cmp => cmp,
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
#[automatically_derived]
|
||||||
|
impl<'db> ::core::hash::Hash for MyTracked<'db> {
|
||||||
|
#[inline]
|
||||||
|
fn hash<__H: ::core::hash::Hasher>(&self, state: &mut __H) -> () {
|
||||||
|
::core::hash::Hash::hash(&self.0, state);
|
||||||
|
::core::hash::Hash::hash(&self.1, state)
|
||||||
|
}
|
||||||
|
}
|
||||||
|
#[allow(dead_code, clippy::pedantic, clippy::complexity, clippy::style)]
|
||||||
|
impl<'db> MyTracked<'db> {
|
||||||
|
pub fn new(
|
||||||
|
__db: &'db <crate::Jar as salsa::jar::Jar<'db>>::DynDb,
|
||||||
|
data: MyInput,
|
||||||
|
next: MyList<'db>,
|
||||||
|
) -> Self {
|
||||||
|
let (__jar, __runtime) = <_ as salsa::storage::HasJar<crate::Jar>>::jar(__db);
|
||||||
|
let __ingredients =
|
||||||
|
<crate::Jar as salsa::storage::HasIngredientsFor<Self>>::ingredient(__jar);
|
||||||
|
let __data = __ingredients.0.new_struct(__runtime, (data, next));
|
||||||
|
Self(__data, std::marker::PhantomData)
|
||||||
|
}
|
||||||
|
pub fn salsa_id(&self) -> salsa::Id {
|
||||||
|
salsa::id::AsId::as_id(unsafe { &*self.0 })
|
||||||
|
}
|
||||||
|
fn data(self, __db: &'db <crate::Jar as salsa::jar::Jar<'db>>::DynDb) -> MyInput {
|
||||||
|
let (_, __runtime) = <_ as salsa::storage::HasJar<crate::Jar>>::jar(__db);
|
||||||
|
let fields = unsafe { &*self.0 }.field(__runtime, 0);
|
||||||
|
fields.0.clone()
|
||||||
|
}
|
||||||
|
fn next(self, __db: &'db <crate::Jar as salsa::jar::Jar<'db>>::DynDb) -> MyList<'db> {
|
||||||
|
let (_, __runtime) = <_ as salsa::storage::HasJar<crate::Jar>>::jar(__db);
|
||||||
|
let fields = unsafe { &*self.0 }.field(__runtime, 1);
|
||||||
|
fields.1.clone()
|
||||||
|
}
|
||||||
|
}
|
||||||
|
impl<'db> salsa::storage::IngredientsFor for MyTracked<'db> {
|
||||||
|
type Jar = crate::Jar;
|
||||||
|
type Ingredients = (
|
||||||
|
salsa::tracked_struct::TrackedStructIngredient<__MyTrackedConfig>,
|
||||||
|
[salsa::tracked_struct::TrackedFieldIngredient<__MyTrackedConfig>; 2],
|
||||||
|
);
|
||||||
|
fn create_ingredients<DB>(routes: &mut salsa::routes::Routes<DB>) -> Self::Ingredients
|
||||||
|
where
|
||||||
|
DB: salsa::DbWithJar<Self::Jar> + salsa::storage::JarFromJars<Self::Jar>,
|
||||||
|
{
|
||||||
|
let struct_ingredient = {
|
||||||
|
let index = routes.push(
|
||||||
|
|jars| {
|
||||||
|
let jar = <DB as salsa::storage::JarFromJars<Self::Jar>>::jar_from_jars(jars);
|
||||||
|
let ingredients =
|
||||||
|
<_ as salsa::storage::HasIngredientsFor<Self>>::ingredient(jar);
|
||||||
|
&ingredients.0
|
||||||
|
},
|
||||||
|
|jars| {
|
||||||
|
let jar =
|
||||||
|
<DB as salsa::storage::JarFromJars<Self::Jar>>::jar_from_jars_mut(jars);
|
||||||
|
let ingredients =
|
||||||
|
<_ as salsa::storage::HasIngredientsFor<Self>>::ingredient_mut(jar);
|
||||||
|
&mut ingredients.0
|
||||||
|
},
|
||||||
|
);
|
||||||
|
salsa::tracked_struct::TrackedStructIngredient::new(index, "MyTracked")
|
||||||
|
};
|
||||||
|
let field_ingredients = [
|
||||||
|
{
|
||||||
|
let index = routes.push(
|
||||||
|
|jars| {
|
||||||
|
let jar =
|
||||||
|
<DB as salsa::storage::JarFromJars<Self::Jar>>::jar_from_jars(jars);
|
||||||
|
let ingredients =
|
||||||
|
<_ as salsa::storage::HasIngredientsFor<Self>>::ingredient(jar);
|
||||||
|
&ingredients.1[0]
|
||||||
|
},
|
||||||
|
|jars| {
|
||||||
|
let jar =
|
||||||
|
<DB as salsa::storage::JarFromJars<Self::Jar>>::jar_from_jars_mut(jars);
|
||||||
|
let ingredients =
|
||||||
|
<_ as salsa::storage::HasIngredientsFor<Self>>::ingredient_mut(jar);
|
||||||
|
&mut ingredients.1[0]
|
||||||
|
},
|
||||||
|
);
|
||||||
|
struct_ingredient.new_field_ingredient(index, 0, "data")
|
||||||
|
},
|
||||||
|
{
|
||||||
|
let index = routes.push(
|
||||||
|
|jars| {
|
||||||
|
let jar =
|
||||||
|
<DB as salsa::storage::JarFromJars<Self::Jar>>::jar_from_jars(jars);
|
||||||
|
let ingredients =
|
||||||
|
<_ as salsa::storage::HasIngredientsFor<Self>>::ingredient(jar);
|
||||||
|
&ingredients.1[1]
|
||||||
|
},
|
||||||
|
|jars| {
|
||||||
|
let jar =
|
||||||
|
<DB as salsa::storage::JarFromJars<Self::Jar>>::jar_from_jars_mut(jars);
|
||||||
|
let ingredients =
|
||||||
|
<_ as salsa::storage::HasIngredientsFor<Self>>::ingredient_mut(jar);
|
||||||
|
&mut ingredients.1[1]
|
||||||
|
},
|
||||||
|
);
|
||||||
|
struct_ingredient.new_field_ingredient(index, 1, "next")
|
||||||
|
},
|
||||||
|
];
|
||||||
|
(struct_ingredient, field_ingredients)
|
||||||
|
}
|
||||||
|
}
|
||||||
|
impl<'db, DB> salsa::salsa_struct::SalsaStructInDb<DB> for MyTracked<'db>
|
||||||
|
where
|
||||||
|
DB: ?Sized + salsa::DbWithJar<crate::Jar>,
|
||||||
|
{
|
||||||
|
fn register_dependent_fn(db: &DB, index: salsa::routes::IngredientIndex) {
|
||||||
|
let (jar, _) = <_ as salsa::storage::HasJar<crate::Jar>>::jar(db);
|
||||||
|
let ingredients =
|
||||||
|
<crate::Jar as salsa::storage::HasIngredientsFor<MyTracked<'db>>>::ingredient(jar);
|
||||||
|
ingredients.0.register_dependent_fn(index)
|
||||||
|
}
|
||||||
|
}
|
||||||
|
impl<'db, DB> salsa::tracked_struct::TrackedStructInDb<DB> for MyTracked<'db>
|
||||||
|
where
|
||||||
|
DB: ?Sized + salsa::DbWithJar<crate::Jar>,
|
||||||
|
{
|
||||||
|
fn database_key_index(db: &DB, id: salsa::Id) -> salsa::DatabaseKeyIndex {
|
||||||
|
let (jar, _) = <_ as salsa::storage::HasJar<crate::Jar>>::jar(db);
|
||||||
|
let ingredients =
|
||||||
|
<crate::Jar as salsa::storage::HasIngredientsFor<MyTracked<'db>>>::ingredient(jar);
|
||||||
|
ingredients.0.database_key_index(id)
|
||||||
|
}
|
||||||
|
}
|
||||||
|
unsafe impl<'db> salsa::update::Update for MyTracked<'db> {
|
||||||
|
unsafe fn maybe_update(old_pointer: *mut Self, new_value: Self) -> bool {
|
||||||
|
if unsafe { *old_pointer } != new_value {
|
||||||
|
unsafe { *old_pointer = new_value };
|
||||||
|
true
|
||||||
|
} else {
|
||||||
|
false
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
impl<'db> salsa::id::AsId for MyTracked<'db> {
|
||||||
|
fn as_id(&self) -> salsa::Id {
|
||||||
|
salsa::id::AsId::as_id(unsafe { &*self.0 })
|
||||||
|
}
|
||||||
|
}
|
||||||
|
unsafe impl<'db> std::marker::Send for MyTracked<'db> {}
|
||||||
|
unsafe impl<'db> std::marker::Sync for MyTracked<'db> {}
|
||||||
|
impl<'db, DB> salsa::id::LookupId<&'db DB> for MyTracked<'db>
|
||||||
|
where
|
||||||
|
DB: ?Sized + salsa::DbWithJar<crate::Jar>,
|
||||||
|
{
|
||||||
|
fn lookup_id(id: salsa::Id, db: &'db DB) -> Self {
|
||||||
|
let (jar, runtime) = <_ as salsa::storage::HasJar<crate::Jar>>::jar(db);
|
||||||
|
let ingredients =
|
||||||
|
<crate::Jar as salsa::storage::HasIngredientsFor<MyTracked<'db>>>::ingredient(jar);
|
||||||
|
Self(
|
||||||
|
ingredients.0.lookup_struct(runtime, id),
|
||||||
|
std::marker::PhantomData,
|
||||||
|
)
|
||||||
|
}
|
||||||
|
}
|
||||||
|
impl<'db> ::salsa::DebugWithDb<<crate::Jar as salsa::jar::Jar<'db>>::DynDb> for MyTracked<'db> {
|
||||||
|
fn fmt(
|
||||||
|
&self,
|
||||||
|
f: &mut ::std::fmt::Formatter<'_>,
|
||||||
|
_db: &<crate::Jar as salsa::jar::Jar<'db>>::DynDb,
|
||||||
|
) -> ::std::fmt::Result {
|
||||||
|
#[allow(unused_imports)]
|
||||||
|
use ::salsa::debug::helper::Fallback;
|
||||||
|
#[allow(unused_mut)]
|
||||||
|
let mut debug_struct = &mut f.debug_struct("MyTracked");
|
||||||
|
debug_struct = debug_struct.field("[salsa id]", &self.salsa_id().as_u32());
|
||||||
|
debug_struct = debug_struct.field(
|
||||||
|
"data",
|
||||||
|
&::salsa::debug::helper::SalsaDebug::<
|
||||||
|
MyInput,
|
||||||
|
<crate::Jar as salsa::jar::Jar<'_>>::DynDb,
|
||||||
|
>::salsa_debug(
|
||||||
|
#[allow(clippy::needless_borrow)]
|
||||||
|
&self.data(_db),
|
||||||
|
_db,
|
||||||
|
),
|
||||||
|
);
|
||||||
|
debug_struct = debug_struct.field(
|
||||||
|
"next",
|
||||||
|
&::salsa::debug::helper::SalsaDebug::<
|
||||||
|
MyList<'_>,
|
||||||
|
<crate::Jar as salsa::jar::Jar<'_>>::DynDb,
|
||||||
|
>::salsa_debug(
|
||||||
|
#[allow(clippy::needless_borrow)]
|
||||||
|
&self.next(_db),
|
||||||
|
_db,
|
||||||
|
),
|
||||||
|
);
|
||||||
|
debug_struct.finish()
|
||||||
|
}
|
||||||
|
}
|
||||||
|
impl<'db> ::std::fmt::Debug for MyTracked<'db> {
|
||||||
|
fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
|
||||||
|
f.debug_struct("MyTracked")
|
||||||
|
.field("[salsa id]", &self.salsa_id().as_u32())
|
||||||
|
.finish()
|
||||||
|
}
|
||||||
|
}
|
||||||
|
enum MyList<'db> {
|
||||||
|
None,
|
||||||
|
Next(MyTracked<'db>),
|
||||||
|
}
|
||||||
|
#[automatically_derived]
|
||||||
|
impl<'db> ::core::marker::StructuralPartialEq for MyList<'db> {}
|
||||||
|
#[automatically_derived]
|
||||||
|
impl<'db> ::core::cmp::PartialEq for MyList<'db> {
|
||||||
|
#[inline]
|
||||||
|
fn eq(&self, other: &MyList<'db>) -> bool {
|
||||||
|
let __self_discr = ::core::intrinsics::discriminant_value(self);
|
||||||
|
let __arg1_discr = ::core::intrinsics::discriminant_value(other);
|
||||||
|
__self_discr == __arg1_discr
|
||||||
|
&& match (self, other) {
|
||||||
|
(MyList::Next(__self_0), MyList::Next(__arg1_0)) => __self_0 == __arg1_0,
|
||||||
|
_ => true,
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
#[automatically_derived]
|
||||||
|
impl<'db> ::core::cmp::Eq for MyList<'db> {
|
||||||
|
#[inline]
|
||||||
|
#[doc(hidden)]
|
||||||
|
#[coverage(off)]
|
||||||
|
fn assert_receiver_is_total_eq(&self) -> () {
|
||||||
|
let _: ::core::cmp::AssertParamIsEq<MyTracked<'db>>;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
#[automatically_derived]
|
||||||
|
impl<'db> ::core::clone::Clone for MyList<'db> {
|
||||||
|
#[inline]
|
||||||
|
fn clone(&self) -> MyList<'db> {
|
||||||
|
match self {
|
||||||
|
MyList::None => MyList::None,
|
||||||
|
MyList::Next(__self_0) => MyList::Next(::core::clone::Clone::clone(__self_0)),
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
#[automatically_derived]
|
||||||
|
impl<'db> ::core::fmt::Debug for MyList<'db> {
|
||||||
|
#[inline]
|
||||||
|
fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
|
||||||
|
match self {
|
||||||
|
MyList::None => ::core::fmt::Formatter::write_str(f, "None"),
|
||||||
|
MyList::Next(__self_0) => {
|
||||||
|
::core::fmt::Formatter::debug_tuple_field1_finish(f, "Next", &__self_0)
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
unsafe impl<'db> salsa::update::Update for MyList<'db> {
|
||||||
|
unsafe fn maybe_update(old_pointer: *mut Self, new_value: Self) -> bool {
|
||||||
|
use ::salsa::update::helper::Fallback as _;
|
||||||
|
let old_pointer = unsafe { &mut *old_pointer };
|
||||||
|
match old_pointer {
|
||||||
|
MyList::None => {
|
||||||
|
let new_value = if let MyList::None = new_value {
|
||||||
|
()
|
||||||
|
} else {
|
||||||
|
*old_pointer = new_value;
|
||||||
|
return true;
|
||||||
|
};
|
||||||
|
false
|
||||||
|
}
|
||||||
|
MyList::Next(__binding_0) => {
|
||||||
|
let new_value = if let MyList::Next(__binding_0) = new_value {
|
||||||
|
(__binding_0,)
|
||||||
|
} else {
|
||||||
|
*old_pointer = new_value;
|
||||||
|
return true;
|
||||||
|
};
|
||||||
|
false
|
||||||
|
| unsafe {
|
||||||
|
salsa::update::helper::Dispatch::<MyTracked<'db>>::maybe_update(
|
||||||
|
__binding_0,
|
||||||
|
new_value.0,
|
||||||
|
)
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
const _: () = {
|
||||||
|
impl<'db> ::salsa::debug::DebugWithDb<<crate::Jar as salsa::jar::Jar<'db>>::DynDb> for MyList<'db> {
|
||||||
|
fn fmt(
|
||||||
|
&self,
|
||||||
|
fmt: &mut std::fmt::Formatter<'_>,
|
||||||
|
db: &<crate::Jar as salsa::jar::Jar<'db>>::DynDb,
|
||||||
|
) -> std::fmt::Result {
|
||||||
|
use ::salsa::debug::helper::Fallback as _;
|
||||||
|
match self {
|
||||||
|
MyList::None => { fmt.debug_tuple("None") }.finish(),
|
||||||
|
MyList::Next(ref __binding_0) => {
|
||||||
|
fmt.debug_tuple("Next")
|
||||||
|
.field(&::salsa::debug::helper::SalsaDebug::<
|
||||||
|
MyTracked<'db>,
|
||||||
|
<crate::Jar as salsa::jar::Jar<'db>>::DynDb,
|
||||||
|
>::salsa_debug(__binding_0, db))
|
||||||
|
}
|
||||||
|
.finish(),
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
};
|
||||||
|
#[allow(non_camel_case_types)]
|
||||||
|
struct create_tracked_list {
|
||||||
|
intern_map: salsa::interned::IdentityInterner<Self>,
|
||||||
|
function: salsa::function::FunctionIngredient<Self>,
|
||||||
|
}
|
||||||
|
impl salsa::function::Configuration for create_tracked_list {
|
||||||
|
type Jar = crate::Jar;
|
||||||
|
type SalsaStruct<'db> = MyInput;
|
||||||
|
type Input<'db> = MyInput;
|
||||||
|
type Value<'db> = MyTracked<'db>;
|
||||||
|
const CYCLE_STRATEGY: salsa::cycle::CycleRecoveryStrategy =
|
||||||
|
salsa::cycle::CycleRecoveryStrategy::Panic;
|
||||||
|
fn should_backdate_value(v1: &Self::Value<'_>, v2: &Self::Value<'_>) -> bool {
|
||||||
|
salsa::function::should_backdate_value(v1, v2)
|
||||||
|
}
|
||||||
|
fn execute<'db>(
|
||||||
|
__db: &'db salsa::function::DynDb<'db, Self>,
|
||||||
|
__id: salsa::Id,
|
||||||
|
) -> Self::Value<'db> {
|
||||||
|
fn __fn<'db>(db: &'db dyn Db, input: MyInput) -> MyTracked<'db> {
|
||||||
|
let t0 = MyTracked::new(db, input, MyList::None);
|
||||||
|
let t1 = MyTracked::new(db, input, MyList::Next(t0));
|
||||||
|
t1
|
||||||
|
}
|
||||||
|
let (__jar, __runtime) = <_ as salsa::storage::HasJar<crate::Jar>>::jar(__db);
|
||||||
|
let __ingredients =
|
||||||
|
<_ as salsa::storage::HasIngredientsFor<create_tracked_list>>::ingredient(__jar);
|
||||||
|
let __key = __ingredients.intern_map.data_with_db(__id, __db).clone();
|
||||||
|
__fn(__db, __key)
|
||||||
|
}
|
||||||
|
fn recover_from_cycle<'db>(
|
||||||
|
_db: &'db salsa::function::DynDb<'db, Self>,
|
||||||
|
_cycle: &salsa::Cycle,
|
||||||
|
_key: salsa::Id,
|
||||||
|
) -> Self::Value<'db> {
|
||||||
|
{
|
||||||
|
#[cold]
|
||||||
|
#[track_caller]
|
||||||
|
#[inline(never)]
|
||||||
|
const fn panic_cold_explicit() -> ! {
|
||||||
|
::core::panicking::panic_explicit()
|
||||||
|
}
|
||||||
|
panic_cold_explicit();
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
impl salsa::interned::Configuration for create_tracked_list {
|
||||||
|
type Data<'db> = (MyInput);
|
||||||
|
}
|
||||||
|
impl salsa::storage::IngredientsFor for create_tracked_list {
|
||||||
|
type Ingredients = Self;
|
||||||
|
type Jar = crate::Jar;
|
||||||
|
fn create_ingredients<DB>(routes: &mut salsa::routes::Routes<DB>) -> Self::Ingredients
|
||||||
|
where
|
||||||
|
DB: salsa::DbWithJar<Self::Jar> + salsa::storage::JarFromJars<Self::Jar>,
|
||||||
|
{
|
||||||
|
Self {
|
||||||
|
intern_map: salsa::interned::IdentityInterner::new(),
|
||||||
|
function: {
|
||||||
|
let index = routes.push(
|
||||||
|
|jars| {
|
||||||
|
let jar =
|
||||||
|
<DB as salsa::storage::JarFromJars<Self::Jar>>::jar_from_jars(jars);
|
||||||
|
let ingredients = <_ as salsa::storage::HasIngredientsFor<
|
||||||
|
Self::Ingredients,
|
||||||
|
>>::ingredient(jar);
|
||||||
|
&ingredients.function
|
||||||
|
},
|
||||||
|
|jars| {
|
||||||
|
let jar =
|
||||||
|
<DB as salsa::storage::JarFromJars<Self::Jar>>::jar_from_jars_mut(jars);
|
||||||
|
let ingredients = <_ as salsa::storage::HasIngredientsFor<
|
||||||
|
Self::Ingredients,
|
||||||
|
>>::ingredient_mut(jar);
|
||||||
|
&mut ingredients.function
|
||||||
|
},
|
||||||
|
);
|
||||||
|
let ingredient =
|
||||||
|
salsa::function::FunctionIngredient::new(index, "create_tracked_list");
|
||||||
|
ingredient.set_capacity(0usize);
|
||||||
|
ingredient
|
||||||
|
},
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
impl create_tracked_list {
|
||||||
|
#[allow(dead_code, clippy::needless_lifetimes)]
|
||||||
|
fn get<'db>(db: &'db dyn Db, input: MyInput) -> &'db MyTracked<'db> {
|
||||||
|
let (__jar, __runtime) = <_ as salsa::storage::HasJar<crate::Jar>>::jar(db);
|
||||||
|
let __ingredients =
|
||||||
|
<_ as salsa::storage::HasIngredientsFor<create_tracked_list>>::ingredient(__jar);
|
||||||
|
let __key = __ingredients.intern_map.intern_id(__runtime, (input));
|
||||||
|
__ingredients.function.fetch(db, __key)
|
||||||
|
}
|
||||||
|
#[allow(dead_code, clippy::needless_lifetimes)]
|
||||||
|
fn set<'db>(db: &'db mut dyn Db, input: MyInput, __value: MyTracked<'db>) {
|
||||||
|
let (__jar, __runtime) = <_ as salsa::storage::HasJar<crate::Jar>>::jar_mut(db);
|
||||||
|
let __ingredients =
|
||||||
|
<_ as salsa::storage::HasIngredientsFor<create_tracked_list>>::ingredient_mut(__jar);
|
||||||
|
let __key = __ingredients.intern_map.intern_id(__runtime, (input));
|
||||||
|
__ingredients
|
||||||
|
.function
|
||||||
|
.store(__runtime, __key, __value, salsa::Durability::LOW)
|
||||||
|
}
|
||||||
|
#[allow(dead_code, clippy::needless_lifetimes)]
|
||||||
|
fn accumulated<'db, __A: salsa::accumulator::Accumulator>(
|
||||||
|
db: &'db dyn Db,
|
||||||
|
input: MyInput,
|
||||||
|
) -> Vec<<__A as salsa::accumulator::Accumulator>::Data>
|
||||||
|
where
|
||||||
|
<crate::Jar as salsa::jar::Jar<'db>>::DynDb:
|
||||||
|
salsa::storage::HasJar<<__A as salsa::accumulator::Accumulator>::Jar>,
|
||||||
|
{
|
||||||
|
let (__jar, __runtime) = <_ as salsa::storage::HasJar<crate::Jar>>::jar(db);
|
||||||
|
let __ingredients =
|
||||||
|
<_ as salsa::storage::HasIngredientsFor<create_tracked_list>>::ingredient(__jar);
|
||||||
|
let __key = __ingredients.intern_map.intern_id(__runtime, (input));
|
||||||
|
__ingredients.function.accumulated::<__A>(db, __key)
|
||||||
|
}
|
||||||
|
}
|
||||||
|
#[allow(clippy::needless_lifetimes)]
|
||||||
|
fn create_tracked_list<'db>(db: &'db dyn Db, input: MyInput) -> MyTracked<'db> {
|
||||||
|
Clone::clone(create_tracked_list::get(db, input))
|
||||||
|
}
|
||||||
|
extern crate test;
|
||||||
|
#[cfg(test)]
|
||||||
|
#[rustc_test_marker = "execute"]
|
||||||
|
pub const execute: test::TestDescAndFn = test::TestDescAndFn {
|
||||||
|
desc: test::TestDesc {
|
||||||
|
name: test::StaticTestName("execute"),
|
||||||
|
ignore: false,
|
||||||
|
ignore_message: ::core::option::Option::None,
|
||||||
|
source_file: "salsa-2022-tests/tests/tracked_with_struct_db.rs",
|
||||||
|
start_line: 47usize,
|
||||||
|
start_col: 4usize,
|
||||||
|
end_line: 47usize,
|
||||||
|
end_col: 11usize,
|
||||||
|
compile_fail: false,
|
||||||
|
no_run: false,
|
||||||
|
should_panic: test::ShouldPanic::No,
|
||||||
|
test_type: test::TestType::IntegrationTest,
|
||||||
|
},
|
||||||
|
testfn: test::StaticTestFn(
|
||||||
|
#[coverage(off)]
|
||||||
|
|| test::assert_test_result(execute1()),
|
||||||
|
),
|
||||||
|
};
|
||||||
|
fn execute1() {
|
||||||
|
mod init {
|
||||||
|
pub fn init() {
|
||||||
|
{
|
||||||
|
let mut env_logger_builder = ::test_log::env_logger::builder();
|
||||||
|
let _ = env_logger_builder.is_test(true).try_init();
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
init::init();
|
||||||
|
{
|
||||||
|
let mut db = Database::default();
|
||||||
|
let input = MyInput::new(&mut db, "foo".to_string());
|
||||||
|
let t0: MyTracked = create_tracked_list(&db, input);
|
||||||
|
let t1 = create_tracked_list(&db, input);
|
||||||
|
::expect_test::Expect {
|
||||||
|
position: ::expect_test::Position {
|
||||||
|
file: "salsa-2022-tests/tests/tracked_with_struct_db.rs",
|
||||||
|
line: 52u32,
|
||||||
|
column: 5u32,
|
||||||
|
},
|
||||||
|
data: r#"
|
||||||
|
MyTracked {
|
||||||
|
[salsa id]: 1,
|
||||||
|
data: MyInput {
|
||||||
|
[salsa id]: 0,
|
||||||
|
field: "foo",
|
||||||
|
},
|
||||||
|
next: Next(
|
||||||
|
MyTracked {
|
||||||
|
[salsa id]: 0,
|
||||||
|
data: MyInput {
|
||||||
|
[salsa id]: 0,
|
||||||
|
field: "foo",
|
||||||
|
},
|
||||||
|
next: None,
|
||||||
|
},
|
||||||
|
),
|
||||||
|
}
|
||||||
|
"#,
|
||||||
|
indent: true,
|
||||||
|
}
|
||||||
|
.assert_debug_eq(&t0.debug(&db));
|
||||||
|
match (&t0, &t1) {
|
||||||
|
(left_val, right_val) => {
|
||||||
|
if !(*left_val == *right_val) {
|
||||||
|
let kind = ::core::panicking::AssertKind::Eq;
|
||||||
|
::core::panicking::assert_failed(
|
||||||
|
kind,
|
||||||
|
&*left_val,
|
||||||
|
&*right_val,
|
||||||
|
::core::option::Option::None,
|
||||||
|
);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
};
|
||||||
|
}
|
||||||
|
}
|
||||||
|
#[rustc_main]
|
||||||
|
#[coverage(off)]
|
||||||
|
pub fn main() -> () {
|
||||||
|
extern crate test;
|
||||||
|
test::test_main_static(&[&execute])
|
||||||
|
}
|
||||||
Loading…
Reference in a new issue