Unexpected panic when downcasting Any

Take the following example:

use std::any::Any;

trait AsAny {
    fn as_any(&self) -> &dyn Any;
}
impl<T: Any> AsAny for T {
    fn as_any(&self) -> &dyn Any {
        self
    }
}

fn main() {
    let a: Box<u8> = Box::new(0u8);
    let _b = a.as_any().downcast_ref::<Box<u8>>().expect("1");

    let a: Box<u8> = Box::new(0u8);
    let a: Box<dyn Any> = a;
    let _b = a.as_any().downcast_ref::<Box<u8>>().expect("2");
}

The above panics on the expect("2"). I still can't quite pin my finger on why the type is getting erased. Yes, a gets upcasted to a Box<dyn Any>, but how come it no longer holds the type information so that it can get downcasted later?

Are there any (safe) workarounds for this? I already have a working workaround with Box::into_raw, Box::from_raw, and a pointer cast, but I'd prefer to avoid unsafe.

Edit: To avoid the XY problem, my real question is that I have a Box<dyn SomeOtherTrait> that I need to cast into a SomeConcreteType. I know about the downcast* methods on Box, but unfortunately they aren't much help in my situation.

let a: Box<u8> = Box::new(0u8);
let a: Box<dyn Any> = a;
let _b = a.as_any().downcast_ref::<Box<u8>>().expect("2");

In order to understand why this compiles, but does not execute as you expect, you need to understand the method resolution algorithm, and the fact that AsAny is a trait you have blanket implemented for any Sized type.

a.as_any() has to be resolved to some specific function call. The search proceeds as follows:

• Is there any method named as_any which has a receiver type of Box<dyn Any>? No.
• …a receiver type of &Box<dyn Any>? Yes!

See, Box<dyn Any> is a Sized type, so it implements AsAny, and the first thing the compiler tries is referencing it, not dereferencing it. Thus, the fact that the Box contains dyn Any never gets involved.

If we're careful we can demonstrate this:

let a: Box<u8> = Box::new(0u8);
let a: Box<dyn Any> = a;
assert_eq!(TypeId::of::<Box<dyn Any>>(), <dyn Any>::type_id(a.as_any()));

> ...my real question is that I have a Box<dyn SomeOtherTrait>...

If you want to be able to downcast from a trait object, that trait must provide downcasting support. Otherwise the run-time information just does not exist; the only information a trait object has at run time is the data pointer and the vtable pointer, and the vtable does not contain a TypeId. The simplest version of the trick is to incorporate as_any into the trait:

use std::any::{TypeId, Any};

trait SomeOtherTrait {
    fn as_any(&self) -> &dyn Any;
    
    // and also your other important methods
}
impl SomeOtherTrait for u8 {
    fn as_any(&self) -> &dyn Any {
        self
    }
}

fn main() {
    let a: Box<u8> = Box::new(0u8);
    let a: Box<dyn SomeOtherTrait> = a;
    assert_eq!(TypeId::of::<u8>(), <dyn Any>::type_id(a.as_any()));
    let _b = a.as_any().downcast_ref::<u8>().expect("2");
}

These assertions pass.

Note that if you do things this way, is critical that SomeOtherTrait has an actual as_any() method that each implementor implements; that is what makes SomeOtherTrait vtables contain the information that is necessary.

In future versions of Rust, this may be made simpler by trait upcasting, which might allow you to simply declare trait SomeOtherTrait: Any and then coerce Box<dyn SomeOtherTrait> to Box<dyn Any> and &dyn SomeOtherTrait to &dyn SomeOtherTrait.

For now, the easiest way to get this done is to use a library that uses even more elaborate tricks to provide convenient downcasting attached to your trait, like downcast-rs. (Unfortunately, I don't quite understand how it works so I don't have an explanation to include here.) This allows you to not require all your trait implementors to include fn as_any(&self) -> &dyn Any { self }.

(If SomeOtherTrait is not a trait you control, then there is nothing you can do.)

Thanks to Kevin Reid's answer, I was able to use trait upcasting (at least on nightly) to do this (in my original question, I was attempting to cast the DynClone to a concrete type):

trait ClonableAny: Any + DynClone {}          // define custom trait that you own with Any
dyn_clone::clone_trait_object!(ClonableAny);  // something needed for just my particular use case with DynClone
impl<T: Clone + 'static> ClonableAny for T {} // blanket impl for all applicable types

let data: Box<dyn Any> = data.clone(); // trait upcast (the clone() is for my use case)
let casted_type = *data
    .downcast::<C::T>()
    .expect("Types should be properly enforced due to generics");

The key is to make a trait that you own that inherits from Any. Then you can use a blanket implementation that implements it for all types that have and the other trait.