Fallback {float} to f32 when f32: From<{float}>

Author: beetrees

compiler/rustc_hir/src/lang_items.rs

@@ -436,6 +436,9 @@ language_item_table! {
     DefaultTrait1,           sym::default_trait1,      default_trait1_trait,       Target::Trait,          GenericRequirement::None;
 
     ContractCheckEnsures,     sym::contract_check_ensures,      contract_check_ensures_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

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
@@ -109,7 +114,8 @@ impl<'tcx> FnCtxt<'_, 'tcx> {
     //
     // - Unconstrained ints are replaced with `i32`.
     //
-    // - Unconstrained floats are replaced with `f64`.
+    // - Unconstrained floats are replaced with `f64`, except when there is a trait predicate
+    //   `f32: From<{float}>`, in which case `f32` is used as the fallback instead.
     //
     // - Non-numerics may get replaced with `()` or `!`, depending on
     //   how they were categorized by `calculate_diverging_fallback`
@@ -124,6 +130,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 +153,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 +168,64 @@ 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();
+        }
+        // Calculate all the unresolved variables that need to fallback to `f32` here. This ensures
+        // we don't need to find root variables in `fallback_if_possible`: see the comment at the
+        // top of that function for details.
+        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 +631,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(

compiler/rustc_infer/src/infer/mod.rs

@@ -1065,6 +1065,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
     }

compiler/rustc_middle/src/ty/sty.rs

@@ -1123,6 +1123,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(_))

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"),

tests/ui/float/f32-into-f32.rs

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

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
+}

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`.