Embed typecheck into the downcaster

Author: Veykril

src/database.rs

@@ -123,8 +123,6 @@ impl dyn Database {
     #[track_caller]
     pub fn as_view<DbView: ?Sized + Database>(&self) -> &DbView {
         let views = self.zalsa().views();
-        views.assert_database(self);
-        // SAFETY: We've asserted that the database is correct.
-        unsafe { views.downcaster_for()(self) }
+        views.downcaster_for().downcast(self)
     }
 }

src/function.rs

@@ -212,9 +212,7 @@ where
         input: Id,
         revision: Revision,
     ) -> MaybeChangedAfter {
-        db.zalsa().views().assert_database(db);
-        // SAFETY: We've asserted that the database is correct.
-        let db = unsafe { (self.view_caster)(db) };
+        let db = self.view_caster.downcast(db);
         self.maybe_changed_after(db, input, revision)
     }
 
@@ -274,9 +272,7 @@ where
         db: &'db dyn Database,
         key_index: Id,
     ) -> (Option<&'db AccumulatedMap>, InputAccumulatedValues) {
-        db.zalsa().views().assert_database(db);
-        // SAFETY: We've asserted that the database is correct.
-        let db = unsafe { (self.view_caster)(db) };
+        let db = self.view_caster.downcast(db);
         self.accumulated_map(db, key_index)
     }
 }

src/views.rs

@@ -38,11 +38,29 @@ struct DynViewCaster {
     type_name: &'static str,
 
     /// Type-erased `ViewCaster::<Db, DbView>::vtable_cast`.
-    cast: ErasedDatabaseDownCaster,
+    cast: ErasedDatabaseDownCasterSig,
 }
 
-type ErasedDatabaseDownCaster = unsafe fn(&dyn Database) -> *const ();
-pub type DatabaseDownCaster<DbView> = unsafe fn(&dyn Database) -> &DbView;
+type ErasedDatabaseDownCasterSig = unsafe fn(&dyn Database) -> *const ();
+type DatabaseDownCasterSig<DbView> = unsafe fn(&dyn Database) -> &DbView;
+
+pub struct DatabaseDownCaster<DbView: ?Sized>(TypeId, DatabaseDownCasterSig<DbView>);
+
+impl<DbView: ?Sized + Any> DatabaseDownCaster<DbView> {
+    pub fn downcast<'db>(&self, db: &'db dyn Database) -> &'db DbView {
+        assert_eq!(
+            self.0,
+            db.type_id(),
+            "Database type does not match the expected type for this `Views` instance"
+        );
+        // SAFETY: We've asserted that the database is correct.
+        unsafe { (self.1)(db) }
+    }
+
+    pub unsafe fn downcast_unchecked<'db>(&self, db: &'db dyn Database) -> &'db DbView {
+        unsafe { (self.1)(db) }
+    }
+}
 
 impl Views {
     pub(crate) fn new<Db: Database>() -> Self {
@@ -53,9 +71,10 @@ impl Views {
             target_type_id: TypeId::of::<dyn Database>(),
             type_name: std::any::type_name::<dyn Database>(),
             cast: unsafe {
-                std::mem::transmute::<DatabaseDownCaster<dyn Database>, ErasedDatabaseDownCaster>(
-                    |db| db,
-                )
+                std::mem::transmute::<
+                    DatabaseDownCasterSig<dyn Database>,
+                    ErasedDatabaseDownCasterSig,
+                >(|db| db)
             },
         });
         Self {
@@ -65,7 +84,7 @@ impl Views {
     }
 
     /// Add a new downcaster from `dyn Database` to `dyn DbView`.
-    pub fn add<DbView: ?Sized + Any>(&self, func: DatabaseDownCaster<DbView>) {
+    pub fn add<DbView: ?Sized + Any>(&self, func: DatabaseDownCasterSig<DbView>) {
         let target_type_id = TypeId::of::<DbView>();
         if self
             .view_casters
@@ -78,7 +97,9 @@ impl Views {
             target_type_id,
             type_name: std::any::type_name::<DbView>(),
             cast: unsafe {
-                std::mem::transmute::<DatabaseDownCaster<DbView>, ErasedDatabaseDownCaster>(func)
+                std::mem::transmute::<DatabaseDownCasterSig<DbView>, ErasedDatabaseDownCasterSig>(
+                    func,
+                )
             },
         });
     }
@@ -92,11 +113,11 @@ impl Views {
         let view_type_id = TypeId::of::<DbView>();
         for (_idx, view) in self.view_casters.iter() {
             if view.target_type_id == view_type_id {
-                return unsafe {
-                    std::mem::transmute::<ErasedDatabaseDownCaster, DatabaseDownCaster<DbView>>(
+                return DatabaseDownCaster(self.source_type_id, unsafe {
+                    std::mem::transmute::<ErasedDatabaseDownCasterSig, DatabaseDownCasterSig<DbView>>(
                         view.cast,
                     )
-                };
+                });
             }
         }
 
@@ -105,14 +126,6 @@ impl Views {
             std::any::type_name::<DbView>(),
         );
     }
-
-    pub fn assert_database(&self, db: &dyn Database) {
-        assert_eq!(
-            self.source_type_id,
-            db.type_id(),
-            "Database type does not match the expected type for this `Views` instance"
-        );
-    }
 }
 
 impl std::fmt::Debug for Views {