assert call args are assignable

Author: compiler-errors

compiler/rustc_codegen_ssa/src/mir/block.rs

@@ -15,7 +15,7 @@ use rustc_hir::lang_items::LangItem;
 use rustc_middle::mir::{self, AssertKind, SwitchTargets, UnwindTerminateReason};
 use rustc_middle::ty::layout::{HasTyCtxt, LayoutOf, ValidityRequirement};
 use rustc_middle::ty::print::{with_no_trimmed_paths, with_no_visible_paths};
-use rustc_middle::ty::{self, Instance, Ty};
+use rustc_middle::ty::{self, Instance, Ty, TyCtxt};
 use rustc_session::config::OptLevel;
 use rustc_span::{source_map::Spanned, sym, Span, Symbol};
 use rustc_target::abi::call::{ArgAbi, FnAbi, PassMode, Reg};
@@ -986,6 +986,9 @@ impl<'a, 'tcx, Bx: BuilderMethods<'a, 'tcx>> FunctionCx<'a, 'tcx, Bx> {
                 }
             }
 
+            #[cfg(debug_assertions)]
+            assert_assignable(bx.tcx(), instance, op.layout.ty, fn_abi.args[i].layout.ty, 16);
+
             // The callee needs to own the argument memory if we pass it
             // by-ref, so make a local copy of non-immediate constants.
             match (&arg.node, op.val) {
@@ -1003,6 +1006,14 @@ impl<'a, 'tcx, Bx: BuilderMethods<'a, 'tcx>> FunctionCx<'a, 'tcx, Bx> {
             self.codegen_argument(bx, op, &mut llargs, &fn_abi.args[i]);
         }
         let num_untupled = untuple.map(|tup| {
+            #[cfg(debug_assertions)]
+            for (param, arg) in std::iter::zip(
+                &fn_abi.args[first_args.len()..],
+                self.monomorphize(tup.node.ty(self.mir, bx.tcx())).tuple_fields(),
+            ) {
+                assert_assignable(bx.tcx(), instance, arg, param.layout.ty, 16);
+            }
+
             self.codegen_arguments_untupled(
                 bx,
                 &tup.node,
@@ -1734,3 +1745,171 @@ enum ReturnDest<'tcx, V> {
     // Store a direct return value to an operand local place.
     DirectOperand(mir::Local),
 }
+
+#[track_caller]
+pub(crate) fn assert_assignable<'tcx>(
+    tcx: TyCtxt<'tcx>,
+    instance: Option<Instance<'tcx>>,
+    from_ty: Ty<'tcx>,
+    to_ty: Ty<'tcx>,
+    limit: usize,
+) {
+    use ty::TypeAndMut;
+    if limit == 0 {
+        // assert_assignable exists solely to catch bugs in cg_clif. it isn't necessary for
+        // soundness. don't attempt to check deep types to avoid exponential behavior in certain
+        // cases.
+        return;
+    }
+    match (from_ty.kind(), to_ty.kind()) {
+        (ty::Ref(_, a, _), ty::Ref(_, b, _))
+        | (
+            ty::RawPtr(TypeAndMut { ty: a, mutbl: _ }),
+            ty::RawPtr(TypeAndMut { ty: b, mutbl: _ }),
+        ) => {
+            assert_assignable(tcx, instance, *a, *b, limit - 1);
+        }
+        (ty::Ref(_, a, _), ty::RawPtr(TypeAndMut { ty: b, mutbl: _ }))
+        | (ty::RawPtr(TypeAndMut { ty: a, mutbl: _ }), ty::Ref(_, b, _)) => {
+            assert_assignable(tcx, instance, *a, *b, limit - 1);
+        }
+        (ty::FnPtr(_), ty::FnPtr(_)) => {
+            let from_sig = tcx.normalize_erasing_late_bound_regions(
+                ty::ParamEnv::reveal_all(),
+                from_ty.fn_sig(tcx),
+            );
+            let ty::FnSig {
+                inputs_and_output: types_from,
+                c_variadic: c_variadic_from,
+                unsafety: unsafety_from,
+                abi: abi_from,
+            } = from_sig;
+            let to_sig = tcx.normalize_erasing_late_bound_regions(
+                ty::ParamEnv::reveal_all(),
+                to_ty.fn_sig(tcx),
+            );
+            let ty::FnSig {
+                inputs_and_output: types_to,
+                c_variadic: c_variadic_to,
+                unsafety: unsafety_to,
+                abi: abi_to,
+            } = to_sig;
+            let mut types_from = types_from.iter();
+            let mut types_to = types_to.iter();
+            loop {
+                match (types_from.next(), types_to.next()) {
+                    (Some(a), Some(b)) => assert_assignable(tcx, instance, a, b, limit - 1),
+                    (None, None) => break,
+                    (Some(_), None) | (None, Some(_)) => panic!("{:#?}/{:#?}", from_ty, to_ty),
+                }
+            }
+            assert_eq!(
+                c_variadic_from, c_variadic_to,
+                "Can't write fn ptr with incompatible sig {:?} to place with sig {:?}\n",
+                from_sig, to_sig,
+            );
+            assert_eq!(
+                unsafety_from, unsafety_to,
+                "Can't write fn ptr with incompatible sig {:?} to place with sig {:?}\n",
+                from_sig, to_sig,
+            );
+            assert_eq!(
+                abi_from, abi_to,
+                "Can't write fn ptr with incompatible sig {:?} to place with sig {:?}\n",
+                from_sig, to_sig,
+            );
+            // fn(&T) -> for<'l> fn(&'l T) is allowed
+        }
+        (&ty::Dynamic(from_traits, _, _from_kind), &ty::Dynamic(to_traits, _, _to_kind)) => {
+            // FIXME(dyn-star): Do the right thing with DynKinds
+            for (from, to) in from_traits.iter().zip(to_traits) {
+                let from =
+                    tcx.normalize_erasing_late_bound_regions(ty::ParamEnv::reveal_all(), from);
+                let to = tcx.normalize_erasing_late_bound_regions(ty::ParamEnv::reveal_all(), to);
+                assert_eq!(
+                    from, to,
+                    "Can't write trait object of incompatible traits {:?} to place with traits {:?}\n",
+                    from_traits, to_traits
+                );
+            }
+            // dyn for<'r> Trait<'r> -> dyn Trait<'_> is allowed
+        }
+        (&ty::Tuple(types_a), &ty::Tuple(types_b)) => {
+            let mut types_a = types_a.iter();
+            let mut types_b = types_b.iter();
+            loop {
+                match (types_a.next(), types_b.next()) {
+                    (Some(a), Some(b)) => assert_assignable(tcx, instance, a, b, limit - 1),
+                    (None, None) => return,
+                    (Some(_), None) | (None, Some(_)) => panic!("{:#?}/{:#?}", from_ty, to_ty),
+                }
+            }
+        }
+        (&ty::Adt(adt_def_a, args_a), &ty::Adt(adt_def_b, args_b))
+            if adt_def_a.did() == adt_def_b.did() =>
+        {
+            let mut types_a = args_a.types();
+            let mut types_b = args_b.types();
+            loop {
+                match (types_a.next(), types_b.next()) {
+                    (Some(a), Some(b)) => assert_assignable(tcx, instance, a, b, limit - 1),
+                    (None, None) => return,
+                    (Some(_), None) | (None, Some(_)) => panic!("{:#?}/{:#?}", from_ty, to_ty),
+                }
+            }
+        }
+        (ty::Array(a, _), ty::Array(b, _)) => assert_assignable(tcx, instance, *a, *b, limit - 1),
+        (&ty::Closure(def_id_a, args_a), &ty::Closure(def_id_b, args_b))
+            if def_id_a == def_id_b =>
+        {
+            let mut types_a = args_a.types();
+            let mut types_b = args_b.types();
+            loop {
+                match (types_a.next(), types_b.next()) {
+                    (Some(a), Some(b)) => assert_assignable(tcx, instance, a, b, limit - 1),
+                    (None, None) => return,
+                    (Some(_), None) | (None, Some(_)) => panic!("{:#?}/{:#?}", from_ty, to_ty),
+                }
+            }
+        }
+        (&ty::Coroutine(def_id_a, args_a), &ty::Coroutine(def_id_b, args_b))
+            if def_id_a == def_id_b =>
+        {
+            let mut types_a = args_a.types();
+            let mut types_b = args_b.types();
+            loop {
+                match (types_a.next(), types_b.next()) {
+                    (Some(a), Some(b)) => assert_assignable(tcx, instance, a, b, limit - 1),
+                    (None, None) => return,
+                    (Some(_), None) | (None, Some(_)) => panic!("{:#?}/{:#?}", from_ty, to_ty),
+                }
+            }
+        }
+        (&ty::CoroutineWitness(def_id_a, args_a), &ty::CoroutineWitness(def_id_b, args_b))
+            if def_id_a == def_id_b =>
+        {
+            let mut types_a = args_a.types();
+            let mut types_b = args_b.types();
+            loop {
+                match (types_a.next(), types_b.next()) {
+                    (Some(a), Some(b)) => assert_assignable(tcx, instance, a, b, limit - 1),
+                    (None, None) => return,
+                    (Some(_), None) | (None, Some(_)) => panic!("{:#?}/{:#?}", from_ty, to_ty),
+                }
+            }
+        }
+        (ty::Param(_), _) | (_, ty::Param(_)) if tcx.sess.opts.unstable_opts.polymorphize => {
+            // No way to check if it is correct or not with polymorphization enabled
+        }
+        _ => {
+            assert_eq!(
+                from_ty,
+                to_ty,
+                "Can't write value with incompatible type {:?} to place with type {:?} in {:?}\n",
+                from_ty.kind(),
+                to_ty.kind(),
+                instance,
+            );
+        }
+    }
+}