Modified apply_adjustments, add unsafety coercion

Author: filtsin

compiler/rustc_codegen_ssa/src/mir/rvalue.rs

@@ -184,25 +184,25 @@ impl<'a, 'tcx, Bx: BuilderMethods<'a, 'tcx>> FunctionCx<'a, 'tcx, Bx> {
                 let cast = bx.cx().layout_of(self.monomorphize(&mir_cast_ty));
 
                 let val = match *kind {
-                    mir::CastKind::Pointer(
-                        PointerCast::ReifyFnPointer,
-                    ) => match *operand.layout.ty.kind() {
-                        ty::FnDef(def_id, substs) => {
-                            if bx.cx().tcx().has_attr(def_id, sym::rustc_args_required_const) {
-                                bug!("reifying a fn ptr that requires const arguments");
+                    mir::CastKind::Pointer(PointerCast::ReifyFnPointer) => {
+                        match *operand.layout.ty.kind() {
+                            ty::FnDef(def_id, substs) => {
+                                if bx.cx().tcx().has_attr(def_id, sym::rustc_args_required_const) {
+                                    bug!("reifying a fn ptr that requires const arguments");
+                                }
+                                let instance = ty::Instance::resolve_for_fn_ptr(
+                                    bx.tcx(),
+                                    ty::ParamEnv::reveal_all(),
+                                    def_id,
+                                    substs,
+                                )
+                                .unwrap()
+                                .polymorphize(bx.cx().tcx());
+                                OperandValue::Immediate(bx.get_fn_addr(instance))
                             }
-                            let instance = ty::Instance::resolve_for_fn_ptr(
-                                bx.tcx(),
-                                ty::ParamEnv::reveal_all(),
-                                def_id,
-                                substs,
-                            )
-                            .unwrap()
-                            .polymorphize(bx.cx().tcx());
-                            OperandValue::Immediate(bx.get_fn_addr(instance))
+                            _ => bug!("{} cannot be reified to a fn ptr", operand.layout.ty),
                         }
-                        _ => bug!("{} cannot be reified to a fn ptr", operand.layout.ty),
-                    },
+                    }
                     mir::CastKind::Pointer(PointerCast::ClosureFnPointer(_)) => {
                         match *operand.layout.ty.kind() {
                             ty::Closure(def_id, substs) => {

compiler/rustc_middle/src/ty/sty.rs

@@ -2081,6 +2081,7 @@ impl<'tcx> TyS<'tcx> {
             FnPtr(f) => *f,
             Error(_) => {
                 // ignore errors (#54954)
+
                 ty::Binder::dummy(FnSig::fake())
             }
             Closure(..) => bug!(

compiler/rustc_mir/src/borrow_check/type_check/mod.rs

@@ -26,10 +26,7 @@ use rustc_middle::ty::adjustment::PointerCast;
 use rustc_middle::ty::cast::CastTy;
 use rustc_middle::ty::fold::TypeFoldable;
 use rustc_middle::ty::subst::{GenericArgKind, Subst, SubstsRef, UserSubsts};
-use rustc_middle::ty::{
-    self, CanonicalUserTypeAnnotation, CanonicalUserTypeAnnotations, RegionVid, ToPredicate, Ty,
-    TyCtxt, UserType, UserTypeAnnotationIndex, WithConstness,
-};
+use rustc_middle::ty::{self, CanonicalUserTypeAnnotation, CanonicalUserTypeAnnotations, RegionVid, ToPredicate, Ty, TyCtxt, UserType, UserTypeAnnotationIndex, WithConstness, Binder};
 use rustc_span::{Span, DUMMY_SP};
 use rustc_target::abi::VariantIdx;
 use rustc_trait_selection::infer::InferCtxtExt as _;
@@ -2051,7 +2048,14 @@ impl<'a, 'tcx> TypeChecker<'a, 'tcx> {
                         // function definition. When we extract the
                         // signature, it comes from the `fn_sig` query,
                         // and hence may contain unnormalized results.
-                        let fn_sig = self.normalize(fn_sig, location);
+                        let mut fn_sig = self.normalize(fn_sig, location);
+
+                        if let ty::FnPtr(pol_sig) = ty.kind() {
+                            let mut sig = fn_sig.skip_binder();
+                            sig.constness = pol_sig.constness();
+                            sig.unsafety = pol_sig.unsafety();
+                            fn_sig = Binder::bind(sig);
+                        }
 
                         let ty_fn_ptr_from = tcx.mk_fn_ptr(fn_sig);
 

compiler/rustc_typeck/src/check/coercion.rs

@@ -994,6 +994,10 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
                                         new_sig = self.tcx.signature_not_const_fn(prev_sig);
                                         new_drop_const = true;
                                     }
+                                    if prev_sig.unsafety() != new_sig.unsafety() {
+                                        prev_sig = prev_sig.map_bound(|sig| ty::FnSig { unsafety: hir::Unsafety::Unsafe, ..sig });
+                                        new_sig = new_sig.map_bound(|sig| ty::FnSig { unsafety: hir::Unsafety::Unsafe, ..sig });=
+                                    }
                                 }
                                 (Some(prev_sig), Some(new_sig))
                             }
@@ -1043,12 +1047,14 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
                 ty::Closure(..) => {
                     Some(Adjust::Pointer(PointerCast::ClosureFnPointer(a_sig.unsafety())))
                 }
-                ty::FnDef(..) => {
-                    Some(Adjust::Pointer(PointerCast::ReifyFnPointer))
-                }
+                ty::FnDef(..) => Some(Adjust::Pointer(PointerCast::ReifyFnPointer)),
                 ty::FnPtr(..) => {
                     if prev_drop_const {
-                        Some(Adjust::Pointer(PointerCast::NotConstFnPointer))
+                        if a_sig.unsafety() != b_sig.unsafety() {
+                            Some(Adjust::Pointer(PointerCast::UnsafeNotConstFnPointer))
+                        } else {
+                            Some(Adjust::Pointer(PointerCast::NotConstFnPointer))
+                        }
                     } else {
                         None
                     }
@@ -1059,12 +1065,14 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
                 ty::Closure(..) => {
                     Some(Adjust::Pointer(PointerCast::ClosureFnPointer(b_sig.unsafety())))
                 }
-                ty::FnDef(..) => {
-                    Some(Adjust::Pointer(PointerCast::ReifyFnPointer))
-                }
+                ty::FnDef(..) => Some(Adjust::Pointer(PointerCast::ReifyFnPointer)),
                 ty::FnPtr(..) => {
                     if new_drop_const {
-                        Some(Adjust::Pointer(PointerCast::NotConstFnPointer))
+                        if a_sig.unsafety() != b_sig.unsafety() {
+                            Some(Adjust::Pointer(PointerCast::UnsafeNotConstFnPointer))
+                        } else {
+                            Some(Adjust::Pointer(PointerCast::NotConstFnPointer))
+                        }
                     } else {
                         None
                     }
@@ -1075,7 +1083,10 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
                 for expr in exprs.iter().map(|e| e.as_coercion_site()) {
                     self.apply_adjustments(
                         expr,
-                        vec![Adjustment { kind: prev_adjustment.clone().unwrap().clone(), target: fn_ptr }],
+                        vec![Adjustment {
+                            kind: prev_adjustment.clone().unwrap().clone(),
+                            target: fn_ptr,
+                        }],
                     );
                 }
             }