Rename UpCaster back to DownCaster

Author: Veykril

components/salsa-macro-rules/src/setup_tracked_fn.rs

@@ -185,11 +185,11 @@ macro_rules! setup_tracked_fn {
                     unsafe {
                         $FN_CACHE.get_or_create(zalsa, || zalsa.lookup_jar_by_type::<$fn_name>())
                     }
-                    .get_or_init(|| *<dyn $Db as $Db>::zalsa_register_upcaster(db))
+                    .get_or_init(|| *<dyn $Db as $Db>::zalsa_register_downcaster(db))
                 }
 
                 pub fn fn_ingredient_mut(db: &mut dyn $Db) -> &mut $zalsa::function::IngredientImpl<Self> {
-                    let view = *<dyn $Db as $Db>::zalsa_register_upcaster(db);
+                    let view = *<dyn $Db as $Db>::zalsa_register_downcaster(db);
                     let zalsa_mut = db.zalsa_mut();
                     let index = zalsa_mut.lookup_jar_by_type::<$fn_name>();
                     let (ingredient, _) = zalsa_mut.lookup_ingredient_mut(index);

components/salsa-macros/src/db.rs

@@ -110,14 +110,14 @@ impl DbMacro {
         let trait_name = &input.ident;
         input.items.push(parse_quote! {
             #[doc(hidden)]
-            fn zalsa_register_upcaster(&self) -> &salsa::plumbing::DatabaseUpCaster<dyn #trait_name>;
+            fn zalsa_register_downcaster(&self) -> &salsa::plumbing::DatabaseDownCaster<dyn #trait_name>;
         });
 
-        let comment = format!(" upcast `Self` to a [`dyn {trait_name}`]");
+        let comment = format!(" downcast `Self` to a [`dyn {trait_name}`]");
         input.items.push(parse_quote! {
             #[doc = #comment]
             #[doc(hidden)]
-            fn upcast(&self) -> &dyn #trait_name where Self: Sized;
+            fn downcast(&self) -> &dyn #trait_name where Self: Sized;
         });
         Ok(())
     }
@@ -134,14 +134,14 @@ impl DbMacro {
             #[cold]
             #[inline(never)]
             #[doc(hidden)]
-            fn zalsa_register_upcaster(&self) -> &salsa::plumbing::DatabaseUpCaster<dyn #TraitPath> {
-                salsa::plumbing::views(self).add(<Self as #TraitPath>::upcast)
+            fn zalsa_register_downcaster(&self) -> &salsa::plumbing::DatabaseDownCaster<dyn #TraitPath> {
+                salsa::plumbing::views(self).add(<Self as #TraitPath>::downcast)
             }
         });
         input.items.push(parse_quote! {
             #[doc(hidden)]
             #[inline(always)]
-            fn upcast(&self) -> &dyn #TraitPath where Self: Sized {
+            fn downcast(&self) -> &dyn #TraitPath where Self: Sized {
                 self
             }
         });

src/database.rs

@@ -1,7 +1,7 @@
 use std::borrow::Cow;
 use std::ptr::NonNull;
 
-use crate::views::DatabaseUpCaster;
+use crate::views::DatabaseDownCaster;
 use crate::zalsa::{IngredientIndex, ZalsaDatabase};
 use crate::{Durability, Revision};
 
@@ -110,14 +110,14 @@ pub trait Database: Send + ZalsaDatabase + AsDynDatabase {
     #[cold]
     #[inline(never)]
     #[doc(hidden)]
-    fn zalsa_register_upcaster(&self) -> &DatabaseUpCaster<dyn Database> {
-        self.zalsa().views().upcaster_for::<dyn Database>()
+    fn zalsa_register_downcaster(&self) -> &DatabaseDownCaster<dyn Database> {
+        self.zalsa().views().downcaster_for::<dyn Database>()
         // The no-op downcaster is special cased in view caster construction.
     }
 
     #[doc(hidden)]
     #[inline(always)]
-    fn upcast(&self) -> &dyn Database
+    fn downcast(&self) -> &dyn Database
     where
         Self: Sized,
     {

src/function.rs

@@ -20,7 +20,7 @@ use crate::salsa_struct::SalsaStructInDb;
 use crate::sync::Arc;
 use crate::table::memo::MemoTableTypes;
 use crate::table::Table;
-use crate::views::DatabaseUpCaster;
+use crate::views::DatabaseDownCaster;
 use crate::zalsa::{IngredientIndex, MemoIngredientIndex, Zalsa};
 use crate::zalsa_local::QueryOriginRef;
 use crate::{Id, Revision};
@@ -124,14 +124,14 @@ pub struct IngredientImpl<C: Configuration> {
     /// Used to find memos to throw out when we have too many memoized values.
     lru: lru::Lru,
 
-    /// An upcaster to `C::DbView`.
+    /// An downcaster to `C::DbView`.
     ///
     /// # Safety
     ///
     /// The supplied database must be be the same as the database used to construct the [`Views`]
-    /// instances that this upcaster was derived from.
     /// instances that this downcaster was derived from.
-    view_caster: OnceLock<DatabaseUpCaster<C::DbView>>,
+    /// instances that this downcaster was derived from.
+    view_caster: OnceLock<DatabaseDownCaster<C::DbView>>,
 
     sync_table: SyncTable,
 
@@ -173,7 +173,7 @@ where
     /// Set the view-caster for this tracked function ingredient, if it has
     /// not already been initialized.
     #[inline]
-    pub fn get_or_init(&self, view_caster: impl FnOnce() -> DatabaseUpCaster<C::DbView>) -> &Self {
+    pub fn get_or_init(&self, view_caster: impl FnOnce() -> DatabaseDownCaster<C::DbView>) -> &Self {
         // Note that we must set this lazily as we don't have access to the database
         // type when ingredients are registered into the `Zalsa`.
         self.view_caster.get_or_init(view_caster);
@@ -239,7 +239,7 @@ where
         self.memo_ingredient_indices.get_zalsa_id(zalsa, id)
     }
 
-    fn view_caster(&self) -> &DatabaseUpCaster<C::DbView> {
+    fn view_caster(&self) -> &DatabaseDownCaster<C::DbView> {
         self.view_caster
             .get()
             .expect("tracked function ingredients cannot be accessed before calling `init`")
@@ -267,7 +267,7 @@ where
         cycle_heads: &mut CycleHeads,
     ) -> VerifyResult {
         // SAFETY: The `db` belongs to the ingredient as per caller invariant
-        let db = unsafe { self.view_caster().upcast_unchecked(db) };
+        let db = unsafe { self.view_caster().downcast_unchecked(db) };
         self.maybe_changed_after(db, input, revision, cycle_heads)
     }
 
@@ -376,7 +376,7 @@ where
         key_index: Id,
     ) -> (Option<&'db AccumulatedMap>, InputAccumulatedValues) {
         // SAFETY: The `db` belongs to the ingredient as per caller invariant
-        let db = unsafe { self.view_caster().upcast_unchecked(db) };
+        let db = unsafe { self.view_caster().downcast_unchecked(db) };
         self.accumulated_map(db, key_index)
     }
 }

src/ingredient.rs

@@ -185,7 +185,7 @@ pub trait Ingredient: Any + std::fmt::Debug + Send + Sync {
 impl dyn Ingredient {
     /// Equivalent to the `downcast` method on `Any`.
     ///
-    /// Because we do not have dyn-upcasting support, we need this workaround.
+    /// Because we do not have dyn-downcasting support, we need this workaround.
     pub fn assert_type<T: Any>(&self) -> &T {
         assert_eq!(
             self.type_id(),
@@ -201,7 +201,7 @@ impl dyn Ingredient {
 
     /// Equivalent to the `downcast` methods on `Any`.
     ///
-    /// Because we do not have dyn-upcasting support, we need this workaround.
+    /// Because we do not have dyn-downcasting support, we need this workaround.
     ///
     /// # Safety
     ///
@@ -220,7 +220,7 @@ impl dyn Ingredient {
 
     /// Equivalent to the `downcast` method on `Any`.
     ///
-    /// Because we do not have dyn-upcasting support, we need this workaround.
+    /// Because we do not have dyn-downcasting support, we need this workaround.
     pub fn assert_type_mut<T: Any>(&mut self) -> &mut T {
         assert_eq!(
             Any::type_id(self),

src/key.rs

@@ -50,7 +50,7 @@ impl DatabaseKeyIndex {
                 .maybe_changed_after(
                     zalsa,
                     // lets say we do turn this into an opaque pair of data and vtable pointer
-                    // then we also need an upcast function, from our dbview to the ingredients
+                    // then we also need an downcast function, from our dbview to the ingredients
                     // dbview
                     db,
                     self.key_index(),

src/lib.rs

@@ -109,7 +109,7 @@ pub mod plumbing {
     pub use crate::tracked_struct::TrackedStructInDb;
     pub use crate::update::helper::{Dispatch as UpdateDispatch, Fallback as UpdateFallback};
     pub use crate::update::{always_update, Update};
-    pub use crate::views::DatabaseUpCaster;
+    pub use crate::views::DatabaseDownCaster;
     pub use crate::zalsa::{
         register_jar, transmute_data_ptr, views, ErasedJar, HasJar, IngredientIndex, JarKind,
         Zalsa, ZalsaDatabase,

src/parallel.rs

@@ -1,6 +1,6 @@
 use rayon::iter::{FromParallelIterator, IntoParallelIterator, ParallelIterator};
 
-use crate::{database::RawDatabasePointer, views::DatabaseUpCaster, Database};
+use crate::{database::RawDatabasePointer, views::DatabaseDownCaster, Database};
 
 pub fn par_map<Db, F, T, R, C>(db: &Db, inputs: impl IntoParallelIterator<Item = T>, op: F) -> C
 where
@@ -11,8 +11,8 @@ where
     C: FromParallelIterator<R>,
 {
     let views = db.zalsa().views();
-    let caster = &views.upcaster_for::<Db>();
-    let db_caster = &views.base_database_upcaster();
+    let caster = &views.downcaster_for::<Db>();
+    let db_caster = &views.base_database_downcaster();
     inputs
         .into_par_iter()
         .map_with(
@@ -24,24 +24,24 @@ where
 
 struct DbForkOnClone<'views, Db: Database + ?Sized>(
     RawDatabasePointer<'static>,
-    &'views DatabaseUpCaster<Db>,
-    &'views DatabaseUpCaster<dyn Database>,
+    &'views DatabaseDownCaster<Db>,
+    &'views DatabaseDownCaster<dyn Database>,
 );
 
 // SAFETY: `T: Send` -> `&own T: Send`, `DbForkOnClone` is an owning pointer
 unsafe impl<Db: Send + Database + ?Sized> Send for DbForkOnClone<'_, Db> {}
 
 impl<Db: Database + ?Sized> DbForkOnClone<'_, Db> {
     fn as_view(&self) -> &Db {
-        // SAFETY: The upcaster ensures that the pointer is valid for the lifetime of the view.
-        unsafe { self.1.upcast_unchecked(self.0) }
+        // SAFETY: The downcaster ensures that the pointer is valid for the lifetime of the view.
+        unsafe { self.1.downcast_unchecked(self.0) }
     }
 }
 
 impl<Db: Database + ?Sized> Drop for DbForkOnClone<'_, Db> {
     fn drop(&mut self) {
         // SAFETY: `caster` is derived from a `db` fitting for our database clone
-        let db = unsafe { self.1.upcast_mut_unchecked(self.0) };
+        let db = unsafe { self.1.downcast_mut_unchecked(self.0) };
         // SAFETY: `db` has been box allocated and leaked by `fork_db`
         _ = unsafe { Box::from_raw(db) };
     }
@@ -51,7 +51,7 @@ impl<Db: Database + ?Sized> Clone for DbForkOnClone<'_, Db> {
     fn clone(&self) -> Self {
         DbForkOnClone(
             // SAFETY: `caster` is derived from a `db` fitting for our database clone
-            unsafe { self.2.upcast_unchecked(self.0) }.fork_db(),
+            unsafe { self.2.downcast_unchecked(self.0) }.fork_db(),
             self.1,
             self.2,
         )
@@ -70,22 +70,22 @@ where
     // SAFETY: We send owning pointers over, which are Send, given the `Db` type parameter above is Send
     unsafe impl<T> Send for AssertSend<T> {}
 
-    let caster = &db.zalsa().views().upcaster_for::<Db>();
+    let caster = &db.zalsa().views().downcaster_for::<Db>();
     // we need to fork eagerly, as `rayon::join_context` gives us no option to tell whether we get
     // moved to another thread before the closure is executed
     let db_a = AssertSend(db.fork_db());
     let db_b = AssertSend(db.fork_db());
     let res = rayon::join(
         // SAFETY: `caster` is derived from a `db` fitting for our database clone
-        move || a(unsafe { caster.upcast_unchecked({ db_a }.0) }),
+        move || a(unsafe { caster.downcast_unchecked({ db_a }.0) }),
         // SAFETY: `caster` is derived from a `db` fitting for our database clone
-        move || b(unsafe { caster.upcast_unchecked({ db_b }.0) }),
+        move || b(unsafe { caster.downcast_unchecked({ db_b }.0) }),
     );
 
     // SAFETY: `db` has been box allocated and leaked by `fork_db`
     // FIXME: Clean this mess up, RAII
-    _ = unsafe { Box::from_raw(caster.upcast_mut_unchecked(db_a.0)) };
+    _ = unsafe { Box::from_raw(caster.downcast_mut_unchecked(db_a.0)) };
     // SAFETY: `db` has been box allocated and leaked by `fork_db`
-    _ = unsafe { Box::from_raw(caster.upcast_mut_unchecked(db_b.0)) };
+    _ = unsafe { Box::from_raw(caster.downcast_mut_unchecked(db_b.0)) };
     res
 }