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

Author: beetrees

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

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(

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
  }

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(_))

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