Auto merge of #147565 - BoxyUwU:coercion_cleanup, r=<try>

coercions reviews/misc whatevers

Author: rust-bors[bot]

compiler/rustc_borrowck/src/type_check/mod.rs

@@ -1062,7 +1062,10 @@ impl<'a, 'tcx> Visitor<'tcx> for TypeChecker<'a, 'tcx> {
 
             Rvalue::Cast(cast_kind, op, ty) => {
                 match *cast_kind {
-                    CastKind::PointerCoercion(PointerCoercion::ReifyFnPointer, coercion_source) => {
+                    CastKind::PointerCoercion(
+                        PointerCoercion::ReifyFnPointer,
+                        coercion_source,
+                    ) => {
                         let is_implicit_coercion = coercion_source == CoercionSource::Implicit;
                         let src_ty = op.ty(self.body, tcx);
                         let mut src_sig = src_ty.fn_sig(tcx);

compiler/rustc_hir_typeck/src/coercion.rs

@@ -9,7 +9,8 @@ use crate::ty::{Ty, TyCtxt};
 
 #[derive(Clone, Copy, Debug, PartialEq, Eq, TyEncodable, TyDecodable, Hash, HashStable)]
 pub enum PointerCoercion {
-    /// Go from a fn-item type to a fn-pointer type.
+    /// Go from a fn-item type to a fn pointer or an unsafe fn pointer.
+    /// It cannot convert an unsafe fn-item to a safe fn pointer.
     ReifyFnPointer,
 
     /// Go from a safe fn pointer to an unsafe fn pointer.

compiler/rustc_middle/src/ty/adjustment.rs

@@ -2834,14 +2834,29 @@ slice_interners!(
 );
 
 impl<'tcx> TyCtxt<'tcx> {
-    /// Given a `fn` type, returns an equivalent `unsafe fn` type;
+    /// Given a `fn` sig, returns an equivalent `unsafe fn` type;
     /// that is, a `fn` type that is equivalent in every way for being
     /// unsafe.
     pub fn safe_to_unsafe_fn_ty(self, sig: PolyFnSig<'tcx>) -> Ty<'tcx> {
         assert!(sig.safety().is_safe());
         Ty::new_fn_ptr(self, sig.map_bound(|sig| ty::FnSig { safety: hir::Safety::Unsafe, ..sig }))
     }
 
+    /// Given a `fn` sig, returns an equivalent `unsafe fn` sig;
+    /// that is, a `fn` sig that is equivalent in every way for being
+    /// unsafe.
+    pub fn safe_to_unsafe_sig(self, sig: PolyFnSig<'tcx>) -> PolyFnSig<'tcx> {
+        assert!(sig.safety().is_safe());
+        sig.map_bound(|sig| ty::FnSig { safety: hir::Safety::Unsafe, ..sig })
+    }
+
+    /// Given a `unsafe fn` sig, returns an equivalent `fn` sig;
+    /// that is, a `fn` sig that is equivalent in every way for being
+    /// safe.
+    pub fn unsafe_to_safe_sig(self, sig: PolyFnSig<'tcx>) -> PolyFnSig<'tcx> {
+        sig.map_bound(|sig| ty::FnSig{ safety: hir::Safety::Safe, ..sig  })
+    }
+
     /// Given the def_id of a Trait `trait_def_id` and the name of an associated item `assoc_name`
     /// returns true if the `trait_def_id` defines an associated item of name `assoc_name`.
     pub fn trait_may_define_assoc_item(self, trait_def_id: DefId, assoc_name: Ident) -> bool {

compiler/rustc_middle/src/ty/context.rs

@@ -0,0 +1,36 @@
+// We have two function parameters with types:
+// - `&?0`
+// - `Box<for<'a> fn(<?0 as Trait<'a>>::Item)>`
+//
+// As the alias in the second parameter has a `?0` it is an ambig
+// alias, and as it references bound vars it can't be normalized to
+// an infer var.
+//
+// When checking function arguments we try to coerce both:
+// - `&()` to `&?0`
+// - `FnDef(f)` to `Box<for<'a> fn(<?0 as Trait<'a>>::Item)>`
+//
+// The first coercion infers `?0=()`. Previously when handling
+// the second coercion we wound *re-normalize* the alias, which
+// now that `?0` has been inferred allowed us to determine this
+// alias is not wellformed and normalize it to some infer var `?1`.
+//
+// We would then see that `FnDef(f)` can't be coerced to `Box<fn(?1)>`
+// and return a `TypeError` referencing this new variable `?1`. This
+// then caused ICEs as diagnostics would encounter inferences variables
+// from the result of normalization inside of the probe used be coercion.
+
+
+trait LendingIterator {
+    type Item<'q>;
+    fn for_each(&self, _f: Box<fn(Self::Item<'_>)>) {}
+}
+
+fn f(_: ()) {}
+
+fn main() {
+    LendingIterator::for_each(&(), f);
+    //~^ ERROR: the trait bound `(): LendingIterator` is not satisfied
+    //~| ERROR: the trait bound `(): LendingIterator` is not satisfied
+    //~| ERROR: mismatched types
+}

tests/crashes/132765.rs

@@ -0,0 +1,46 @@
+error[E0277]: the trait bound `(): LendingIterator` is not satisfied
+  --> $DIR/hr_alias_normalization_leaking_vars.rs:32:31
+   |
+LL |     LendingIterator::for_each(&(), f);
+   |     ------------------------- ^^^ the trait `LendingIterator` is not implemented for `()`
+   |     |
+   |     required by a bound introduced by this call
+   |
+help: this trait has no implementations, consider adding one
+  --> $DIR/hr_alias_normalization_leaking_vars.rs:24:1
+   |
+LL | trait LendingIterator {
+   | ^^^^^^^^^^^^^^^^^^^^^
+
+error[E0308]: mismatched types
+  --> $DIR/hr_alias_normalization_leaking_vars.rs:32:36
+   |
+LL |     LendingIterator::for_each(&(), f);
+   |     -------------------------      ^ expected `Box<fn(...)>`, found fn item
+   |     |
+   |     arguments to this function are incorrect
+   |
+   = note: expected struct `Box<for<'a> fn(<() as LendingIterator>::Item<'a>)>`
+             found fn item `fn(()) {f}`
+note: method defined here
+  --> $DIR/hr_alias_normalization_leaking_vars.rs:26:8
+   |
+LL |     fn for_each(&self, _f: Box<fn(Self::Item<'_>)>) {}
+   |        ^^^^^^^^        ---------------------------
+
+error[E0277]: the trait bound `(): LendingIterator` is not satisfied
+  --> $DIR/hr_alias_normalization_leaking_vars.rs:32:36
+   |
+LL |     LendingIterator::for_each(&(), f);
+   |                                    ^ the trait `LendingIterator` is not implemented for `()`
+   |
+help: this trait has no implementations, consider adding one
+  --> $DIR/hr_alias_normalization_leaking_vars.rs:24:1
+   |
+LL | trait LendingIterator {
+   | ^^^^^^^^^^^^^^^^^^^^^
+
+error: aborting due to 3 previous errors
+
+Some errors have detailed explanations: E0277, E0308.
+For more information about an error, try `rustc --explain E0277`.

tests/ui/coercion/hr_alias_normalization_leaking_vars.rs

@@ -3,6 +3,9 @@
 // behavior has been fixed.
 
 //@ check-pass
+//@ revisions: current next
+//@ ignore-compare-mode-next-solver (explicit revisions)
+//@[next] compile-flags: -Znext-solver
 
 fn peculiar() -> impl Fn(u8) -> u8 {
     return |x| x + 1

tests/ui/coercion/hr_alias_normalization_leaking_vars.stderr

@@ -0,0 +1,25 @@
+macro_rules! lub {
+    ($lhs:expr, $rhs:expr) => {
+        if true { $lhs } else { $rhs }
+    };
+}
+
+struct Foo<T>(T);
+
+fn mk<T>() -> T {
+    loop {}
+}
+
+fn lub_deep_binder() {
+    loop {}
+
+    let a: Foo<for<'a> fn(&'a ())> = mk::<Foo<fn(&'static ())>>();
+    //~^ ERROR: mismatched types
+
+    let lhs = mk::<Foo<for<'a> fn(&'static (), &'a ())>>();
+    let rhs = mk::<Foo<for<'a> fn(&'a (), &'static ())>>();
+    lub!(lhs, rhs);
+    //~^ ERROR: `if` and `else` have incompatible types
+}
+
+fn main() {}

tests/ui/coercion/issue-88097.rs

@@ -0,0 +1,25 @@
+error[E0308]: mismatched types
+  --> $DIR/leak_check_failed_coercion_ops.rs:16:38
+   |
+LL |     let a: Foo<for<'a> fn(&'a ())> = mk::<Foo<fn(&'static ())>>();
+   |            -----------------------   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ one type is more general than the other
+   |            |
+   |            expected due to this
+   |
+   = note: expected struct `Foo<for<'a> fn(&'a ())>`
+              found struct `Foo<fn(&'static ())>`
+
+error[E0308]: `if` and `else` have incompatible types
+  --> $DIR/leak_check_failed_coercion_ops.rs:21:15
+   |
+LL |     lub!(lhs, rhs);
+   |          ---  ^^^ one type is more general than the other
+   |          |
+   |          expected because of this
+   |
+   = note: expected struct `Foo<for<'a> fn(&(), &'a ())>`
+              found struct `Foo<for<'a> fn(&'a (), &())>`
+
+error: aborting due to 2 previous errors
+
+For more information about this error, try `rustc --explain E0308`.