Change implementation to use safe upcasting polyfill

Author: the10thWiz

core/lib/src/fairing/mod.rs

@@ -64,6 +64,22 @@ pub use self::info_kind::{Info, Kind};
 /// A type alias for the return `Result` type of [`Fairing::on_ignite()`].
 pub type Result<T = Rocket<Build>, E = Rocket<Build>> = std::result::Result<T, E>;
 
+pub trait AsAny: Any {
+    fn as_any(&self) -> &dyn Any;
+    fn as_any_mut(&mut self) -> &mut dyn Any;
+}
+
+impl<T: Any> AsAny for T {
+    fn as_any(&self) -> &dyn Any {
+        self
+    }
+
+    fn as_any_mut(&mut self) -> &mut dyn Any {
+        self
+    }
+}
+
+
 // We might imagine that a request fairing returns an `Outcome`. If it returns
 // `Success`, we don't do any routing and use that response directly. Same if it
 // returns `Error`. We only route if it returns `Forward`. I've chosen not to
@@ -425,7 +441,7 @@ pub type Result<T = Rocket<Build>, E = Rocket<Build>> = std::result::Result<T, E
 ///
 /// [request-local state]: https://rocket.rs/master/guide/state/#request-local-state
 #[crate::async_trait]
-pub trait Fairing: Send + Sync + Any + 'static {
+pub trait Fairing: Send + Sync + AsAny + 'static {
     /// Returns an [`Info`] structure containing the `name` and [`Kind`] of this
     /// fairing. The `name` can be any arbitrary string. `Kind` must be an `or`d
     /// set of `Kind` variants.

core/lib/src/rocket.rs

@@ -514,7 +514,7 @@ impl Rocket<Build> {
     /// If multiple instances of the same type of Fairing have been attached, the modify function
     /// will be run on each instance.
     #[must_use]
-    pub fn modify_fairings<F: Fairing, E: fmt::Debug>(mut self, modifier: impl Fn(&mut F) -> Result<(), E>) -> Result<Self, Self> {
+    pub fn modify_fairings<F: Fairing, E: fmt::Debug>(mut self, mut modifier: impl FnMut(&mut F) -> Result<(), E>) -> Result<Self, Self> {
         #[derive(Debug, PartialEq, Eq)]
         enum State {
             None,
@@ -523,16 +523,11 @@ impl Rocket<Build> {
         }
         let mut state = State::None;
         for f in self.fairings.iter_mut() {
-            let f = f.as_mut();
-            if f.type_id() == TypeId::of::<F>() {
-                // SAFTEY: `f` is a valid pointer since it was obtained from a Box, and it points
-                // at an `F` since it has the same TypeId. Converting from dyn type to a concrete
-                // type is handled automatically by the compilier
-                let f = unsafe { &mut *((f as *mut dyn Fairing) as *mut F) };
+            if let Some(f) = f.as_any_mut().downcast_mut() {
                 match modifier(f) {
                     Ok(()) => if state == State::None { state = State::Success },
-                    Err(e) => {
-                        error_!("Failed to modify fairing: {:?}", e);
+                    Err(error) => {
+                        error!(?error, "Failed to modify fairing");
                         state = State::Failure;
                     }
                 }