[WIP] check ptr-to-ptr casts via traits

Author: Lukas Markeffsky

compiler/rustc_hir_typeck/src/cast.rs

@@ -32,9 +32,10 @@ use super::FnCtxt;
 
 use crate::errors;
 use crate::type_error_struct;
-use hir::ExprKind;
+use hir::{ExprKind, LangItem};
 use rustc_errors::{Applicability, Diagnostic, DiagnosticBuilder, ErrorGuaranteed};
 use rustc_hir as hir;
+use rustc_infer::traits::Obligation;
 use rustc_macros::{TypeFoldable, TypeVisitable};
 use rustc_middle::mir::Mutability;
 use rustc_middle::ty::adjustment::AllowTwoPhase;
@@ -45,7 +46,8 @@ use rustc_session::lint;
 use rustc_span::def_id::{DefId, LOCAL_CRATE};
 use rustc_span::symbol::sym;
 use rustc_span::Span;
-use rustc_trait_selection::infer::InferCtxtExt;
+use rustc_trait_selection::infer::InferCtxtExt as _;
+use rustc_trait_selection::traits::query::evaluate_obligation::InferCtxtExt as _;
 
 /// Reifies a cast check to be checked once we have full type information for
 /// a function context.
@@ -724,8 +726,11 @@ impl<'a, 'tcx> CastCheck<'tcx> {
                 Err(CastError::IllegalCast)
             }
 
-            // ptr -> *
-            (Ptr(m_e), Ptr(m_c)) => self.check_ptr_ptr_cast(fcx, m_e, m_c), // ptr-ptr-cast
+            // ptr-ptr-cast
+            (Ptr(m_e), Ptr(m_c)) => {
+                self.check_ptr_ptr_cast(fcx, m_e, m_c)?;
+                Ok(CastKind::PtrPtrCast)
+            }
 
             // ptr-addr-cast
             (Ptr(m_expr), Int(t_c)) => {
@@ -770,10 +775,27 @@ impl<'a, 'tcx> CastCheck<'tcx> {
         fcx: &FnCtxt<'a, 'tcx>,
         m_expr: ty::TypeAndMut<'tcx>,
         m_cast: ty::TypeAndMut<'tcx>,
-    ) -> Result<CastKind, CastError> {
+    ) -> Result<(), CastError> {
         debug!("check_ptr_ptr_cast m_expr={:?} m_cast={:?}", m_expr, m_cast);
         // ptr-ptr cast. vtables must match.
 
+        let meta_did = fcx.tcx.require_lang_item(LangItem::Metadata, Some(self.span));
+        let expr_meta = Ty::new_projection(fcx.tcx, meta_did, [m_expr.ty]);
+        let cast_meta = Ty::new_projection(fcx.tcx, meta_did, [m_cast.ty]);
+        let expr_meta = fcx.normalize(self.span, expr_meta);
+        let cast_meta = fcx.normalize(self.span, cast_meta);
+
+        let pred = ty::TraitRef::from_lang_item(
+            fcx.tcx,
+            LangItem::MetadataCast,
+            self.span,
+            [expr_meta, cast_meta],
+        );
+        let obligation = Obligation::new(fcx.tcx, fcx.misc(self.span), fcx.param_env, pred);
+        if fcx.predicate_must_hold_modulo_regions(&obligation) {
+            return Ok(());
+        }
+
         let expr_kind = fcx.pointer_kind(m_expr.ty, self.span)?;
         let cast_kind = fcx.pointer_kind(m_cast.ty, self.span)?;
 
@@ -784,7 +806,8 @@ impl<'a, 'tcx> CastCheck<'tcx> {
 
         // Cast to thin pointer is OK
         if cast_kind == PointerKind::Thin {
-            return Ok(CastKind::PtrPtrCast);
+            fcx.tcx.dcx().span_err(self.span, format!("{pred}"));
+            return Ok(());
         }
 
         let Some(expr_kind) = expr_kind else {
@@ -799,7 +822,8 @@ impl<'a, 'tcx> CastCheck<'tcx> {
 
         // vtable kinds must match
         if fcx.tcx.erase_regions(cast_kind) == fcx.tcx.erase_regions(expr_kind) {
-            Ok(CastKind::PtrPtrCast)
+            fcx.tcx.dcx().span_err(self.span, format!("{pred}"));
+            Ok(())
         } else {
             Err(CastError::DifferingKinds)
         }