Auto merge of rust-lang#139087 - beetrees:impl-from-f16-for-f32, r=<try>

Fallback `{float}` to `f32` when `f32: From<{float}>` and add `impl From<f16> for f32`

Currently, the following code compiles:
```rust
fn foo::<T: Into<f32>>(_: T) {}

fn main() {
    foo(1.0);
}
```

This is because the only `From<{float}>` impl for `f32` is currently `From<f32>`. However, once `impl From<f16> for f32` is added this is no longer the case. This would cause the float literal to fallback to `f64`, subsequently causing a type error as `f32` does not implement `From<f64>`. While this kind of change to type inference isn't technically a breaking change according to Rust's breaking change policy, the previous attempt to add `impl From<f16> for f32` was removed rust-lang#123830 due to the large number of crates affected (by my count, there were root regressions in 42 crates and 52 GitHub repos, not including duplicates). This PR solves this problem by using `f32` as the fallback type for `{float}` when there is a trait predicate of `f32: From<{float}>`. This allows adding `impl From<f16> for f32` without affecting the code that currently compiles (such as the example above; this PR shouldn't affect what is possible on stable).

This PR also allows adding a future-incompatibility warning if the lang team wants one; alternatively this could be expanded in the future into something more general like `@tgross35` suggested in rust-lang#123831 (comment). I think it would be also possible to disallow the `f32` fallback in a future edition.

This will need a crater check.

For reference, I've based the implementation loosely on the existing `calculate_diverging_fallback`. This first commit adds the `f32` fallback and the second adds `impl From<f16> for f32`. I think this falls under the types team, so
r? types

Fixes: rust-lang#123831
Tracking issue: rust-lang#116909

`@rustbot` label +T-lang +T-types +T-libs-api +F-f16_and_f128

To decide on whether a future-incompatibility warning is desired or otherwise (see above):
`@rustbot` label +I-lang-nominated

Author: bors

Diff for: compiler/rustc_hir/src/lang_items.rs

@@ -433,6 +433,9 @@ language_item_table! {
     // Experimental lang items for implementing contract pre- and post-condition checking.
     ContractBuildCheckEnsures, sym::contract_build_check_ensures, contract_build_check_ensures_fn, Target::Fn, GenericRequirement::None;
     ContractCheckRequires,     sym::contract_check_requires,      contract_check_requires_fn,      Target::Fn, GenericRequirement::None;
+
+    // Used to fallback `{float}` to `f32` when `f32: From<{float}>`
+    From,                    sym::From,                from_trait,                 Target::Trait,          GenericRequirement::Exact(1);
 }
 
 /// The requirement imposed on the generics of a lang item

Diff for: compiler/rustc_hir_typeck/src/fallback.rs

@@ -11,7 +11,10 @@ use rustc_hir::HirId;
 use rustc_hir::def::{DefKind, Res};
 use rustc_hir::def_id::DefId;
 use rustc_hir::intravisit::{InferKind, Visitor};
-use rustc_middle::ty::{self, Ty, TyCtxt, TypeSuperVisitable, TypeVisitable};
+use rustc_middle::ty::{
+    self, ClauseKind, FloatVid, PredicatePolarity, TraitPredicate, Ty, TyCtxt, TypeSuperVisitable,
+    TypeVisitable,
+};
 use rustc_session::lint;
 use rustc_span::def_id::LocalDefId;
 use rustc_span::{DUMMY_SP, Span};
@@ -92,14 +95,16 @@ impl<'tcx> FnCtxt<'_, 'tcx> {
 
         let diverging_fallback = self
             .calculate_diverging_fallback(&unresolved_variables, self.diverging_fallback_behavior);
+        let fallback_to_f32 = self.calculate_fallback_to_f32(&unresolved_variables);
 
         // We do fallback in two passes, to try to generate
         // better error messages.
         // The first time, we do *not* replace opaque types.
         let mut fallback_occurred = false;
         for ty in unresolved_variables {
             debug!("unsolved_variable = {:?}", ty);
-            fallback_occurred |= self.fallback_if_possible(ty, &diverging_fallback);
+            fallback_occurred |=
+                self.fallback_if_possible(ty, &diverging_fallback, &fallback_to_f32);
         }
 
         fallback_occurred
@@ -124,6 +129,7 @@ impl<'tcx> FnCtxt<'_, 'tcx> {
         &self,
         ty: Ty<'tcx>,
         diverging_fallback: &UnordMap<Ty<'tcx>, Ty<'tcx>>,
+        fallback_to_f32: &UnordSet<FloatVid>,
     ) -> bool {
         // Careful: we do NOT shallow-resolve `ty`. We know that `ty`
         // is an unsolved variable, and we determine its fallback
@@ -146,6 +152,7 @@ impl<'tcx> FnCtxt<'_, 'tcx> {
         let fallback = match ty.kind() {
             _ if let Some(e) = self.tainted_by_errors() => Ty::new_error(self.tcx, e),
             ty::Infer(ty::IntVar(_)) => self.tcx.types.i32,
+            ty::Infer(ty::FloatVar(vid)) if fallback_to_f32.contains(&vid) => self.tcx.types.f32,
             ty::Infer(ty::FloatVar(_)) => self.tcx.types.f64,
             _ => match diverging_fallback.get(&ty) {
                 Some(&fallback_ty) => fallback_ty,
@@ -160,6 +167,61 @@ impl<'tcx> FnCtxt<'_, 'tcx> {
         true
     }
 
+    /// Existing code relies on `f32: From<T>` (usually written as `T: Into<f32>`) resolving `T` to
+    /// `f32` when the type of `T` is inferred from an unsuffixed float literal. Using the default
+    /// fallback of `f64`, this would break when adding `impl From<f16> for f32`, as there are now
+    /// two float type which could be `T`, meaning that the fallback of `f64` would be used and
+    /// compilation error would occur as `f32` does not implement `From<f64>`. To avoid breaking
+    /// existing code, we instead fallback `T` to `f32` when there is a trait predicate
+    /// `f32: From<T>`. This means code like the following will continue to compile:
+    ///
+    /// ```rust
+    /// fn foo<T: Into<f32>>(_: T) {}
+    ///
+    /// foo(1.0);
+    /// ```
+    fn calculate_fallback_to_f32(&self, unresolved_variables: &[Ty<'tcx>]) -> UnordSet<FloatVid> {
+        let Some(from_trait) = self.tcx.lang_items().from_trait() else {
+            return UnordSet::new();
+        };
+        let pending_obligations = self.fulfillment_cx.borrow_mut().pending_obligations();
+        debug!("calculate_fallback_to_f32: pending_obligations={:?}", pending_obligations);
+        let roots: UnordSet<ty::FloatVid> = pending_obligations
+            .into_iter()
+            .filter_map(|obligation| {
+                // The predicates we are looking for look like
+                // `TraitPredicate(<f32 as std::convert::From<{float}>>, polarity:Positive)`.
+                // They will have no bound variables.
+                obligation.predicate.kind().no_bound_vars()
+            })
+            .filter_map(|predicate| match predicate {
+                ty::PredicateKind::Clause(ClauseKind::Trait(TraitPredicate {
+                    polarity: PredicatePolarity::Positive,
+                    trait_ref,
+                })) if trait_ref.def_id == from_trait
+                    && self.shallow_resolve(trait_ref.self_ty()).kind()
+                        == &ty::Float(ty::FloatTy::F32) =>
+                {
+                    self.root_float_vid(trait_ref.args.type_at(1))
+                }
+                _ => None,
+            })
+            .collect();
+        debug!("calculate_fallback_to_f32: roots={:?}", roots);
+        if roots.is_empty() {
+            // Most functions have no `f32: From<{float}>` predicates, so short-circuit and return
+            // an empty set when this is the case.
+            return UnordSet::new();
+        }
+        let fallback_to_f32 = unresolved_variables
+            .iter()
+            .flat_map(|ty| ty.float_vid())
+            .filter(|vid| roots.contains(&self.root_float_var(*vid)))
+            .collect();
+        debug!("calculate_fallback_to_f32: fallback_to_f32={:?}", fallback_to_f32);
+        fallback_to_f32
+    }
+
     /// The "diverging fallback" system is rather complicated. This is
     /// a result of our need to balance 'do the right thing' with
     /// backwards compatibility.
@@ -565,6 +627,11 @@ impl<'tcx> FnCtxt<'_, 'tcx> {
         Some(self.root_var(self.shallow_resolve(ty).ty_vid()?))
     }
 
+    /// If `ty` is an unresolved float type variable, returns its root vid.
+    fn root_float_vid(&self, ty: Ty<'tcx>) -> Option<ty::FloatVid> {
+        Some(self.root_float_var(self.shallow_resolve(ty).float_vid()?))
+    }
+
     /// Given a set of diverging vids and coercions, walk the HIR to gather a
     /// set of suggestions which can be applied to preserve fallback to unit.
     fn try_to_suggest_annotations(

Diff for: compiler/rustc_infer/src/infer/mod.rs

@@ -1061,6 +1061,10 @@ impl<'tcx> InferCtxt<'tcx> {
         self.inner.borrow_mut().type_variables().root_var(var)
     }
 
+    pub fn root_float_var(&self, var: ty::FloatVid) -> ty::FloatVid {
+        self.inner.borrow_mut().float_unification_table().find(var)
+    }
+
     pub fn root_const_var(&self, var: ty::ConstVid) -> ty::ConstVid {
         self.inner.borrow_mut().const_unification_table().find(var).vid
     }

Diff for: compiler/rustc_middle/src/ty/sty.rs

@@ -1124,6 +1124,14 @@ impl<'tcx> Ty<'tcx> {
         }
     }
 
+    #[inline]
+    pub fn float_vid(self) -> Option<ty::FloatVid> {
+        match self.kind() {
+            &Infer(FloatVar(vid)) => Some(vid),
+            _ => None,
+        }
+    }
+
     #[inline]
     pub fn is_ty_or_numeric_infer(self) -> bool {
         matches!(self.kind(), Infer(_))

Diff for: library/core/src/convert/mod.rs

@@ -573,6 +573,7 @@ pub trait Into<T>: Sized {
 /// [`from`]: From::from
 /// [book]: ../../book/ch09-00-error-handling.html
 #[rustc_diagnostic_item = "From"]
+#[cfg_attr(not(bootstrap), lang = "From")]
 #[stable(feature = "rust1", since = "1.0.0")]
 #[rustc_on_unimplemented(on(
     all(_Self = "&str", T = "alloc::string::String"),

Diff for: library/core/src/convert/num.rs

@@ -185,9 +185,8 @@ impl_from!(u32 => f128, #[stable(feature = "lossless_float_conv", since = "1.6.0
 // impl_from!(u64 => f128, #[stable(feature = "lossless_float_conv", since = "1.6.0")]);
 
 // float -> float
-// FIXME(f16_f128): adding additional `From<{float}>` impls to `f32` breaks inference. See
-// <https://github.com/rust-lang/rust/issues/123831>
 impl_from!(f16 => f64, #[stable(feature = "lossless_float_conv", since = "1.6.0")]);
+impl_from!(f16 => f32, #[stable(feature = "lossless_float_conv", since = "1.6.0")]);
 impl_from!(f16 => f128, #[stable(feature = "lossless_float_conv", since = "1.6.0")]);
 impl_from!(f32 => f64, #[stable(feature = "lossless_float_conv", since = "1.6.0")]);
 impl_from!(f32 => f128, #[stable(feature = "lossless_float_conv", since = "1.6.0")]);

Diff for: tests/ui/float/f32-into-f32.rs

@@ -0,0 +1,7 @@
+//@ run-pass
+
+fn foo(_: impl Into<f32>) {}
+
+fn main() {
+    foo(1.0);
+}

Diff for: tests/ui/float/trait-f16-or-f32.rs

@@ -0,0 +1,13 @@
+//@ check-fail
+
+#![feature(f16)]
+
+trait Trait {}
+impl Trait for f16 {}
+impl Trait for f32 {}
+
+fn foo(_: impl Trait) {}
+
+fn main() {
+    foo(1.0); //~ ERROR the trait bound `f64: Trait` is not satisfied
+}

Diff for: tests/ui/float/trait-f16-or-f32.stderr

@@ -0,0 +1,20 @@
+error[E0277]: the trait bound `f64: Trait` is not satisfied
+  --> $DIR/trait-f16-or-f32.rs:12:9
+   |
+LL |     foo(1.0);
+   |     --- ^^^ the trait `Trait` is not implemented for `f64`
+   |     |
+   |     required by a bound introduced by this call
+   |
+   = help: the following other types implement trait `Trait`:
+             f16
+             f32
+note: required by a bound in `foo`
+  --> $DIR/trait-f16-or-f32.rs:9:16
+   |
+LL | fn foo(_: impl Trait) {}
+   |                ^^^^^ required by this bound in `foo`
+
+error: aborting due to 1 previous error
+
+For more information about this error, try `rustc --explain E0277`.