Match coercion

Author: filtsin

compiler/rustc_codegen_ssa/src/mir/rvalue.rs

@@ -185,7 +185,7 @@ impl<'a, 'tcx, Bx: BuilderMethods<'a, 'tcx>> FunctionCx<'a, 'tcx, Bx> {
 
                 let val = match *kind {
                     mir::CastKind::Pointer(
-                        PointerCast::ReifyFnPointer | PointerCast::ReifyNotConstFnPointer,
+                        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) {

compiler/rustc_middle/src/ty/adjustment.rs

@@ -11,9 +11,6 @@ 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_mir/src/borrow_check/type_check/mod.rs

@@ -2072,35 +2072,6 @@ 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 | PointerCast::ReifyNotConstFnPointer) => {
+            Pointer(PointerCast::ReifyFnPointer) => {
                 // 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

@@ -557,7 +557,6 @@ impl Visitor<'tcx> for Validator<'mir, 'tcx> {
                 CastKind::Pointer(
                     PointerCast::UnsafeFnPointer
                     | PointerCast::ClosureFnPointer(_)
-                    | PointerCast::ReifyNotConstFnPointer
                     | PointerCast::NotConstFnPointer
                     | PointerCast::UnsafeNotConstFnPointer
                     | PointerCast::ReifyFnPointer,

compiler/rustc_typeck/src/check/coercion.rs

@@ -975,7 +975,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
                 (None, None)
             } else {
                 match (&prev_ty.kind(), &new_ty.kind()) {
-                    (&ty::FnDef(..), &ty::FnDef(..)) => {
+                    (&ty::FnDef(..) | &ty::FnPtr(..), &ty::FnDef(..) | &ty::FnPtr(..)) => {
                         // Don't reify if the function types have a LUB, i.e., they
                         // are the same function and their parameters have a LUB.
                         match self
@@ -1040,34 +1040,51 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
             // Reify both sides and return the reified fn pointer type.
             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::Closure(..) => {
+                    Some(Adjust::Pointer(PointerCast::ClosureFnPointer(a_sig.unsafety())))
+                }
                 ty::FnDef(..) => {
+                    Some(Adjust::Pointer(PointerCast::ReifyFnPointer))
+                }
+                ty::FnPtr(..) => {
                     if prev_drop_const {
-                        Adjust::Pointer(PointerCast::ReifyNotConstFnPointer)
+                        Some(Adjust::Pointer(PointerCast::NotConstFnPointer))
                     } else {
-                        Adjust::Pointer(PointerCast::ReifyFnPointer)
+                        None
                     }
                 }
                 _ => unreachable!(),
             };
             let next_adjustment = match new_ty.kind() {
-                ty::Closure(..) => Adjust::Pointer(PointerCast::ClosureFnPointer(b_sig.unsafety())),
+                ty::Closure(..) => {
+                    Some(Adjust::Pointer(PointerCast::ClosureFnPointer(b_sig.unsafety())))
+                }
                 ty::FnDef(..) => {
+                    Some(Adjust::Pointer(PointerCast::ReifyFnPointer))
+                }
+                ty::FnPtr(..) => {
                     if new_drop_const {
-                        Adjust::Pointer(PointerCast::ReifyNotConstFnPointer)
+                        Some(Adjust::Pointer(PointerCast::NotConstFnPointer))
                     } else {
-                        Adjust::Pointer(PointerCast::ReifyFnPointer)
+                        None
                     }
                 }
                 _ => unreachable!(),
             };
-            for expr in exprs.iter().map(|e| e.as_coercion_site()) {
+            if prev_adjustment.is_some() {
+                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 }],
+                    );
+                }
+            }
+            if next_adjustment.is_some() {
                 self.apply_adjustments(
-                    expr,
-                    vec![Adjustment { kind: prev_adjustment.clone(), target: fn_ptr }],
+                    new,
+                    vec![Adjustment { kind: next_adjustment.unwrap(), target: fn_ptr }],
                 );
             }
-            self.apply_adjustments(new, vec![Adjustment { kind: next_adjustment, target: fn_ptr }]);
             return Ok(fn_ptr);
         }
 

src/tools/clippy/clippy_lints/src/utils/qualify_min_const_fn.rs

@@ -152,7 +152,6 @@ fn check_rvalue(tcx: TyCtxt<'tcx>, body: &Body<'tcx>, def_id: DefId, rvalue: &Rv
                 PointerCast::UnsafeFnPointer
                 | PointerCast::ClosureFnPointer(_)
                 | PointerCast::ReifyFnPointer
-                | PointerCast::ReifyNotConstFnPointer
                 | PointerCast::NotConstFnPointer
                 | PointerCast::UnsafeNotConstFnPointer,
             ),