Add ub_checks for downcast_unchecked

Right now debug_assert! is used, which will not trigger in user code.

This is likely unacceptable for performance reasons,
since the optimizer can not understand virtual Any::type_id() calls.
This could potentially be fixed if we apply something like #[ffi_const]
to the Any::type_id() function (which would have wierder reaching benefits).

This cannot use the assert_unsafe_precondition! macro,
because that requires the assertion to work in a const context.

Author: Techcable

library/alloc/src/boxed/convert.rs

@@ -392,7 +392,9 @@ impl<A: Allocator> Box<dyn Any, A> {
     #[inline]
     #[unstable(feature = "downcast_unchecked", issue = "90850")]
     pub unsafe fn downcast_unchecked<T: Any>(self) -> Box<T, A> {
-        debug_assert!(self.is::<T>());
+        if core::ub_checks::check_library_ub() {
+            assert!(self.is::<T>());
+        }
         unsafe {
             let (raw, alloc): (*mut dyn Any, _) = Box::into_raw_with_allocator(self);
             Box::from_raw_in(raw as *mut T, alloc)
@@ -451,7 +453,9 @@ impl<A: Allocator> Box<dyn Any + Send, A> {
     #[inline]
     #[unstable(feature = "downcast_unchecked", issue = "90850")]
     pub unsafe fn downcast_unchecked<T: Any>(self) -> Box<T, A> {
-        debug_assert!(self.is::<T>());
+        if core::ub_checks::check_library_ub() {
+            assert!(self.is::<T>());
+        }
         unsafe {
             let (raw, alloc): (*mut (dyn Any + Send), _) = Box::into_raw_with_allocator(self);
             Box::from_raw_in(raw as *mut T, alloc)
@@ -510,7 +514,9 @@ impl<A: Allocator> Box<dyn Any + Send + Sync, A> {
     #[inline]
     #[unstable(feature = "downcast_unchecked", issue = "90850")]
     pub unsafe fn downcast_unchecked<T: Any>(self) -> Box<T, A> {
-        debug_assert!(self.is::<T>());
+        if core::ub_checks::check_library_ub() {
+            assert!(self.is::<T>());
+        }
         unsafe {
             let (raw, alloc): (*mut (dyn Any + Send + Sync), _) =
                 Box::into_raw_with_allocator(self);

library/alloc/src/rc.rs

@@ -2042,6 +2042,9 @@ impl<A: Allocator> Rc<dyn Any, A> {
     #[inline]
     #[unstable(feature = "downcast_unchecked", issue = "90850")]
     pub unsafe fn downcast_unchecked<T: Any>(self) -> Rc<T, A> {
+        if core::ub_checks::check_library_ub() {
+            assert!((*self).is::<T>());
+        }
         unsafe {
             let (ptr, alloc) = Rc::into_inner_with_allocator(self);
             Rc::from_inner_in(ptr.cast(), alloc)

library/alloc/src/sync.rs

@@ -2754,6 +2754,9 @@ impl<A: Allocator> Arc<dyn Any + Send + Sync, A> {
     where
         T: Any + Send + Sync,
     {
+        if core::ub_checks::check_library_ub() {
+            assert!((*self).is::<T>());
+        }
         unsafe {
             let (ptr, alloc) = Arc::into_inner_with_allocator(self);
             Arc::from_inner_in(ptr.cast(), alloc)

library/core/src/any.rs

@@ -292,7 +292,9 @@ impl dyn Any {
     #[unstable(feature = "downcast_unchecked", issue = "90850")]
     #[inline]
     pub unsafe fn downcast_ref_unchecked<T: Any>(&self) -> &T {
-        debug_assert!(self.is::<T>());
+        if core::ub_checks::check_library_ub() {
+            assert!(self.is::<T>());
+        }
         // SAFETY: caller guarantees that T is the correct type
         unsafe { &*(self as *const dyn Any as *const T) }
     }
@@ -322,7 +324,9 @@ impl dyn Any {
     #[unstable(feature = "downcast_unchecked", issue = "90850")]
     #[inline]
     pub unsafe fn downcast_mut_unchecked<T: Any>(&mut self) -> &mut T {
-        debug_assert!(self.is::<T>());
+        if core::ub_checks::check_library_ub() {
+            assert!(self.is::<T>());
+        }
         // SAFETY: caller guarantees that T is the correct type
         unsafe { &mut *(self as *mut dyn Any as *mut T) }
     }