Add example of reifyfnpointer with const drop

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");
-                                }
-                                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))
+                    mir::CastKind::Pointer(
+                        PointerCast::ReifyFnPointer | PointerCast::ReifyNotConstFnPointer,
+                    ) => 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");
                             }
-                            _ => bug!("{} cannot be reified to a fn ptr", operand.layout.ty),
+                            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),
+                    },
                     mir::CastKind::Pointer(PointerCast::ClosureFnPointer(_)) => {
                         match *operand.layout.ty.kind() {
                             ty::Closure(def_id, substs) => {

compiler/rustc_lint/src/builtin.rs

@@ -2807,8 +2807,8 @@ impl ClashingExternDeclarations {
                             let a_sig = a_poly_sig.skip_binder();
                             let b_sig = b_poly_sig.skip_binder();
 
-                            (a_sig.abi, a_sig.unsafety, a_sig.c_variadic)
-                                == (b_sig.abi, b_sig.unsafety, b_sig.c_variadic)
+                            (a_sig.abi, a_sig.unsafety, a_sig.c_variadic, a_sig.constness)
+                                == (b_sig.abi, b_sig.unsafety, b_sig.c_variadic, b_sig.constness)
                                 && a_sig.inputs().iter().eq_by(b_sig.inputs().iter(), |a, b| {
                                     structurally_same_type_impl(seen_types, cx, a, b, ckind)
                                 })

compiler/rustc_middle/src/ty/adjustment.rs

@@ -11,6 +11,9 @@ pub enum PointerCast {
     /// Go from a fn-item type to a fn-pointer type.
     ReifyFnPointer,
 
+    /// Go from a fn-item type to a not const fn-pointer type (drop const qualifier)
+    ReifyNotConstFnPointer,
+
     /// Go from a safe fn pointer to an unsafe fn pointer.
     UnsafeFnPointer,
 

compiler/rustc_middle/src/ty/context.rs

@@ -2110,6 +2110,10 @@ impl<'tcx> TyCtxt<'tcx> {
         })
     }
 
+    pub fn signature_not_const_fn(self, sig: PolyFnSig<'tcx>) -> PolyFnSig<'tcx> {
+        sig.map_bound(|s| ty::FnSig { constness: hir::Constness::NotConst, ..s })
+    }
+
     /// Same a `self.mk_region(kind)`, but avoids accessing the interners if
     /// `*r == kind`.
     #[inline]
@@ -2302,6 +2306,13 @@ impl<'tcx> TyCtxt<'tcx> {
         self.mk_ty(FnPtr(fty))
     }
 
+    #[inline]
+    pub fn mk_not_const_fn_ptr(self, fty: PolyFnSig<'tcx>) -> Ty<'tcx> {
+        let mut not_const = fty.skip_binder();
+        not_const.constness = hir::Constness::NotConst;
+        self.mk_ty(FnPtr(ty::Binder::dummy(not_const)))
+    }
+
     #[inline]
     pub fn mk_dynamic(
         self,

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

@@ -2072,6 +2072,35 @@ impl<'a, 'tcx> TypeChecker<'a, 'tcx> {
                         }
                     }
 
+                    CastKind::Pointer(PointerCast::ReifyNotConstFnPointer) => {
+                        let fn_sig = op.ty(body, tcx).fn_sig(tcx);
+
+                        // The type that we see in the fcx is like
+                        // `foo::<'a, 'b>`, where `foo` is the path to a
+                        // 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 ty_fn_ptr_from = tcx.mk_not_const_fn_ptr(fn_sig);
+
+                        if let Err(terr) = self.eq_types(
+                            ty_fn_ptr_from,
+                            ty,
+                            location.to_locations(),
+                            ConstraintCategory::Cast,
+                        ) {
+                            span_mirbug!(
+                                self,
+                                rvalue,
+                                "equating {:?} with {:?} yields {:?}",
+                                ty_fn_ptr_from,
+                                ty,
+                                terr
+                            );
+                        }
+                    }
+
                     CastKind::Pointer(PointerCast::ClosureFnPointer(unsafety)) => {
                         let sig = match op.ty(body, tcx).kind() {
                             ty::Closure(_, substs) => substs.as_closure().sig(),

compiler/rustc_mir/src/interpret/cast.rs

@@ -45,7 +45,7 @@ impl<'mir, 'tcx: 'mir, M: Machine<'mir, 'tcx>> InterpCx<'mir, 'tcx, M> {
                 self.write_immediate(*v, dest)?;
             }
 
-            Pointer(PointerCast::ReifyFnPointer) => {
+            Pointer(PointerCast::ReifyFnPointer | PointerCast::ReifyNotConstFnPointer) => {
                 // The src operand does not matter, just its type
                 match *src.layout.ty.kind() {
                     ty::FnDef(def_id, substs) => {

compiler/rustc_mir/src/transform/check_consts/validation.rs

@@ -748,8 +748,9 @@ impl Visitor<'tcx> for Validator<'mir, 'tcx> {
                     ty::FnPtr(fn_sig) => {
                         // At this point, we are calling a function by raw pointer because
                         // we know that it is const
-                        if self.ccx.tcx.features().const_fn_pointer &&
-                          fn_sig.constness() == hir::Constness::Const {
+                        if self.ccx.tcx.features().const_fn_pointer
+                            && fn_sig.constness() == hir::Constness::Const
+                        {
                             return;
                         }
                         self.check_op(ops::FnCallIndirect);

compiler/rustc_typeck/src/check/coercion.rs

@@ -952,6 +952,8 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
     {
         let prev_ty = self.resolve_vars_with_obligations(prev_ty);
         let new_ty = self.resolve_vars_with_obligations(new_ty);
+        let mut prev_drop_const = false;
+        let mut new_drop_const = false;
         debug!(
             "coercion::try_find_coercion_lub({:?}, {:?}, exprs={:?} exprs)",
             prev_ty,
@@ -982,7 +984,18 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
                             // We have a LUB of prev_ty and new_ty, just return it.
                             Ok(ok) => return Ok(self.register_infer_ok_obligations(ok)),
                             Err(_) => {
-                                (Some(prev_ty.fn_sig(self.tcx)), Some(new_ty.fn_sig(self.tcx)))
+                                let mut prev_sig = prev_ty.fn_sig(self.tcx);
+                                let mut new_sig = new_ty.fn_sig(self.tcx);
+                                if prev_sig.constness() != new_sig.constness() {
+                                    if prev_sig.constness() == hir::Constness::Const {
+                                        prev_sig = self.tcx.signature_not_const_fn(prev_sig);
+                                        prev_drop_const = true;
+                                    } else {
+                                        new_sig = self.tcx.signature_not_const_fn(prev_sig);
+                                        new_drop_const = true;
+                                    }
+                                }
+                                (Some(prev_sig), Some(new_sig))
                             }
                         }
                     }
@@ -1028,12 +1041,24 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
             let fn_ptr = self.tcx.mk_fn_ptr(sig);
             let prev_adjustment = match prev_ty.kind() {
                 ty::Closure(..) => Adjust::Pointer(PointerCast::ClosureFnPointer(a_sig.unsafety())),
-                ty::FnDef(..) => Adjust::Pointer(PointerCast::ReifyFnPointer),
+                ty::FnDef(..) => {
+                    if prev_drop_const {
+                        Adjust::Pointer(PointerCast::ReifyNotConstFnPointer)
+                    } else {
+                        Adjust::Pointer(PointerCast::ReifyFnPointer)
+                    }
+                }
                 _ => unreachable!(),
             };
             let next_adjustment = match new_ty.kind() {
                 ty::Closure(..) => Adjust::Pointer(PointerCast::ClosureFnPointer(b_sig.unsafety())),
-                ty::FnDef(..) => Adjust::Pointer(PointerCast::ReifyFnPointer),
+                ty::FnDef(..) => {
+                    if new_drop_const {
+                        Adjust::Pointer(PointerCast::ReifyNotConstFnPointer)
+                    } else {
+                        Adjust::Pointer(PointerCast::ReifyFnPointer)
+                    }
+                }
                 _ => unreachable!(),
             };
             for expr in exprs.iter().map(|e| e.as_coercion_site()) {

src/test/ui/consts/const_fn_pointer.rs

@@ -13,15 +13,15 @@ const fn bazz() { baz(FOO) }
 trait Bar { const F: const fn(Self) -> Self; }
 
 const fn map_i32(x: i32) -> i32 { x * 2 }
-impl Bar for i32 { const F: const fn(Self) -> Self = map_i32; } 
+impl Bar for i32 { const F: const fn(Self) -> Self = map_i32; }
 const fn map_u32(x: u32) -> u32 { x * 3 }
-impl Bar for u32 { const F: const fn(Self) -> Self = map_u32; } 
+impl Bar for u32 { const F: const fn(Self) -> Self = map_u32; }
 
 const fn map_smth<T: Bar>(v: T) -> T {
   <T as Bar>::F(v)
 }
 
-fn main() { 
+fn main() {
   const VAR: i32 = map_smth(2);
   assert_eq!(VAR, 4);
 }

src/test/ui/consts/const_fn_ptr_cast.rs

@@ -22,4 +22,4 @@ const _: const unsafe fn() = unsafe_fn;
 
 const _: unsafe fn() = const_unsafe_fn;
 
-fn main() { }
+fn main() { }