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,7 @@ 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, FloatVid, Ty, TyCtxt, TypeSuperVisitable, TypeVisitable};
 use rustc_session::lint;
 use rustc_span::def_id::LocalDefId;
 use rustc_span::{DUMMY_SP, Span};
@@ -92,14 +92,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 +111,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 +127,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 +150,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 +165,38 @@ 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 roots: UnordSet<ty::FloatVid> = self.from_float_for_f32_root_vids();
+        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 +602,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.
+    pub(crate) 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_hir_typeck/src/fn_ctxt/inspect_obligations.rs

@@ -1,5 +1,7 @@
 //! A utility module to inspect currently ambiguous obligations in the current context.
 
+use rustc_data_structures::unord::UnordSet;
+use rustc_hir::def_id::DefId;
 use rustc_infer::traits::{self, ObligationCause, PredicateObligations};
 use rustc_middle::traits::solve::GoalSource;
 use rustc_middle::ty::{self, Ty, TypeVisitableExt};
@@ -96,6 +98,69 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
         });
         obligations_for_self_ty
     }
+
+    /// Only needed for the `From<{float}>` for `f32` type fallback.
+    #[instrument(skip(self), level = "debug")]
+    pub(crate) fn from_float_for_f32_root_vids(&self) -> UnordSet<ty::FloatVid> {
+        if self.next_trait_solver() {
+            self.from_float_for_f32_root_vids_next()
+        } else {
+            let Some(from_trait) = self.tcx.lang_items().from_trait() else {
+                return UnordSet::new();
+            };
+            self.fulfillment_cx
+                .borrow_mut()
+                .pending_obligations()
+                .into_iter()
+                .filter_map(|obligation| {
+                    self.predicate_from_float_for_f32_root_vid(from_trait, obligation.predicate)
+                })
+                .collect()
+        }
+    }
+
+    fn predicate_from_float_for_f32_root_vid(
+        &self,
+        from_trait: DefId,
+        predicate: ty::Predicate<'tcx>,
+    ) -> Option<ty::FloatVid> {
+        // The predicates we are looking for look like
+        // `TraitPredicate(<f32 as std::convert::From<{float}>>, polarity:Positive)`.
+        // They will have no bound variables.
+        match predicate.kind().no_bound_vars() {
+            Some(ty::PredicateKind::Clause(ty::ClauseKind::Trait(ty::TraitPredicate {
+                polarity: ty::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,
+        }
+    }
+
+    fn from_float_for_f32_root_vids_next(&self) -> UnordSet<ty::FloatVid> {
+        let Some(from_trait) = self.tcx.lang_items().from_trait() else {
+            return UnordSet::new();
+        };
+        let obligations = self.fulfillment_cx.borrow().pending_obligations();
+        debug!(?obligations);
+        let mut vids = UnordSet::new();
+        for obligation in obligations {
+            let mut visitor = FindFromFloatForF32RootVids {
+                fcx: self,
+                from_trait,
+                vids: &mut vids,
+                span: obligation.cause.span,
+            };
+
+            let goal = obligation.as_goal();
+            self.visit_proof_tree(goal, &mut visitor);
+        }
+        vids
+    }
 }
 
 struct NestedObligationsForSelfTy<'a, 'tcx> {
@@ -105,7 +170,7 @@ struct NestedObligationsForSelfTy<'a, 'tcx> {
     obligations_for_self_ty: &'a mut PredicateObligations<'tcx>,
 }
 
-impl<'a, 'tcx> ProofTreeVisitor<'tcx> for NestedObligationsForSelfTy<'a, 'tcx> {
+impl<'tcx> ProofTreeVisitor<'tcx> for NestedObligationsForSelfTy<'_, 'tcx> {
     fn span(&self) -> Span {
         self.root_cause.span
     }
@@ -166,3 +231,34 @@ impl<'a, 'tcx> ProofTreeVisitor<'tcx> for NestedObligationsForSelfTy<'a, 'tcx> {
         }
     }
 }
+
+struct FindFromFloatForF32RootVids<'a, 'tcx> {
+    fcx: &'a FnCtxt<'a, 'tcx>,
+    from_trait: DefId,
+    vids: &'a mut UnordSet<ty::FloatVid>,
+    span: Span,
+}
+
+impl<'tcx> ProofTreeVisitor<'tcx> for FindFromFloatForF32RootVids<'_, 'tcx> {
+    fn span(&self) -> Span {
+        self.span
+    }
+
+    fn config(&self) -> InspectConfig {
+        // See comment in `NestedObligationsForSelfTy`.
+        InspectConfig { max_depth: 5 }
+    }
+
+    fn visit_goal(&mut self, inspect_goal: &InspectGoal<'_, 'tcx>) {
+        self.vids.extend(
+            self.fcx.predicate_from_float_for_f32_root_vid(
+                self.from_trait,
+                inspect_goal.goal().predicate,
+            ),
+        );
+
+        if let Some(candidate) = inspect_goal.unique_applicable_candidate() {
+            candidate.visit_nested_no_probe(self)
+        }
+    }
+}

compiler/rustc_infer/src/infer/mod.rs

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

@@ -1126,6 +1126,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"]
+#[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,9 @@
+//@ revisions: old-solver next-solver
+//@[next-solver] compile-flags: -Znext-solver
+//@ 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`.