try adding dbg! calls into rustc

Author: Ryan1729

src/librustc_typeck/check/cast.rs

@@ -597,6 +597,8 @@ impl<'a, 'tcx> CastCheck<'tcx> {
         use rustc_middle::ty::cast::CastTy::*;
         use rustc_middle::ty::cast::IntTy::*;
 
+        //dbg!("calling do_check", &self.expr_ty, self.cast_ty, (CastTy::from_ty(self.expr_ty), CastTy::from_ty(self.cast_ty)));
+
         let (t_from, t_cast) = match (CastTy::from_ty(self.expr_ty), CastTy::from_ty(self.cast_ty))
         {
             (Some(t_from), Some(t_cast)) => (t_from, t_cast),
@@ -640,6 +642,7 @@ impl<'a, 'tcx> CastCheck<'tcx> {
                             },
                             // array-ptr-cast
                             Ptr(mt) => {
+                                dbg!("calling check_ref_cast");
                                 self.check_ref_cast(fcx, TypeAndMut { mutbl, ty: inner_ty }, mt)
                             }
                             _ => Err(CastError::NonScalar),
@@ -787,6 +790,9 @@ impl<'a, 'tcx> CastCheck<'tcx> {
                     )
                     });
 
+                // TODO: Remove this!
+                dbg!("enter demand_eqtype", &self.span, &ety, &m_cast.ty);
+
                 // this will report a type mismatch if needed
                 fcx.demand_eqtype(self.span, ety, m_cast.ty);
                 return Ok(CastKind::ArrayPtrCast);

src/librustc_typeck/check/demand.rs

@@ -71,6 +71,9 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
 
     pub fn demand_eqtype(&self, sp: Span, expected: Ty<'tcx>, actual: Ty<'tcx>) {
         if let Some(mut err) = self.demand_eqtype_diag(sp, expected, actual) {
+            // TODO: Remove this!
+            dbg!((&sp, &expected, &actual));
+
             err.emit();
         }
     }

src/tools/clippy/clippy_lints/src/transmute.rs

@@ -333,6 +333,23 @@ impl<'tcx> LateLintPass<'tcx> for Transmute {
                 let to_ty = cx.typeck_results().expr_ty(e);
 
                 match (&from_ty.kind, &to_ty.kind) {
+                    // put this back at the bottom later
+(_, _) if can_be_expressed_as_pointer_cast(cx, e, from_ty, to_ty) => span_lint_and_then(
+                        cx,
+                        TRANSMUTES_EXPRESSIBLE_AS_PTR_CASTS,
+                        e.span,
+                        &format!(
+                            "transmute from `{}` to `{}` which could be expressed as a pointer cast instead",
+                            from_ty,
+                            to_ty
+                        ),
+                        |diag| {
+                            if let Some(arg) = sugg::Sugg::hir_opt(cx, &args[0]) {
+                                let sugg = arg.as_ty(&to_ty.to_string()).to_string();
+                                diag.span_suggestion(e.span, "try", sugg, Applicability::Unspecified);
+                            }
+                        }
+                    ),
                     _ if from_ty == to_ty => span_lint(
                         cx,
                         USELESS_TRANSMUTE,
@@ -628,22 +645,6 @@ impl<'tcx> LateLintPass<'tcx> for Transmute {
                             );
                         }
                     },
-                    (_, _) if can_be_expressed_as_pointer_cast(cx, e, from_ty, to_ty) => span_lint_and_then(
-                        cx,
-                        TRANSMUTES_EXPRESSIBLE_AS_PTR_CASTS,
-                        e.span,
-                        &format!(
-                            "transmute from `{}` to `{}` which could be expressed as a pointer cast instead",
-                            from_ty,
-                            to_ty
-                        ),
-                        |diag| {
-                            if let Some(arg) = sugg::Sugg::hir_opt(cx, &args[0]) {
-                                let sugg = arg.as_ty(&to_ty.to_string()).to_string();
-                                diag.span_suggestion(e.span, "try", sugg, Applicability::Unspecified);
-                            }
-                        }
-                    ),
                     _ => {
                         return;
                     },

src/tools/clippy/tests/ui/transmutes_expressible_as_ptr_casts.rs

@@ -8,11 +8,11 @@ use std::mem::transmute;
 
 // rustc_typeck::check::cast contains documentation about when a cast `e as U` is 
 // valid, which we quote from below.
-
-fn main() {
+fn valid_cast_cases() {
     // We should see an error message for each transmute, and no error messages for
     // the casts, since the casts are the recommended fixes.
 
+
     // e is an integer and U is *U_0, while U_0: Sized; addr-ptr-cast
     let ptr_i32_transmute = unsafe {
         transmute::<isize, *const i32>(-1)
@@ -63,3 +63,17 @@ fn main() {
     };
     let usize_from_fn_ptr = foo as *const usize;
 }
+
+type DCErrIn<'a> = &'a [i32; 1];
+type DCErrOut = *const u8;
+fn trigger_do_check_to_emit_error(in_param: DCErrIn<'_>) -> DCErrOut {
+    unsafe { transmute::<DCErrIn, DCErrOut>(in_param) }
+}
+
+type OtherErrIn<'a> = &'a i32;
+type OtherErrOut = *const u8;
+fn other(in_param: OtherErrIn<'_>) -> OtherErrOut {
+    unsafe { transmute::<OtherErrIn, OtherErrOut>(in_param) }
+}
+
+fn main() {}