Auto merge of #126838 - matthiaskrgr:rollup-qkop22o, r=matthiaskrgr

Rollup of 3 pull requests

Successful merges:

 - #126140 (Rename `std::fs::try_exists` to  `std::fs::exists` and stabilize fs_try_exists)
 - #126318 (Add a `x perf` command for integrating bootstrap with `rustc-perf`)
 - #126552 (Remove use of const traits (and `feature(effects)`) from stdlib)

r? `@ghost`
`@rustbot` modify labels: rollup

compiler/rustc_feature/src/unstable.rs

@@ -449,7 +449,7 @@ declare_features! (
  /// Allows `dyn* Trait` objects.
  (incomplete, dyn_star, "1.65.0", Some(102425)),
  /// Uses generic effect parameters for ~const bounds
- (unstable, effects, "1.72.0", Some(102090)),
+ (incomplete, effects, "1.72.0", Some(102090)),
  /// Allows exhaustive pattern matching on types that contain uninhabited types.
  (unstable, exhaustive_patterns, "1.13.0", Some(51085)),
  /// Allows explicit tail calls via `become` expression.

compiler/rustc_hir_analysis/src/check/intrinsic.rs

@@ -429,17 +429,17 @@ pub fn check_intrinsic_type(
 
  sym::ptr_guaranteed_cmp => (
  1,
- 1,
+ 0,
  vec![Ty::new_imm_ptr(tcx, param(0)), Ty::new_imm_ptr(tcx, param(0))],
  tcx.types.u8,
  ),
 
  sym::const_allocate => {
- (0, 1, vec![tcx.types.usize, tcx.types.usize], Ty::new_mut_ptr(tcx, tcx.types.u8))
+ (0, 0, vec![tcx.types.usize, tcx.types.usize], Ty::new_mut_ptr(tcx, tcx.types.u8))
  }
  sym::const_deallocate => (
  0,
- 1,
+ 0,
  vec![Ty::new_mut_ptr(tcx, tcx.types.u8), tcx.types.usize, tcx.types.usize],
  tcx.types.unit,
  ),
@@ -478,16 +478,16 @@ pub fn check_intrinsic_type(
  | sym::frem_algebraic => (1, 0, vec![param(0), param(0)], param(0)),
  sym::float_to_int_unchecked => (2, 0, vec![param(0)], param(1)),
 
- sym::assume => (0, 1, vec![tcx.types.bool], tcx.types.unit),
- sym::likely => (0, 1, vec![tcx.types.bool], tcx.types.bool),
- sym::unlikely => (0, 1, vec![tcx.types.bool], tcx.types.bool),
+ sym::assume => (0, 0, vec![tcx.types.bool], tcx.types.unit),
+ sym::likely => (0, 0, vec![tcx.types.bool], tcx.types.bool),
+ sym::unlikely => (0, 0, vec![tcx.types.bool], tcx.types.bool),
 
  sym::read_via_copy => (1, 0, vec![Ty::new_imm_ptr(tcx, param(0))], param(0)),
  sym::write_via_move => {
  (1, 0, vec![Ty::new_mut_ptr(tcx, param(0)), param(0)], tcx.types.unit)
  }
 
- sym::typed_swap => (1, 1, vec![Ty::new_mut_ptr(tcx, param(0)); 2], tcx.types.unit),
+ sym::typed_swap => (1, 0, vec![Ty::new_mut_ptr(tcx, param(0)); 2], tcx.types.unit),
 
  sym::discriminant_value => {
  let assoc_items = tcx.associated_item_def_ids(
@@ -566,20 +566,20 @@ pub fn check_intrinsic_type(
 
  sym::black_box => (1, 0, vec![param(0)], param(0)),
 
- sym::is_val_statically_known => (1, 1, vec![param(0)], tcx.types.bool),
+ sym::is_val_statically_known => (1, 0, vec![param(0)], tcx.types.bool),
 
- sym::const_eval_select => (4, 1, vec![param(0), param(1), param(2)], param(3)),
+ sym::const_eval_select => (4, 0, vec![param(0), param(1), param(2)], param(3)),
 
  sym::vtable_size | sym::vtable_align => {
  (0, 0, vec![Ty::new_imm_ptr(tcx, tcx.types.unit)], tcx.types.usize)
  }
 
  // This type check is not particularly useful, but the `where` bounds
  // on the definition in `core` do the heavy lifting for checking it.
- sym::aggregate_raw_ptr => (3, 1, vec![param(1), param(2)], param(0)),
- sym::ptr_metadata => (2, 1, vec![Ty::new_imm_ptr(tcx, param(0))], param(1)),
+ sym::aggregate_raw_ptr => (3, 0, vec![param(1), param(2)], param(0)),
+ sym::ptr_metadata => (2, 0, vec![Ty::new_imm_ptr(tcx, param(0))], param(1)),
 
- sym::ub_checks => (0, 1, Vec::new(), tcx.types.bool),
+ sym::ub_checks => (0, 0, Vec::new(), tcx.types.bool),
 
  sym::simd_eq
  | sym::simd_ne

library/alloc/src/lib.rs

@@ -176,7 +176,6 @@
 #![feature(const_mut_refs)]
 #![feature(const_precise_live_drops)]
 #![feature(const_ptr_write)]
-#![feature(const_trait_impl)]
 #![feature(const_try)]
 #![feature(decl_macro)]
 #![feature(dropck_eyepatch)]

library/core/src/cmp.rs

@@ -245,7 +245,6 @@ use self::Ordering::*;
  append_const_msg
 )]
 #[rustc_diagnostic_item = "PartialEq"]
-#[const_trait]
 pub trait PartialEq<Rhs: ?Sized = Self> {
  /// This method tests for `self` and `other` values to be equal, and is used
  /// by `==`.
@@ -1475,8 +1474,7 @@ mod impls {
  macro_rules! partial_eq_impl {
  ($($t:ty)*) => ($(
  #[stable(feature = "rust1", since = "1.0.0")]
- #[rustc_const_unstable(feature = "const_cmp", issue = "92391")]
- impl const PartialEq for $t {
+ impl PartialEq for $t {
  #[inline]
  fn eq(&self, other: &$t) -> bool { (*self) == (*other) }
  #[inline]

library/core/src/escape.rs

@@ -60,7 +60,7 @@ const fn escape_ascii<const N: usize>(byte: u8) -> ([ascii::Char; N], Range<u8>)
 const fn escape_unicode<const N: usize>(c: char) -> ([ascii::Char; N], Range<u8>) {
  const { assert!(N >= 10 && N < u8::MAX as usize) };
 
- let c = u32::from(c);
+ let c = c as u32;
 
  // OR-ing `1` ensures that for `c == 0` the code computes that
  // one digit should be printed.

library/core/src/ffi/c_str.rs

@@ -515,7 +515,10 @@ impl CStr {
  #[inline]
  #[must_use]
  const fn as_non_null_ptr(&self) -> NonNull<c_char> {
- NonNull::from(&self.inner).as_non_null_ptr()
+ // FIXME(effects) replace with `NonNull::from`
+ // SAFETY: a reference is never null
+ unsafe { NonNull::new_unchecked(&self.inner as *const [c_char] as *mut [c_char]) }
+ .as_non_null_ptr()
  }
 
  /// Returns the length of `self`. Like C's `strlen`, this does not include the nul terminator.

library/core/src/lib.rs

@@ -200,6 +200,7 @@
 // Language features:
 // tidy-alphabetical-start
 #![cfg_attr(bootstrap, feature(c_unwind))]
+#![cfg_attr(bootstrap, feature(effects))]
 #![feature(abi_unadjusted)]
 #![feature(adt_const_params)]
 #![feature(allow_internal_unsafe)]
@@ -214,13 +215,11 @@
 #![feature(const_mut_refs)]
 #![feature(const_precise_live_drops)]
 #![feature(const_refs_to_cell)]
-#![feature(const_trait_impl)]
 #![feature(decl_macro)]
 #![feature(deprecated_suggestion)]
 #![feature(doc_cfg)]
 #![feature(doc_cfg_hide)]
 #![feature(doc_notable_trait)]
-#![feature(effects)]
 #![feature(extern_types)]
 #![feature(f128)]
 #![feature(f16)]

library/core/src/marker.rs

@@ -944,7 +944,6 @@ marker_impls! {
 #[lang = "destruct"]
 #[rustc_on_unimplemented(message = "can't drop `{Self}`", append_const_msg)]
 #[rustc_deny_explicit_impl(implement_via_object = false)]
-#[const_trait]
 pub trait Destruct {}
 
 /// A marker for tuple types.

library/core/src/num/nonzero.rs

@@ -33,7 +33,6 @@ use super::{IntErrorKind, ParseIntError};
  reason = "implementation detail which may disappear or be replaced at any time",
  issue = "none"
 )]
-#[const_trait]
 pub unsafe trait ZeroablePrimitive: Sized + Copy + private::Sealed {
  #[doc(hidden)]
  type NonZeroInner: Sized + Copy;
@@ -47,7 +46,6 @@ macro_rules! impl_zeroable_primitive {
  reason = "implementation detail which may disappear or be replaced at any time",
  issue = "none"
  )]
- #[const_trait]
  pub trait Sealed {}
 
  $(
@@ -70,14 +68,14 @@ macro_rules! impl_zeroable_primitive {
  reason = "implementation detail which may disappear or be replaced at any time",
  issue = "none"
  )]
- impl const private::Sealed for $primitive {}
+ impl private::Sealed for $primitive {}
 
  #[unstable(
  feature = "nonzero_internals",
  reason = "implementation detail which may disappear or be replaced at any time",
  issue = "none"
  )]
- unsafe impl const ZeroablePrimitive for $primitive {
+ unsafe impl ZeroablePrimitive for $primitive {
  type NonZeroInner = private::$NonZeroInner;
  }
  )+

library/core/src/ops/arith.rs

@@ -73,7 +73,6 @@
  append_const_msg
 )]
 #[doc(alias = "+")]
-#[const_trait]
 pub trait Add<Rhs = Self> {
  /// The resulting type after applying the `+` operator.
  #[stable(feature = "rust1", since = "1.0.0")]
@@ -95,8 +94,7 @@ pub trait Add<Rhs = Self> {
 macro_rules! add_impl {
  ($($t:ty)*) => ($(
  #[stable(feature = "rust1", since = "1.0.0")]
- #[rustc_const_unstable(feature = "const_ops", issue = "90080")]
- impl const Add for $t {
+ impl Add for $t {
  type Output = $t;
 
  #[inline]

library/core/src/task/wake.rs

@@ -282,7 +282,7 @@ impl<'a> Context<'a> {
  pub const fn ext(&mut self) -> &mut dyn Any {
  // FIXME: this field makes Context extra-weird about unwind safety
  // can we justify AssertUnwindSafe if we stabilize this? do we care?
- match &mut *self.ext {
+ match &mut self.ext.0 {
  ExtData::Some(data) => *data,
  ExtData::None(unit) => unit,
  }
@@ -356,7 +356,7 @@ impl<'a> ContextBuilder<'a> {
  #[rustc_const_unstable(feature = "const_waker", issue = "102012")]
  #[unstable(feature = "context_ext", issue = "123392")]
  pub const fn from(cx: &'a mut Context<'_>) -> Self {
- let ext = match &mut *cx.ext {
+ let ext = match &mut cx.ext.0 {
  ExtData::Some(ext) => ExtData::Some(*ext),
  ExtData::None(()) => ExtData::None(()),
  };

library/std/src/fs.rs

@@ -2742,18 +2742,15 @@ impl AsInnerMut<fs_imp::DirBuilder> for DirBuilder {
 /// # Examples
 ///
 /// ```no_run
-/// #![feature(fs_try_exists)]
 /// use std::fs;
 ///
-/// assert!(!fs::try_exists("does_not_exist.txt").expect("Can't check existence of file does_not_exist.txt"));
-/// assert!(fs::try_exists("/root/secret_file.txt").is_err());
+/// assert!(!fs::exists("does_not_exist.txt").expect("Can't check existence of file does_not_exist.txt"));
+/// assert!(fs::exists("/root/secret_file.txt").is_err());
 /// ```
 ///
 /// [`Path::exists`]: crate::path::Path::exists
-// FIXME: stabilization should modify documentation of `exists()` to recommend this method
-// instead.
-#[unstable(feature = "fs_try_exists", issue = "83186")]
+#[stable(feature = "fs_try_exists", since = "CURRENT_RUSTC_VERSION")]
 #[inline]
-pub fn try_exists<P: AsRef<Path>>(path: P) -> io::Result<bool> {
- fs_imp::try_exists(path.as_ref())
+pub fn exists<P: AsRef<Path>>(path: P) -> io::Result<bool> {
+ fs_imp::exists(path.as_ref())
 }

library/std/src/lib.rs

@@ -284,7 +284,6 @@
 #![feature(cfi_encoding)]
 #![feature(concat_idents)]
 #![feature(const_mut_refs)]
-#![feature(const_trait_impl)]
 #![feature(decl_macro)]
 #![feature(deprecated_suggestion)]
 #![feature(doc_cfg)]

library/std/src/path.rs

@@ -2907,6 +2907,8 @@ impl Path {
  /// prevent time-of-check to time-of-use (TOCTOU) bugs. You should only use it in scenarios
  /// where those bugs are not an issue.
  ///
+ /// This is an alias for [`std::fs::exists`](crate::fs::exists).
+ ///
  /// # Examples
  ///
  /// ```no_run
@@ -2919,7 +2921,7 @@ impl Path {
  #[stable(feature = "path_try_exists", since = "1.63.0")]
  #[inline]
  pub fn try_exists(&self) -> io::Result<bool> {
- fs::try_exists(self)
+ fs::exists(self)
  }
 
  /// Returns `true` if the path exists on disk and is pointing at a regular file.

library/std/src/sys/pal/hermit/fs.rs

@@ -18,7 +18,7 @@ use crate::sys::time::SystemTime;
 use crate::sys::unsupported;
 use crate::sys_common::{AsInner, AsInnerMut, FromInner, IntoInner};
 
-pub use crate::sys_common::fs::{copy, try_exists};
+pub use crate::sys_common::fs::{copy, exists};
 
 #[derive(Debug)]
 pub struct File(FileDesc);

library/std/src/sys/pal/solid/fs.rs

@@ -12,7 +12,7 @@ use crate::{
  sys::unsupported,
 };
 
-pub use crate::sys_common::fs::try_exists;
+pub use crate::sys_common::fs::exists;
 
 /// A file descriptor.
 #[derive(Clone, Copy)]

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

@@ -97,7 +97,7 @@ use libc::{
 ))]
 use libc::{dirent64, fstat64, ftruncate64, lseek64, lstat64, off64_t, open64, stat64};
 
-pub use crate::sys_common::fs::try_exists;
+pub use crate::sys_common::fs::exists;
 
 pub struct File(FileDesc);
 

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

@@ -478,7 +478,7 @@ mod cgroups {
 
  use crate::borrow::Cow;
  use crate::ffi::OsString;
- use crate::fs::{try_exists, File};
+ use crate::fs::{exists, File};
  use crate::io::Read;
  use crate::io::{BufRead, BufReader};
  use crate::os::unix::ffi::OsStringExt;
@@ -556,7 +556,7 @@ mod cgroups {
  path.push("cgroup.controllers");
 
  // skip if we're not looking at cgroup2
- if matches!(try_exists(&path), Err(_) | Ok(false)) {
+ if matches!(exists(&path), Err(_) | Ok(false)) {
  return usize::MAX;
  };
 
@@ -613,7 +613,7 @@ mod cgroups {
  path.push(&group_path);
 
  // skip if we guessed the mount incorrectly
- if matches!(try_exists(&path), Err(_) | Ok(false)) {
+ if matches!(exists(&path), Err(_) | Ok(false)) {
  continue;
  }
 

library/std/src/sys/pal/unsupported/fs.rs

@@ -291,7 +291,7 @@ pub fn remove_dir_all(_path: &Path) -> io::Result<()> {
  unsupported()
 }
 
-pub fn try_exists(_path: &Path) -> io::Result<bool> {
+pub fn exists(_path: &Path) -> io::Result<bool> {
  unsupported()
 }
 

library/std/src/sys/pal/wasi/fs.rs

@@ -17,7 +17,7 @@ use crate::sys::time::SystemTime;
 use crate::sys::unsupported;
 use crate::sys_common::{AsInner, FromInner, IntoInner};
 
-pub use crate::sys_common::fs::try_exists;
+pub use crate::sys_common::fs::exists;
 
 pub struct File {
  fd: WasiFd,

library/std/src/sys/pal/windows/fs.rs

@@ -1531,7 +1531,7 @@ pub fn junction_point(original: &Path, link: &Path) -> io::Result<()> {
 }
 
 // Try to see if a file exists but, unlike `exists`, report I/O errors.
-pub fn try_exists(path: &Path) -> io::Result<bool> {
+pub fn exists(path: &Path) -> io::Result<bool> {
  // Open the file to ensure any symlinks are followed to their target.
  let mut opts = OpenOptions::new();
  // No read, write, etc access rights are needed.

library/std/src/sys_common/fs.rs

@@ -42,7 +42,7 @@ fn remove_dir_all_recursive(path: &Path) -> io::Result<()> {
  fs::remove_dir(path)
 }
 
-pub fn try_exists(path: &Path) -> io::Result<bool> {
+pub fn exists(path: &Path) -> io::Result<bool> {
  match fs::metadata(path) {
  Ok(_) => Ok(true),
  Err(error) if error.kind() == io::ErrorKind::NotFound => Ok(false),

src/bootstrap/src/core/build_steps/mod.rs

@@ -7,6 +7,7 @@ pub(crate) mod doc;
 pub(crate) mod format;
 pub(crate) mod install;
 pub(crate) mod llvm;
+pub(crate) mod perf;
 pub(crate) mod run;
 pub(crate) mod setup;
 pub(crate) mod suggest;