Rollup of 7 pull requests

compiler/rustc_lint/src/lib.rs

@@ -516,6 +516,10 @@ fn register_builtins(store: &mut LintStore) {
  "converted into hard error, see PR #118649 \
  <https://github.com/rust-lang/rust/pull/118649> for more information",
  );
+ store.register_removed(
+ "illegal_floating_point_literal_pattern",
+ "no longer a warning, float patterns behave the same as `==`",
+ );
 }
 
 fn register_internals(store: &mut LintStore) {

compiler/rustc_lint_defs/src/builtin.rs

@@ -45,7 +45,6 @@ declare_lint_pass! {
  FUZZY_PROVENANCE_CASTS,
  HIDDEN_GLOB_REEXPORTS,
  ILL_FORMED_ATTRIBUTE_INPUT,
- ILLEGAL_FLOATING_POINT_LITERAL_PATTERN,
  INCOMPLETE_INCLUDE,
  INDIRECT_STRUCTURAL_MATCH,
  INEFFECTIVE_UNSTABLE_TRAIT_IMPL,
@@ -1873,55 +1872,6 @@ declare_lint! {
  };
 }
 
-declare_lint! {
- /// The `illegal_floating_point_literal_pattern` lint detects
- /// floating-point literals used in patterns.
- ///
- /// ### Example
- ///
- /// ```rust
- /// let x = 42.0;
- ///
- /// match x {
- /// 5.0 => {}
- /// _ => {}
- /// }
- /// ```
- ///
- /// {{produces}}
- ///
- /// ### Explanation
- ///
- /// Previous versions of the compiler accepted floating-point literals in
- /// patterns, but it was later determined this was a mistake. The
- /// semantics of comparing floating-point values may not be clear in a
- /// pattern when contrasted with "structural equality". Typically you can
- /// work around this by using a [match guard], such as:
- ///
- /// ```rust
- /// # let x = 42.0;
- ///
- /// match x {
- /// y if y == 5.0 => {}
- /// _ => {}
- /// }
- /// ```
- ///
- /// This is a [future-incompatible] lint to transition this to a hard
- /// error in the future. See [issue #41620] for more details.
- ///
- /// [issue #41620]: https://github.com/rust-lang/rust/issues/41620
- /// [match guard]: https://doc.rust-lang.org/reference/expressions/match-expr.html#match-guards
- /// [future-incompatible]: ../index.md#future-incompatible-lints
- pub ILLEGAL_FLOATING_POINT_LITERAL_PATTERN,
- Warn,
- "floating-point literals cannot be used in patterns",
- @future_incompatible = FutureIncompatibleInfo {
- reason: FutureIncompatibilityReason::FutureReleaseErrorDontReportInDeps,
- reference: "issue #41620 <https://github.com/rust-lang/rust/issues/41620>",
- };
-}
-
 declare_lint! {
  /// The `unstable_name_collisions` lint detects that you have used a name
  /// that the standard library plans to add in the future.

compiler/rustc_middle/src/mir/interpret/value.rs

@@ -418,8 +418,8 @@ impl<'tcx, Prov: Provenance> Scalar<Prov> {
 
  #[inline]
  pub fn to_float<F: Float>(self) -> InterpResult<'tcx, F> {
- // Going through `to_uint` to check size and truncation.
- Ok(F::from_bits(self.to_uint(Size::from_bits(F::BITS))?))
+ // Going through `to_bits` to check size and truncation.
+ Ok(F::from_bits(self.to_bits(Size::from_bits(F::BITS))?))
  }
 
  #[inline]

compiler/rustc_middle/src/ty/consts/int.rs

@@ -249,11 +249,6 @@ impl ScalarInt {
  }
  }
 
- #[inline]
- pub fn try_to_target_usize(&self, tcx: TyCtxt<'_>) -> Result<u64, Size> {
- Ok(self.to_bits(tcx.data_layout.pointer_size)? as u64)
- }
-
  /// Tries to convert the `ScalarInt` to an unsigned integer of the given size.
  /// Fails if the size of the `ScalarInt` is not equal to `size` and returns the
  /// `ScalarInt`s size in that case.
@@ -262,56 +257,61 @@ impl ScalarInt {
  self.to_bits(size)
  }
 
- // Tries to convert the `ScalarInt` to `bool`. Fails if the `size` of the `ScalarInt`
- // in not equal to `Size { raw: 1 }` or if the value is not 0 or 1 and returns the `size`
- // value of the `ScalarInt` in that case.
- #[inline]
- pub fn try_to_bool(self) -> Result<bool, Size> {
- match self.try_to_u8()? {
- 0 => Ok(false),
- 1 => Ok(true),
- _ => Err(self.size()),
- }
- }
-
  // Tries to convert the `ScalarInt` to `u8`. Fails if the `size` of the `ScalarInt`
  // in not equal to `Size { raw: 1 }` and returns the `size` value of the `ScalarInt` in
  // that case.
  #[inline]
  pub fn try_to_u8(self) -> Result<u8, Size> {
- self.to_bits(Size::from_bits(8)).map(|v| u8::try_from(v).unwrap())
+ self.try_to_uint(Size::from_bits(8)).map(|v| u8::try_from(v).unwrap())
  }
 
  /// Tries to convert the `ScalarInt` to `u16`. Fails if the size of the `ScalarInt`
  /// in not equal to `Size { raw: 2 }` and returns the `size` value of the `ScalarInt` in
  /// that case.
  #[inline]
  pub fn try_to_u16(self) -> Result<u16, Size> {
- self.to_bits(Size::from_bits(16)).map(|v| u16::try_from(v).unwrap())
+ self.try_to_uint(Size::from_bits(16)).map(|v| u16::try_from(v).unwrap())
  }
 
  /// Tries to convert the `ScalarInt` to `u32`. Fails if the `size` of the `ScalarInt`
  /// in not equal to `Size { raw: 4 }` and returns the `size` value of the `ScalarInt` in
  /// that case.
  #[inline]
  pub fn try_to_u32(self) -> Result<u32, Size> {
- self.to_bits(Size::from_bits(32)).map(|v| u32::try_from(v).unwrap())
+ self.try_to_uint(Size::from_bits(32)).map(|v| u32::try_from(v).unwrap())
  }
 
  /// Tries to convert the `ScalarInt` to `u64`. Fails if the `size` of the `ScalarInt`
  /// in not equal to `Size { raw: 8 }` and returns the `size` value of the `ScalarInt` in
  /// that case.
  #[inline]
  pub fn try_to_u64(self) -> Result<u64, Size> {
- self.to_bits(Size::from_bits(64)).map(|v| u64::try_from(v).unwrap())
+ self.try_to_uint(Size::from_bits(64)).map(|v| u64::try_from(v).unwrap())
  }
 
  /// Tries to convert the `ScalarInt` to `u128`. Fails if the `size` of the `ScalarInt`
  /// in not equal to `Size { raw: 16 }` and returns the `size` value of the `ScalarInt` in
  /// that case.
  #[inline]
  pub fn try_to_u128(self) -> Result<u128, Size> {
- self.to_bits(Size::from_bits(128))
+ self.try_to_uint(Size::from_bits(128))
+ }
+
+ #[inline]
+ pub fn try_to_target_usize(&self, tcx: TyCtxt<'_>) -> Result<u64, Size> {
+ self.try_to_uint(tcx.data_layout.pointer_size).map(|v| u64::try_from(v).unwrap())
+ }
+
+ // Tries to convert the `ScalarInt` to `bool`. Fails if the `size` of the `ScalarInt`
+ // in not equal to `Size { raw: 1 }` or if the value is not 0 or 1 and returns the `size`
+ // value of the `ScalarInt` in that case.
+ #[inline]
+ pub fn try_to_bool(self) -> Result<bool, Size> {
+ match self.try_to_u8()? {
+ 0 => Ok(false),
+ 1 => Ok(true),
+ _ => Err(self.size()),
+ }
  }
 
  /// Tries to convert the `ScalarInt` to a signed integer of the given size.
@@ -357,6 +357,27 @@ impl ScalarInt {
  pub fn try_to_i128(self) -> Result<i128, Size> {
  self.try_to_int(Size::from_bits(128))
  }
+
+ #[inline]
+ pub fn try_to_target_isize(&self, tcx: TyCtxt<'_>) -> Result<i64, Size> {
+ self.try_to_int(tcx.data_layout.pointer_size).map(|v| i64::try_from(v).unwrap())
+ }
+
+ #[inline]
+ pub fn try_to_float<F: Float>(self) -> Result<F, Size> {
+ // Going through `to_uint` to check size and truncation.
+ Ok(F::from_bits(self.to_bits(Size::from_bits(F::BITS))?))
+ }
+
+ #[inline]
+ pub fn try_to_f32(self) -> Result<Single, Size> {
+ self.try_to_float()
+ }
+
+ #[inline]
+ pub fn try_to_f64(self) -> Result<Double, Size> {
+ self.try_to_float()
+ }
 }
 
 macro_rules! from {
@@ -399,11 +420,7 @@ impl TryFrom<ScalarInt> for bool {
  type Error = Size;
  #[inline]
  fn try_from(int: ScalarInt) -> Result<Self, Size> {
- int.to_bits(Size::from_bytes(1)).and_then(|u| match u {
- 0 => Ok(false),
- 1 => Ok(true),
- _ => Err(Size::from_bytes(1)),
- })
+ int.try_to_bool()
  }
 }
 

compiler/rustc_mir_build/messages.ftl

@@ -107,8 +107,6 @@ mir_build_extern_static_requires_unsafe_unsafe_op_in_unsafe_fn_allowed =
  .note = extern statics are not controlled by the Rust type system: invalid data, aliasing violations or data races will cause undefined behavior
  .label = use of extern static
 
-mir_build_float_pattern = floating-point types cannot be used in patterns
-
 mir_build_indirect_structural_match =
  to use a constant of type `{$non_sm_ty}` in a pattern, `{$non_sm_ty}` must be annotated with `#[derive(PartialEq)]`
 
@@ -232,6 +230,10 @@ mir_build_mutation_of_layout_constrained_field_requires_unsafe_unsafe_op_in_unsa
  .note = mutating layout constrained fields cannot statically be checked for valid values
  .label = mutation of layout constrained field
 
+mir_build_nan_pattern = cannot use NaN in patterns
+ .note = NaNs compare inequal to everything, even themselves, so this pattern would never match
+ .help = try using the `is_nan` method instead
+
 mir_build_non_const_path = runtime values cannot be referenced in patterns
 
 mir_build_non_empty_never_pattern =

compiler/rustc_mir_build/src/build/matches/simplify.rs

@@ -40,43 +40,39 @@ impl<'a, 'tcx> Builder<'a, 'tcx> {
  &mut self,
  candidate: &mut Candidate<'pat, 'tcx>,
  ) -> bool {
- // repeatedly simplify match pairs until fixed point is reached
  debug!("{candidate:#?}");
-
- // existing_bindings and new_bindings exists to keep the semantics in order.
- // Reversing the binding order for bindings after `@` changes the binding order in places
- // it shouldn't be changed, for example `let (Some(a), Some(b)) = (x, y)`
+ // In order to please the borrow checker, in a pattern like `x @ pat` we must lower the
+ // bindings in `pat` before `x`. E.g. (#69971):
+ //
+ // struct NonCopyStruct {
+ // copy_field: u32,
+ // }
+ //
+ // fn foo1(x: NonCopyStruct) {
+ // let y @ NonCopyStruct { copy_field: z } = x;
+ // // the above should turn into
+ // let z = x.copy_field;
+ // let y = x;
+ // }
  //
- // To avoid this, the binding occurs in the following manner:
- // * the bindings for one iteration of the following loop occurs in order (i.e. left to
- // right)
- // * the bindings from the previous iteration of the loop is prepended to the bindings from
- // the current iteration (in the implementation this is done by mem::swap and extend)
- // * after all iterations, these new bindings are then appended to the bindings that were
- // preexisting (i.e. `candidate.binding` when the function was called).
+ // We can't just reverse the binding order, because we must preserve pattern-order
+ // otherwise, e.g. in `let (Some(a), Some(b)) = (x, y)`. Our rule then is: deepest-first,
+ // and bindings at the same depth stay in source order.
+ //
+ // To do this, every time around the loop we prepend the newly found bindings to the
+ // bindings we already had.
  //
  // example:
  // candidate.bindings = [1, 2, 3]
- // binding in iter 1: [4, 5]
- // binding in iter 2: [6, 7]
+ // bindings in iter 1: [4, 5]
+ // bindings in iter 2: [6, 7]
  //
- // final binding: [1, 2, 3, 6, 7, 4, 5]
- let mut existing_bindings = mem::take(&mut candidate.bindings);
- let mut new_bindings = Vec::new();
+ // final bindings: [6, 7, 4, 5, 1, 2, 3]
+ let mut accumulated_bindings = mem::take(&mut candidate.bindings);
+ // Repeatedly simplify match pairs until fixed point is reached
  loop {
- let match_pairs = mem::take(&mut candidate.match_pairs);
-
- if let [MatchPair { pattern: Pat { kind: PatKind::Or { pats }, .. }, place }] =
- &*match_pairs
- {
- existing_bindings.extend_from_slice(&new_bindings);
- mem::swap(&mut candidate.bindings, &mut existing_bindings);
- candidate.subcandidates = self.create_or_subcandidates(candidate, place, pats);
- return true;
- }
-
  let mut changed = false;
- for match_pair in match_pairs {
+ for match_pair in mem::take(&mut candidate.match_pairs) {
  match self.simplify_match_pair(match_pair, candidate) {
  Ok(()) => {
  changed = true;
@@ -86,36 +82,39 @@ impl<'a, 'tcx> Builder<'a, 'tcx> {
  }
  }
  }
- // Avoid issue #69971: the binding order should be right to left if there are more
- // bindings after `@` to please the borrow checker
- // Ex
- // struct NonCopyStruct {
- // copy_field: u32,
- // }
- //
- // fn foo1(x: NonCopyStruct) {
- // let y @ NonCopyStruct { copy_field: z } = x;
- // // the above should turn into
- // let z = x.copy_field;
- // let y = x;
- // }
- candidate.bindings.extend_from_slice(&new_bindings);
- mem::swap(&mut candidate.bindings, &mut new_bindings);
+
+ // This does: accumulated_bindings = candidate.bindings.take() ++ accumulated_bindings
+ candidate.bindings.extend_from_slice(&accumulated_bindings);
+ mem::swap(&mut candidate.bindings, &mut accumulated_bindings);
  candidate.bindings.clear();
 
  if !changed {
- existing_bindings.extend_from_slice(&new_bindings);
- mem::swap(&mut candidate.bindings, &mut existing_bindings);
- // Move or-patterns to the end, because they can result in us
- // creating additional candidates, so we want to test them as
- // late as possible.
- candidate
- .match_pairs
- .sort_by_key(|pair| matches!(pair.pattern.kind, PatKind::Or { .. }));
- debug!(simplified = ?candidate, "simplify_candidate");
- return false; // if we were not able to simplify any, done.
+ // If we were not able to simplify anymore, done.
+ break;
  }
  }
+
+ // Store computed bindings back in `candidate`.
+ mem::swap(&mut candidate.bindings, &mut accumulated_bindings);
+
+ let did_expand_or =
+ if let [MatchPair { pattern: Pat { kind: PatKind::Or { pats }, .. }, place }] =
+ &*candidate.match_pairs
+ {
+ candidate.subcandidates = self.create_or_subcandidates(candidate, place, pats);
+ candidate.match_pairs.clear();
+ true
+ } else {
+ false
+ };
+
+ // Move or-patterns to the end, because they can result in us
+ // creating additional candidates, so we want to test them as
+ // late as possible.
+ candidate.match_pairs.sort_by_key(|pair| matches!(pair.pattern.kind, PatKind::Or { .. }));
+ debug!(simplified = ?candidate, "simplify_candidate");
+
+ did_expand_or
  }
 
  /// Given `candidate` that has a single or-pattern for its match-pairs,

compiler/rustc_mir_build/src/errors.rs

@@ -780,9 +780,14 @@ pub struct UnsizedPattern<'tcx> {
  pub non_sm_ty: Ty<'tcx>,
 }
 
-#[derive(LintDiagnostic)]
-#[diag(mir_build_float_pattern)]
-pub struct FloatPattern;
+#[derive(Diagnostic)]
+#[diag(mir_build_nan_pattern)]
+#[note]
+#[help]
+pub struct NaNPattern {
+ #[primary_span]
+ pub span: Span,
+}
 
 #[derive(LintDiagnostic)]
 #[diag(mir_build_pointer_pattern)]