Rollup of 7 pull requests

Cargo.lock

@@ -2598,12 +2598,76 @@ dependencies = [
  "windows-sys 0.48.0",
 ]
 
+[[package]]
+name = "num"
+version = "0.4.3"
+source = "registry+https:/rust-lang/crates.io-index"
+checksum = "35bd024e8b2ff75562e5f34e7f4905839deb4b22955ef5e73d2fea1b9813cb23"
+dependencies = [
+ "num-bigint",
+ "num-complex",
+ "num-integer",
+ "num-iter",
+ "num-rational",
+ "num-traits",
+]
+
+[[package]]
+name = "num-bigint"
+version = "0.4.6"
+source = "registry+https:/rust-lang/crates.io-index"
+checksum = "a5e44f723f1133c9deac646763579fdb3ac745e418f2a7af9cd0c431da1f20b9"
+dependencies = [
+ "num-integer",
+ "num-traits",
+]
+
+[[package]]
+name = "num-complex"
+version = "0.4.6"
+source = "registry+https:/rust-lang/crates.io-index"
+checksum = "73f88a1307638156682bada9d7604135552957b7818057dcef22705b4d509495"
+dependencies = [
+ "num-traits",
+]
+
 [[package]]
 name = "num-conv"
 version = "0.1.0"
 source = "registry+https:/rust-lang/crates.io-index"
 checksum = "51d515d32fb182ee37cda2ccdcb92950d6a3c2893aa280e540671c2cd0f3b1d9"
 
+[[package]]
+name = "num-integer"
+version = "0.1.46"
+source = "registry+https:/rust-lang/crates.io-index"
+checksum = "7969661fd2958a5cb096e56c8e1ad0444ac2bbcd0061bd28660485a44879858f"
+dependencies = [
+ "num-traits",
+]
+
+[[package]]
+name = "num-iter"
+version = "0.1.45"
+source = "registry+https:/rust-lang/crates.io-index"
+checksum = "1429034a0490724d0075ebb2bc9e875d6503c3cf69e235a8941aa757d83ef5bf"
+dependencies = [
+ "autocfg",
+ "num-integer",
+ "num-traits",
+]
+
+[[package]]
+name = "num-rational"
+version = "0.4.2"
+source = "registry+https:/rust-lang/crates.io-index"
+checksum = "f83d14da390562dca69fc84082e73e548e1ad308d24accdedd2720017cb37824"
+dependencies = [
+ "num-bigint",
+ "num-integer",
+ "num-traits",
+]
+
 [[package]]
 name = "num-traits"
 version = "0.2.19"
@@ -5630,6 +5694,17 @@ dependencies = [
  "std",
 ]
 
+[[package]]
+name = "test-float-parse"
+version = "0.1.0"
+dependencies = [
+ "indicatif",
+ "num",
+ "rand",
+ "rand_chacha",
+ "rayon",
+]
+
 [[package]]
 name = "textwrap"
 version = "0.16.1"

Cargo.toml

@@ -4,6 +4,7 @@ members = [
  "compiler/rustc",
  "library/std",
  "library/sysroot",
+ "src/etc/test-float-parse",
  "src/rustdoc-json-types",
  "src/tools/build_helper",
  "src/tools/cargotest",
@@ -109,6 +110,18 @@ strip = true
 debug = 0
 strip = true
 
+# Bigint libraries are slow without optimization, speed up testing
+[profile.dev.package.test-float-parse]
+opt-level = 3
+
+# Speed up the binary as much as possible
+[profile.release.package.test-float-parse]
+opt-level = 3
+codegen-units = 1
+# FIXME: LTO cannot be enabled for binaries in a workspace
+# <https:/rust-lang/cargo/issues/9330>
+# lto = true
+
 [patch.crates-io]
 # See comments in `library/rustc-std-workspace-core/README.md` for what's going on
 # here

compiler/rustc_ast_passes/messages.ftl

@@ -120,6 +120,9 @@ ast_passes_fn_without_body =
 ast_passes_forbidden_bound =
  bounds cannot be used in this context
 
+ast_passes_forbidden_const_param =
+ late-bound const parameters cannot be used currently
+
 ast_passes_forbidden_default =
  `default` is only allowed on items in trait impls
  .label = `default` because of this

compiler/rustc_ast_passes/src/errors.rs

@@ -69,6 +69,13 @@ pub struct ForbiddenBound {
  pub spans: Vec<Span>,
 }
 
+#[derive(Diagnostic)]
+#[diag(ast_passes_forbidden_const_param)]
+pub struct ForbiddenConstParam {
+ #[primary_span]
+ pub const_param_spans: Vec<Span>,
+}
+
 #[derive(Diagnostic)]
 #[diag(ast_passes_fn_param_too_many)]
 pub struct FnParamTooMany {

compiler/rustc_ast_passes/src/feature_gate.rs

@@ -162,6 +162,22 @@ impl<'a> PostExpansionVisitor<'a> {
  crate::fluent_generated::ast_passes_forbidden_non_lifetime_param
  );
 
+ // FIXME(non_lifetime_binders): Const bound params are pretty broken.
+ // Let's keep users from using this feature accidentally.
+ if self.features.non_lifetime_binders {
+ let const_param_spans: Vec<_> = params
+ .iter()
+ .filter_map(|param| match param.kind {
+ ast::GenericParamKind::Const { .. } => Some(param.ident.span),
+ _ => None,
+ })
+ .collect();
+
+ if !const_param_spans.is_empty() {
+ self.sess.dcx().emit_err(errors::ForbiddenConstParam { const_param_spans });
+ }
+ }
+
  for param in params {
  if !param.bounds.is_empty() {
  let spans: Vec<_> = param.bounds.iter().map(|b| b.span()).collect();

compiler/rustc_hir_analysis/src/collect/resolve_bound_vars.rs

@@ -2094,11 +2094,7 @@ pub fn deny_non_region_late_bound(
  format!("late-bound {what} parameter not allowed on {where_}"),
  );
 
- let guar = if tcx.features().non_lifetime_binders && first {
- diag.emit()
- } else {
- diag.delay_as_bug()
- };
+ let guar = diag.emit_unless(!tcx.features().non_lifetime_binders || !first);
 
  first = false;
  *arg = ResolvedArg::Error(guar);

compiler/rustc_mir_build/src/thir/pattern/check_match.rs

@@ -16,8 +16,8 @@ use rustc_middle::ty::print::with_no_trimmed_paths;
 use rustc_middle::ty::{self, AdtDef, Ty, TyCtxt};
 use rustc_pattern_analysis::errors::Uncovered;
 use rustc_pattern_analysis::rustc::{
- Constructor, DeconstructedPat, MatchArm, RustcPatCtxt as PatCtxt, Usefulness, UsefulnessReport,
- WitnessPat,
+ Constructor, DeconstructedPat, MatchArm, RevealedTy, RustcPatCtxt as PatCtxt, Usefulness,
+ UsefulnessReport, WitnessPat,
 };
 use rustc_session::lint::builtin::{
  BINDINGS_WITH_VARIANT_NAME, IRREFUTABLE_LET_PATTERNS, UNREACHABLE_PATTERNS,
@@ -998,27 +998,31 @@ fn report_non_exhaustive_match<'p, 'tcx>(
  err.note(format!("the matched value is of type `{}`", scrut_ty));
 
  if !is_empty_match {
- let mut non_exhaustive_tys = FxIndexSet::default();
+ let mut special_tys = FxIndexSet::default();
  // Look at the first witness.
- collect_non_exhaustive_tys(cx, &witnesses[0], &mut non_exhaustive_tys);
+ collect_special_tys(cx, &witnesses[0], &mut special_tys);
 
- for ty in non_exhaustive_tys {
+ for ty in special_tys {
  if ty.is_ptr_sized_integral() {
- if ty == cx.tcx.types.usize {
+ if ty.inner() == cx.tcx.types.usize {
  err.note(format!(
  "`{ty}` does not have a fixed maximum value, so half-open ranges are necessary to match \
  exhaustively",
  ));
- } else if ty == cx.tcx.types.isize {
+ } else if ty.inner() == cx.tcx.types.isize {
  err.note(format!(
  "`{ty}` does not have fixed minimum and maximum values, so half-open ranges are necessary to match \
  exhaustively",
  ));
  }
- } else if ty == cx.tcx.types.str_ {
+ } else if ty.inner() == cx.tcx.types.str_ {
  err.note("`&str` cannot be matched exhaustively, so a wildcard `_` is necessary");
- } else if cx.is_foreign_non_exhaustive_enum(cx.reveal_opaque_ty(ty)) {
+ } else if cx.is_foreign_non_exhaustive_enum(ty) {
  err.note(format!("`{ty}` is marked as non-exhaustive, so a wildcard `_` is necessary to match exhaustively"));
+ } else if cx.is_uninhabited(ty.inner()) && cx.tcx.features().min_exhaustive_patterns {
+ // The type is uninhabited yet there is a witness: we must be in the `MaybeInvalid`
+ // case.
+ err.note(format!("`{ty}` is uninhabited but is not being matched by value, so a wildcard `_` is required"));
  }
  }
  }
@@ -1168,22 +1172,22 @@ fn joined_uncovered_patterns<'p, 'tcx>(
  }
 }
 
-fn collect_non_exhaustive_tys<'tcx>(
+/// Collect types that require specific explanations when they show up in witnesses.
+fn collect_special_tys<'tcx>(
  cx: &PatCtxt<'_, 'tcx>,
  pat: &WitnessPat<'_, 'tcx>,
- non_exhaustive_tys: &mut FxIndexSet<Ty<'tcx>>,
+ special_tys: &mut FxIndexSet<RevealedTy<'tcx>>,
 ) {
- if matches!(pat.ctor(), Constructor::NonExhaustive) {
- non_exhaustive_tys.insert(pat.ty().inner());
+ if matches!(pat.ctor(), Constructor::NonExhaustive | Constructor::Never) {
+ special_tys.insert(*pat.ty());
  }
  if let Constructor::IntRange(range) = pat.ctor() {
  if cx.is_range_beyond_boundaries(range, *pat.ty()) {
  // The range denotes the values before `isize::MIN` or the values after `usize::MAX`/`isize::MAX`.
- non_exhaustive_tys.insert(pat.ty().inner());
+ special_tys.insert(*pat.ty());
  }
  }
- pat.iter_fields()
- .for_each(|field_pat| collect_non_exhaustive_tys(cx, field_pat, non_exhaustive_tys))
+ pat.iter_fields().for_each(|field_pat| collect_special_tys(cx, field_pat, special_tys))
 }
 
 fn report_adt_defined_here<'tcx>(

compiler/rustc_pattern_analysis/src/rustc.rs

@@ -40,9 +40,15 @@ pub type WitnessPat<'p, 'tcx> = crate::pat::WitnessPat<RustcPatCtxt<'p, 'tcx>>;
 ///
 /// Use `.inner()` or deref to get to the `Ty<'tcx>`.
 #[repr(transparent)]
-#[derive(Clone, Copy)]
+#[derive(Clone, Copy, PartialEq, Eq, Hash)]
 pub struct RevealedTy<'tcx>(Ty<'tcx>);
 
+impl<'tcx> fmt::Display for RevealedTy<'tcx> {
+ fn fmt(&self, fmt: &mut fmt::Formatter<'_>) -> fmt::Result {
+ self.0.fmt(fmt)
+ }
+}
+
 impl<'tcx> fmt::Debug for RevealedTy<'tcx> {
  fn fmt(&self, fmt: &mut fmt::Formatter<'_>) -> fmt::Result {
  self.0.fmt(fmt)

compiler/rustc_resolve/src/late.rs

@@ -2763,7 +2763,11 @@ impl<'a: 'ast, 'b, 'ast, 'tcx> LateResolutionVisitor<'a, 'b, 'ast, 'tcx> {
  let res = match kind {
  RibKind::Item(..) | RibKind::AssocItem => Res::Def(def_kind, def_id.to_def_id()),
  RibKind::Normal => {
- if self.r.tcx.features().non_lifetime_binders {
+ // FIXME(non_lifetime_binders): Stop special-casing
+ // const params to error out here.
+ if self.r.tcx.features().non_lifetime_binders
+ && matches!(param.kind, GenericParamKind::Type { .. })
+ {
  Res::Def(def_kind, def_id.to_def_id())
  } else {
  Res::Err

library/std/src/sys/pal/unix/net.rs

@@ -4,7 +4,6 @@ use crate::io::{self, BorrowedBuf, BorrowedCursor, IoSlice, IoSliceMut};
 use crate::mem;
 use crate::net::{Shutdown, SocketAddr};
 use crate::os::unix::io::{AsFd, AsRawFd, BorrowedFd, FromRawFd, IntoRawFd, RawFd};
-use crate::str;
 use crate::sys::fd::FileDesc;
 use crate::sys::pal::unix::IsMinusOne;
 use crate::sys_common::net::{getsockopt, setsockopt, sockaddr_to_addr};
@@ -47,7 +46,9 @@ pub fn cvt_gai(err: c_int) -> io::Result<()> {
 
  #[cfg(not(target_os = "espidf"))]
  let detail = unsafe {
- str::from_utf8(CStr::from_ptr(libc::gai_strerror(err)).to_bytes()).unwrap().to_owned()
+ // We can't always expect a UTF-8 environment. When we don't get that luxury,
+ // it's better to give a low-quality error message than none at all.
+ CStr::from_ptr(libc::gai_strerror(err)).to_string_lossy()
  };
 
  #[cfg(target_os = "espidf")]

src/bootstrap/mk/Makefile.in

@@ -51,6 +51,7 @@ check-aux:
  $(Q)$(BOOTSTRAP) test --stage 2 \
  src/tools/cargo \
  src/tools/cargotest \
+ src/etc/test-float-parse \
  $(BOOTSTRAP_ARGS)
  # Run standard library tests in Miri.
  $(Q)BOOTSTRAP_SKIP_TARGET_SANITY=1 \

src/bootstrap/src/core/build_steps/check.rs

@@ -466,6 +466,7 @@ tool_check_step!(CargoMiri, "src/tools/miri/cargo-miri", SourceType::InTree);
 tool_check_step!(Rls, "src/tools/rls", SourceType::InTree);
 tool_check_step!(Rustfmt, "src/tools/rustfmt", SourceType::InTree);
 tool_check_step!(MiroptTestTools, "src/tools/miropt-test-tools", SourceType::InTree);
+tool_check_step!(TestFloatParse, "src/etc/test-float-parse", SourceType::InTree);
 
 tool_check_step!(Bootstrap, "src/bootstrap", SourceType::InTree, false);
 

src/bootstrap/src/core/build_steps/clippy.rs

@@ -326,4 +326,5 @@ lint_any!(
  Rustfmt, "src/tools/rustfmt", "rustfmt";
  RustInstaller, "src/tools/rust-installer", "rust-installer";
  Tidy, "src/tools/tidy", "tidy";
+ TestFloatParse, "src/etc/test-float-parse", "test-float-parse";
 );