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

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 for the fallback to `f32` (currently implemented in the third commit) if the lang team wants one (allowing the `f32` fallback to be removed in the future); 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.

As expected, a crater check showed [no non-spurious regressions](rust-lang#139087 (comment)).

For reference, I've based the implementation loosely on the existing `calculate_diverging_fallback`. This first commit adds the `f32` fallback, the second adds `impl From<f16> for f32`, and the third adds a FCW lint for the `f32` fallback. 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

cc rust-lang#154024 rust-lang#154005

Author: bors

compiler/rustc_hir/src/lang_items.rs

@@ -443,6 +443,9 @@ language_item_table! {
     FieldBase,               sym::field_base,              field_base,                 Target::AssocTy,        GenericRequirement::Exact(0);
     FieldType,               sym::field_type,              field_type,                 Target::AssocTy,        GenericRequirement::Exact(0);
     FieldOffset,             sym::field_offset,            field_offset,               Target::AssocConst,     GenericRequirement::Exact(0);
+
+    // 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/demand.rs

@@ -346,7 +346,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
                     match infer {
                         ty::TyVar(_) => self.next_ty_var(DUMMY_SP),
                         ty::IntVar(_) => self.next_int_var(),
-                        ty::FloatVar(_) => self.next_float_var(),
+                        ty::FloatVar(_) => self.next_float_var(DUMMY_SP, None),
                         ty::FreshTy(_) | ty::FreshIntTy(_) | ty::FreshFloatTy(_) => {
                             bug!("unexpected fresh ty outside of the trait solver")
                         }

compiler/rustc_hir_typeck/src/errors.rs

@@ -1384,3 +1384,15 @@ pub(crate) struct ProjectOnNonPinProjectType {
     )]
     pub sugg_span: Option<Span>,
 }
+
+#[derive(Diagnostic)]
+#[diag("falling back to `f32` as the trait bound `f32: From<f64>` is not satisfied")]
+pub(crate) struct FloatLiteralF32Fallback {
+    pub literal: String,
+    #[suggestion(
+        "explicitly specify the type as `f32`",
+        code = "{literal}_f32",
+        applicability = "machine-applicable"
+    )]
+    pub span: Option<Span>,
+}

compiler/rustc_hir_typeck/src/expr.rs

@@ -349,7 +349,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
 
         let tcx = self.tcx;
         match expr.kind {
-            ExprKind::Lit(ref lit) => self.check_expr_lit(lit, expected),
+            ExprKind::Lit(ref lit) => self.check_expr_lit(lit, expr.hir_id, expected),
             ExprKind::Binary(op, lhs, rhs) => self.check_expr_binop(expr, op, lhs, rhs, expected),
             ExprKind::Assign(lhs, rhs, span) => {
                 self.check_expr_assign(expr, expected, lhs, rhs, span)

compiler/rustc_hir_typeck/src/fallback.rs

@@ -5,13 +5,13 @@ use rustc_data_structures::fx::FxHashSet;
 use rustc_data_structures::graph;
 use rustc_data_structures::graph::vec_graph::VecGraph;
 use rustc_data_structures::unord::{UnordMap, UnordSet};
-use rustc_hir as hir;
-use rustc_hir::HirId;
 use rustc_hir::attrs::DivergingFallbackBehavior;
 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_hir::{self as hir, CRATE_HIR_ID, HirId};
+use rustc_lint::builtin::FLOAT_LITERAL_F32_FALLBACK;
+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};
@@ -55,15 +55,20 @@ impl<'tcx> FnCtxt<'_, 'tcx> {
 
         let (diverging_fallback, diverging_fallback_ty) =
             self.calculate_diverging_fallback(&unresolved_variables);
+        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, diverging_fallback_ty);
+            fallback_occurred |= self.fallback_if_possible(
+                ty,
+                &diverging_fallback,
+                diverging_fallback_ty,
+                &fallback_to_f32,
+            );
         }
 
         fallback_occurred
@@ -73,7 +78,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 [`Self::calculate_diverging_fallback`], crate's
@@ -89,6 +95,7 @@ impl<'tcx> FnCtxt<'_, 'tcx> {
         ty: Ty<'tcx>,
         diverging_fallback: &UnordSet<Ty<'tcx>>,
         diverging_fallback_ty: 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
@@ -111,6 +118,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,
             _ if diverging_fallback.contains(&ty) => {
                 self.diverging_fallback_has_occurred.set(true);
@@ -125,6 +133,52 @@ 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)))
+            .inspect(|vid| {
+                let origin = self.float_var_origin(*vid);
+                // Show the entire literal in the suggestion to make it clearer.
+                let literal = self.tcx.sess.source_map().span_to_snippet(origin.span).ok();
+                self.tcx.emit_node_span_lint(
+                    FLOAT_LITERAL_F32_FALLBACK,
+                    origin.lint_id.unwrap_or(CRATE_HIR_ID),
+                    origin.span,
+                    errors::FloatLiteralF32Fallback {
+                        span: literal.as_ref().map(|_| origin.span),
+                        literal: literal.unwrap_or_default(),
+                    },
+                );
+            })
+            .collect();
+        debug!("calculate_fallback_to_f32: fallback_to_f32={:?}", fallback_to_f32);
+        fallback_to_f32
+    }
+
     fn calculate_diverging_fallback(
         &self,
         unresolved_variables: &[Ty<'tcx>],
@@ -362,6 +416,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/checks.rs

@@ -718,6 +718,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
     pub(in super::super) fn check_expr_lit(
         &self,
         lit: &hir::Lit,
+        lint_id: HirId,
         expected: Expectation<'tcx>,
     ) -> Ty<'tcx> {
         let tcx = self.tcx;
@@ -765,7 +766,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
                     ty::Float(_) => Some(ty),
                     _ => None,
                 });
-                opt_ty.unwrap_or_else(|| self.next_float_var())
+                opt_ty.unwrap_or_else(|| self.next_float_var(lit.span, Some(lint_id)))
             }
             ast::LitKind::Bool(_) => tcx.types.bool,
             ast::LitKind::CStr(_, _) => Ty::new_imm_ref(

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::ty::{self, Ty, TypeVisitableExt};
 use rustc_span::Span;
@@ -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
     }
@@ -144,3 +209,37 @@ 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 {
+        // Avoid hang from exponentially growing proof trees (see `cycle-modulo-ambig-aliases.rs`).
+        // 3 is more than enough for all occurrences in practice (a.k.a. `Into`).
+        InspectConfig { max_depth: 3 }
+    }
+
+    fn visit_goal(&mut self, inspect_goal: &InspectGoal<'_, 'tcx>) {
+        if let Some(vid) = self
+            .fcx
+            .predicate_from_float_for_f32_root_vid(self.from_trait, inspect_goal.goal().predicate)
+        {
+            self.vids.insert(vid);
+        } else if let Some(candidate) = inspect_goal.unique_applicable_candidate() {
+            let start_len = self.vids.len();
+            let _ = candidate.goal().infcx().commit_if_ok(|_| {
+                candidate.visit_nested_no_probe(self);
+                if self.vids.len() > start_len { Ok(()) } else { Err(()) }
+            });
+        }
+    }
+}

compiler/rustc_hir_typeck/src/pat.rs

@@ -917,7 +917,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
     fn check_pat_expr_unadjusted(&self, lt: &'tcx hir::PatExpr<'tcx>) -> Ty<'tcx> {
         let ty = match &lt.kind {
             rustc_hir::PatExprKind::Lit { lit, negated } => {
-                let ty = self.check_expr_lit(lit, Expectation::NoExpectation);
+                let ty = self.check_expr_lit(lit, lt.hir_id, Expectation::NoExpectation);
                 if *negated {
                     self.register_bound(
                         ty,

compiler/rustc_infer/src/infer/canonical/mod.rs

@@ -107,7 +107,10 @@ impl<'tcx> InferCtxt<'tcx> {
 
             CanonicalVarKind::Int => self.next_int_var().into(),
 
-            CanonicalVarKind::Float => self.next_float_var().into(),
+            CanonicalVarKind::Float => {
+                // There is no HirId available to pass as a lint_id.
+                self.next_float_var(span, None).into()
+            }
 
             CanonicalVarKind::PlaceholderTy(ty::PlaceholderType { universe, bound, .. }) => {
                 let universe_mapped = universe_map(universe);