[WIP] Add downcast_trait and downcast_trait_mut

Cargo.lock

@@ -1890,9 +1890,9 @@ dependencies = [
 
 [[package]]
 name = "ipc-channel"
-version = "0.20.0"
+version = "0.20.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5b1c98b70019c830a1fc39cecfe1f60ff99c4122f0a189697c810c90ec545c14"
+checksum = "1700f6b8b9f00cdd675f32fbb3a5be882213140dfe045805273221ca266c43f8"
 dependencies = [
  "bincode",
  "crossbeam-channel",

compiler/rustc_const_eval/src/interpret/intrinsics.rs

@@ -4,14 +4,17 @@
 
 use std::assert_matches::assert_matches;
 
-use rustc_abi::{FieldIdx, HasDataLayout, Size};
+use rustc_abi::{FIRST_VARIANT, FieldIdx, HasDataLayout, Size};
 use rustc_apfloat::ieee::{Double, Half, Quad, Single};
+use rustc_hir::def_id::CRATE_DEF_ID;
+use rustc_infer::infer::TyCtxtInferExt;
 use rustc_middle::mir::interpret::{CTFE_ALLOC_SALT, read_target_uint, write_target_uint};
 use rustc_middle::mir::{self, BinOp, ConstValue, NonDivergingIntrinsic};
 use rustc_middle::ty::layout::TyAndLayout;
-use rustc_middle::ty::{Ty, TyCtxt};
-use rustc_middle::{bug, ty};
+use rustc_middle::ty::{Ty, TyCtxt, TypeFoldable};
+use rustc_middle::{bug, span_bug, ty};
 use rustc_span::{Symbol, sym};
+use rustc_trait_selection::traits::{Obligation, ObligationCause, ObligationCtxt};
 use tracing::trace;
 
 use super::memory::MemoryKind;
@@ -149,6 +152,49 @@ impl<'tcx, M: Machine<'tcx>> InterpCx<'tcx, M> {
                 let b_ty = self.read_type_id(&args[1])?;
                 self.write_scalar(Scalar::from_bool(a_ty == b_ty), dest)?;
             }
+            sym::vtable_for => {
+                let tp_ty = instance.args.type_at(0);
+                let result_ty = instance.args.type_at(1);
+
+                ensure_monomorphic_enough(tcx, tp_ty)?;
+                ensure_monomorphic_enough(tcx, result_ty)?;
+                let ty::Dynamic(preds, _, ty::Dyn) = result_ty.kind() else {
+                    span_bug!(
+                        self.find_closest_untracked_caller_location(),
+                        "Invalid type provided to vtable_for::<T, U>. U must be dyn Trait, got {result_ty}."
+                    );
+                };
+
+                let (infcx, param_env) =
+                    self.tcx.infer_ctxt().build_with_typing_env(self.typing_env);
+
+                let ocx = ObligationCtxt::new(&infcx);
+                ocx.register_obligations(preds.iter().map(|pred| {
+                    let pred = pred.with_self_ty(tcx, tp_ty);
+                    // Lifetimes can only be 'static because of the bound on T
+                    let pred = pred.fold_with(&mut ty::BottomUpFolder {
+                        tcx,
+                        ty_op: |ty| ty,
+                        lt_op: |lt| {
+                            if lt == tcx.lifetimes.re_erased { tcx.lifetimes.re_static } else { lt }
+                        },
+                        ct_op: |ct| ct,
+                    });
+                    Obligation::new(tcx, ObligationCause::dummy(), param_env, pred)
+                }));
+                let type_impls_trait = ocx.select_all_or_error().is_empty();
+                // Since `assumed_wf_tys=[]` the choice of LocalDefId is irrelevant, so using the "default"
+                let regions_are_valid = ocx.resolve_regions(CRATE_DEF_ID, param_env, []).is_empty();
+
+                if regions_are_valid && type_impls_trait {
+                    let vtable_ptr = self.get_vtable_ptr(tp_ty, preds)?;
+                    // Writing a non-null pointer into an `Option<NonNull>` will automatically make it `Some`.
+                    self.write_pointer(vtable_ptr, dest)?;
+                } else {
+                    // Write `None`
+                    self.write_discriminant(FIRST_VARIANT, dest)?;
+                }
+            }
             sym::variant_count => {
                 let tp_ty = instance.args.type_at(0);
                 let ty = match tp_ty.kind() {

compiler/rustc_hir_analysis/src/check/intrinsic.rs

@@ -94,6 +94,7 @@ fn intrinsic_operation_unsafety(tcx: TyCtxt<'_>, intrinsic_id: LocalDefId) -> hi
         | sym::discriminant_value
         | sym::type_id
         | sym::type_id_eq
+        | sym::vtable_for
         | sym::select_unpredictable
         | sym::cold_path
         | sym::ptr_guaranteed_cmp
@@ -553,6 +554,20 @@ pub(crate) fn check_intrinsic_type(
             (0, 0, vec![Ty::new_imm_ptr(tcx, tcx.types.unit)], tcx.types.usize)
         }
 
+        sym::vtable_for => {
+            let dyn_metadata = tcx.require_lang_item(LangItem::DynMetadata, span);
+            let dyn_metadata_adt_ref = tcx.adt_def(dyn_metadata);
+            let dyn_metadata_args = tcx.mk_args(&[param(1).into()]);
+            let dyn_ty = Ty::new_adt(tcx, dyn_metadata_adt_ref, dyn_metadata_args);
+
+            let option_did = tcx.require_lang_item(LangItem::Option, span);
+            let option_adt_ref = tcx.adt_def(option_did);
+            let option_args = tcx.mk_args(&[dyn_ty.into()]);
+            let ret_ty = Ty::new_adt(tcx, option_adt_ref, option_args);
+
+            (2, 0, vec![], ret_ty)
+        }
+
         // This type check is not particularly useful, but the `where` bounds
         // on the definition in `core` do the heavy lifting for checking it.
         sym::aggregate_raw_ptr => (3, 0, vec![param(1), param(2)], param(0)),

compiler/rustc_span/src/symbol.rs

@@ -2350,6 +2350,7 @@ symbols! {
         vreg_low16,
         vsx,
         vtable_align,
+        vtable_for,
         vtable_size,
         warn,
         wasip2,

compiler/rustc_type_ir/src/predicate.rs

@@ -275,6 +275,13 @@ pub enum ExistentialPredicate<I: Interner> {
 }
 
 impl<I: Interner> ty::Binder<I, ExistentialPredicate<I>> {
+    pub fn def_id(&self) -> I::DefId {
+        match self.skip_binder() {
+            ExistentialPredicate::Trait(tr) => tr.def_id,
+            ExistentialPredicate::Projection(p) => p.def_id,
+            ExistentialPredicate::AutoTrait(did) => did,
+        }
+    }
     /// Given an existential predicate like `?Self: PartialEq<u32>` (e.g., derived from `dyn PartialEq<u32>`),
     /// and a concrete type `self_ty`, returns a full predicate where the existentially quantified variable `?Self`
     /// has been replaced with `self_ty` (e.g., `self_ty: PartialEq<u32>`, in our example).

library/core/src/any.rs

@@ -86,7 +86,7 @@
 
 #![stable(feature = "rust1", since = "1.0.0")]
 
-use crate::{fmt, hash, intrinsics};
+use crate::{fmt, hash, intrinsics, ptr};
 
 ///////////////////////////////////////////////////////////////////////////////
 // Any trait
@@ -896,3 +896,45 @@ pub const fn type_name<T: ?Sized>() -> &'static str {
 pub const fn type_name_of_val<T: ?Sized>(_val: &T) -> &'static str {
     type_name::<T>()
 }
+
+#[allow(missing_docs)]
+#[must_use]
+#[unstable(feature = "downcast_trait", issue = "144361")]
+pub const fn downcast_trait<
+    T: Any + 'static,
+    U: ptr::Pointee<Metadata = ptr::DynMetadata<U>> + ?Sized + 'static,
+>(
+    t: &T,
+) -> Option<&U> {
+    let vtable: Option<ptr::DynMetadata<U>> = const { intrinsics::vtable_for::<T, U>() };
+    match vtable {
+        Some(dyn_metadata) => {
+            let pointer = ptr::from_raw_parts(t, dyn_metadata);
+            // SAFETY: `t` is a reference to a type, so we know it is valid.
+            // `dyn_metadata` is a vtable for T, implementing the trait of `U`.
+            Some(unsafe { &*pointer })
+        }
+        None => None,
+    }
+}
+
+#[allow(missing_docs)]
+#[must_use]
+#[unstable(feature = "downcast_trait", issue = "144361")]
+pub const fn downcast_trait_mut<
+    T: Any + 'static,
+    U: ptr::Pointee<Metadata = ptr::DynMetadata<U>> + ?Sized + 'static,
+>(
+    t: &mut T,
+) -> Option<&mut U> {
+    let vtable: Option<ptr::DynMetadata<U>> = const { intrinsics::vtable_for::<T, U>() };
+    match vtable {
+        Some(dyn_metadata) => {
+            let pointer = ptr::from_raw_parts_mut(t, dyn_metadata);
+            // SAFETY: `t` is a reference to a type, so we know it is valid.
+            // `dyn_metadata` is a vtable for T, implementing the trait of `U`.
+            Some(unsafe { &mut *pointer })
+        }
+        None => None,
+    }
+}

library/core/src/intrinsics/mod.rs

@@ -2657,6 +2657,18 @@ pub unsafe fn vtable_size(ptr: *const ()) -> usize;
 #[rustc_intrinsic]
 pub unsafe fn vtable_align(ptr: *const ()) -> usize;
 
+/// FIXME: write actual docs (ivarflakstad)
+/// The intrinsic will return the vtable of `t` through the lens of `U`.
+///
+/// # Safety
+///
+/// `ptr` must point to a vtable.
+#[rustc_nounwind]
+#[unstable(feature = "core_intrinsics", issue = "none")]
+#[rustc_intrinsic]
+pub const fn vtable_for<T, U: ptr::Pointee<Metadata = ptr::DynMetadata<U>> + ?Sized>()
+-> Option<ptr::DynMetadata<U>>;
+
 /// The size of a type in bytes.
 ///
 /// Note that, unlike most intrinsics, this is safe to call;

library/coretests/tests/intrinsics.rs

@@ -1,5 +1,8 @@
 use core::any::TypeId;
-use core::intrinsics::assume;
+use core::intrinsics::{assume, vtable_for};
+use std::fmt::Debug;
+use std::option::Option;
+use std::ptr::DynMetadata;
 
 #[test]
 fn test_typeid_sized_types() {
@@ -193,3 +196,17 @@ fn carrying_mul_add_fallback_i128() {
         (u128::MAX - 1, -(i128::MIN / 2)),
     );
 }
+
+#[test]
+fn test_vtable_for() {
+    #[derive(Debug)]
+    struct A {}
+
+    struct B {}
+
+    const A_VTABLE: Option<DynMetadata<dyn Debug>> = vtable_for::<A, dyn Debug>();
+    assert!(A_VTABLE.is_some());
+
+    const B_VTABLE: Option<DynMetadata<dyn Debug>> = vtable_for::<B, dyn Debug>();
+    assert!(B_VTABLE.is_none());
+}

tests/ui/any/downcast_trait.rs

@@ -0,0 +1,29 @@
+//@ run-pass
+#![feature(downcast_trait)]
+
+use std::fmt::Debug;
+
+// Look ma, no `T: Debug`
+fn downcast_debug_format<T: 'static>(t: &T) -> String {
+    match std::any::downcast_trait::<_, dyn Debug>(t) {
+        Some(d) => format!("{d:?}"),
+        None => "default".to_string()
+    }
+}
+
+// Test that downcasting to a dyn trait works as expected
+fn main() {
+    #[allow(dead_code)]
+    #[derive(Debug)]
+    struct A {
+        index: usize
+    }
+    let a = A { index: 42 };
+    let result = downcast_debug_format(&a);
+    assert_eq!("A { index: 42 }", result);
+
+    struct B {}
+    let b = B {};
+    let result = downcast_debug_format(&b);
+    assert_eq!("default", result);
+}

tests/ui/any/downcast_trait_err1.rs

@@ -0,0 +1,34 @@
+//@ run-pass
+#![feature(downcast_trait)]
+
+use std::{any::downcast_trait, sync::OnceLock};
+
+trait Trait {
+    fn call(&self, x: &Box<i32>);
+}
+
+impl Trait for for<'a> fn(&'a Box<i32>) {
+    fn call(&self, x: &Box<i32>) {
+        self(x);
+    }
+}
+
+static STORAGE: OnceLock<&'static Box<i32>> = OnceLock::new();
+
+fn store(x: &'static Box<i32>) {
+    STORAGE.set(x).unwrap();
+}
+
+fn main() {
+    let data = Box::new(Box::new(1i32));
+    let fn_ptr: fn(&'static Box<i32>) = store;
+    let dt = downcast_trait::<_, dyn Trait>(&fn_ptr);
+    if let Some(dt) = dt {
+        // unsound path
+        dt.call(&*data);
+        drop(data);
+        println!("{}", STORAGE.get().unwrap());
+    } else {
+        println!("success")
+    }
+}

tests/ui/any/downcast_trait_err2.rs

@@ -0,0 +1,32 @@
+//@ run-pass
+#![feature(downcast_trait)]
+use std::{any::downcast_trait, sync::OnceLock};
+
+trait Trait<T> {
+    fn call(&self, t: T, x: &Box<i32>);
+}
+
+impl Trait<for<'a> fn(&'a Box<i32>)> for () {
+    fn call(&self, f: for<'a> fn(&'a Box<i32>), x: &Box<i32>) {
+        f(x);
+    }
+}
+
+static STORAGE: OnceLock<&'static Box<i32>> = OnceLock::new();
+
+fn store(x: &'static Box<i32>) {
+    STORAGE.set(x).unwrap();
+}
+
+fn main() {
+    let data = Box::new(Box::new(1i32));
+    let dt = downcast_trait::<_, dyn Trait<fn(&'static Box<i32>)>>(&());
+    if let Some(dt) = dt {
+        // unsound path
+        dt.call(store, &*data);
+        drop(data);
+        println!("{}", STORAGE.get().unwrap());
+    } else {
+        println!("success")
+    }
+}

tests/ui/any/downcast_trait_mut.rs

@@ -0,0 +1,20 @@
+//@ run-pass
+#![feature(downcast_trait)]
+
+use std::fmt::{Error, Write};
+
+// Look ma, no `T: Write`
+fn downcast_mut_write<T: 'static>(t: &mut T, s: &str) -> Result<(), Error> {
+    match std::any::downcast_trait_mut::<_, dyn Write>(t) {
+        Some(w) => w.write_str(s),
+        None => Ok(())
+    }
+}
+
+// Test that downcasting to a mut dyn trait works as expected
+fn main() {
+    let mut buf = "Hello".to_string();
+
+    downcast_mut_write(&mut buf, " world!").unwrap();
+    assert_eq!(buf, "Hello world!");
+}