Master bootstrap update

compiler/rustc_data_structures/src/flock.rs

@@ -4,31 +4,6 @@
 //! green/native threading. This is just a bare-bones enough solution for
 //! librustdoc, it is not production quality at all.
 
-#[cfg(bootstrap)]
-cfg_match! {
-    cfg(target_os = "linux") => {
-        mod linux;
-        use linux as imp;
-    }
-    cfg(target_os = "redox") => {
-        mod linux;
-        use linux as imp;
-    }
-    cfg(unix) => {
-        mod unix;
-        use unix as imp;
-    }
-    cfg(windows) => {
-        mod windows;
-        use self::windows as imp;
-    }
-    _ => {
-        mod unsupported;
-        use unsupported as imp;
-    }
-}
-
-#[cfg(not(bootstrap))]
 cfg_match! {
     target_os = "linux" => {
         mod linux;

compiler/rustc_data_structures/src/profiling.rs

@@ -860,69 +860,6 @@ fn get_thread_id() -> u32 {
 }
 
 // Memory reporting
-#[cfg(bootstrap)]
-cfg_match! {
-    cfg(windows) => {
-        pub fn get_resident_set_size() -> Option<usize> {
-            use std::mem;
-
-            use windows::{
-                Win32::System::ProcessStatus::{K32GetProcessMemoryInfo, PROCESS_MEMORY_COUNTERS},
-                Win32::System::Threading::GetCurrentProcess,
-            };
-
-            let mut pmc = PROCESS_MEMORY_COUNTERS::default();
-            let pmc_size = mem::size_of_val(&pmc);
-            unsafe {
-                K32GetProcessMemoryInfo(
-                    GetCurrentProcess(),
-                    &mut pmc,
-                    pmc_size as u32,
-                )
-            }
-            .ok()
-            .ok()?;
-
-            Some(pmc.WorkingSetSize)
-        }
-    }
-    cfg(target_os = "macos")  => {
-        pub fn get_resident_set_size() -> Option<usize> {
-            use libc::{c_int, c_void, getpid, proc_pidinfo, proc_taskinfo, PROC_PIDTASKINFO};
-            use std::mem;
-            const PROC_TASKINFO_SIZE: c_int = mem::size_of::<proc_taskinfo>() as c_int;
-
-            unsafe {
-                let mut info: proc_taskinfo = mem::zeroed();
-                let info_ptr = &mut info as *mut proc_taskinfo as *mut c_void;
-                let pid = getpid() as c_int;
-                let ret = proc_pidinfo(pid, PROC_PIDTASKINFO, 0, info_ptr, PROC_TASKINFO_SIZE);
-                if ret == PROC_TASKINFO_SIZE {
-                    Some(info.pti_resident_size as usize)
-                } else {
-                    None
-                }
-            }
-        }
-    }
-    cfg(unix) => {
-        pub fn get_resident_set_size() -> Option<usize> {
-            let field = 1;
-            let contents = fs::read("/proc/self/statm").ok()?;
-            let contents = String::from_utf8(contents).ok()?;
-            let s = contents.split_whitespace().nth(field)?;
-            let npages = s.parse::<usize>().ok()?;
-            Some(npages * 4096)
-        }
-    }
-    _ => {
-        pub fn get_resident_set_size() -> Option<usize> {
-            None
-        }
-    }
-}
-
-#[cfg(not(bootstrap))]
 cfg_match! {
     windows => {
         pub fn get_resident_set_size() -> Option<usize> {

compiler/rustc_feature/src/accepted.rs

@@ -387,7 +387,7 @@ declare_features! (
     /// Allows `#[target_feature(...)]`.
     (accepted, target_feature, "1.27.0", None),
     /// Allows the use of `#[target_feature]` on safe functions.
-    (accepted, target_feature_11, "CURRENT_RUSTC_VERSION", Some(69098)),
+    (accepted, target_feature_11, "1.86.0", Some(69098)),
     /// Allows `fn main()` with return types which implements `Termination` (RFC 1937).
     (accepted, termination_trait, "1.26.0", Some(43301)),
     /// Allows `#[test]` functions where the return type implements `Termination` (RFC 1937).
@@ -401,7 +401,7 @@ declare_features! (
     (accepted, track_caller, "1.46.0", Some(47809)),
     /// Allows dyn upcasting trait objects via supertraits.
     /// Dyn upcasting is casting, e.g., `dyn Foo -> dyn Bar` where `Foo: Bar`.
-    (accepted, trait_upcasting, "CURRENT_RUSTC_VERSION", Some(65991)),
+    (accepted, trait_upcasting, "1.86.0", Some(65991)),
     /// Allows #[repr(transparent)] on univariant enums (RFC 2645).
     (accepted, transparent_enums, "1.42.0", Some(60405)),
     /// Allows indexing tuples.

compiler/rustc_feature/src/unstable.rs

@@ -203,7 +203,7 @@ declare_features! (
     /// Allows using anonymous lifetimes in argument-position impl-trait.
     (unstable, anonymous_lifetime_in_impl_trait, "1.63.0", None),
     /// Allows access to the emscripten_wasm_eh config, used by panic_unwind and unwind
-    (internal, cfg_emscripten_wasm_eh, "CURRENT_RUSTC_VERSION", None),
+    (internal, cfg_emscripten_wasm_eh, "1.86.0", None),
     /// Allows identifying the `compiler_builtins` crate.
     (internal, compiler_builtins, "1.13.0", None),
     /// Allows writing custom MIR
@@ -360,7 +360,7 @@ declare_features! (
     /// Allows `extern "C-cmse-nonsecure-call" fn()`.
     (unstable, abi_c_cmse_nonsecure_call, "1.51.0", Some(81391)),
     /// Allows `extern "gpu-kernel" fn()`.
-    (unstable, abi_gpu_kernel, "CURRENT_RUSTC_VERSION", Some(135467)),
+    (unstable, abi_gpu_kernel, "1.86.0", Some(135467)),
     /// Allows `extern "msp430-interrupt" fn()`.
     (unstable, abi_msp430_interrupt, "1.16.0", Some(38487)),
     /// Allows `extern "ptx-*" fn()`.
@@ -404,7 +404,7 @@ declare_features! (
     /// Allows the use of `#[cfg(<true/false>)]`.
     (unstable, cfg_boolean_literals, "1.83.0", Some(131204)),
     /// Allows the use of `#[cfg(contract_checks)` to check if contract checks are enabled.
-    (unstable, cfg_contract_checks, "CURRENT_RUSTC_VERSION", Some(128044)),
+    (unstable, cfg_contract_checks, "1.86.0", Some(128044)),
     /// Allows the use of `#[cfg(overflow_checks)` to check if integer overflow behaviour.
     (unstable, cfg_overflow_checks, "1.71.0", Some(111466)),
     /// Provides the relocation model information as cfg entry
@@ -448,9 +448,9 @@ declare_features! (
     /// Allows the `?` operator in const contexts.
     (unstable, const_try, "1.56.0", Some(74935)),
     /// Allows use of contracts attributes.
-    (incomplete, contracts, "CURRENT_RUSTC_VERSION", Some(128044)),
+    (incomplete, contracts, "1.86.0", Some(128044)),
     /// Allows access to internal machinery used to implement contracts.
-    (internal, contracts_internals, "CURRENT_RUSTC_VERSION", Some(128044)),
+    (internal, contracts_internals, "1.86.0", Some(128044)),
     /// Allows coroutines to be cloned.
     (unstable, coroutine_clone, "1.65.0", Some(95360)),
     /// Allows defining coroutines.
@@ -491,7 +491,7 @@ declare_features! (
     /// for functions with varargs.
     (unstable, extended_varargs_abi_support, "1.65.0", Some(100189)),
     /// Allows using `system` as a calling convention with varargs.
-    (unstable, extern_system_varargs, "CURRENT_RUSTC_VERSION", Some(136946)),
+    (unstable, extern_system_varargs, "1.86.0", Some(136946)),
     /// Allows defining `extern type`s.
     (unstable, extern_types, "1.23.0", Some(43467)),
     /// Allow using 128-bit (quad precision) floating point numbers.
@@ -519,7 +519,7 @@ declare_features! (
     /// Allows generic parameters and where-clauses on free & associated const items.
     (incomplete, generic_const_items, "1.73.0", Some(113521)),
     /// Allows any generic constants being used as pattern type range ends
-    (incomplete, generic_pattern_types, "CURRENT_RUSTC_VERSION", Some(136574)),
+    (incomplete, generic_pattern_types, "1.86.0", Some(136574)),
     /// Allows registering static items globally, possibly across crates, to iterate over at runtime.
     (unstable, global_registration, "1.80.0", Some(125119)),
     /// Allows using guards in patterns.
@@ -535,15 +535,15 @@ declare_features! (
     /// Allows `impl Trait` as output type in `Fn` traits in return position of functions.
     (unstable, impl_trait_in_fn_trait_return, "1.64.0", Some(99697)),
     /// Allows `use` associated functions from traits.
-    (unstable, import_trait_associated_functions, "CURRENT_RUSTC_VERSION", Some(134691)),
+    (unstable, import_trait_associated_functions, "1.86.0", Some(134691)),
     /// Allows associated types in inherent impls.
     (incomplete, inherent_associated_types, "1.52.0", Some(8995)),
     /// Allow anonymous constants from an inline `const` block in pattern position
     (unstable, inline_const_pat, "1.58.0", Some(76001)),
     /// Allows using `pointer` and `reference` in intra-doc links
     (unstable, intra_doc_pointers, "1.51.0", Some(80896)),
     // Allows using the `kl` and `widekl` target features and the associated intrinsics
-    (unstable, keylocker_x86, "CURRENT_RUSTC_VERSION", Some(134813)),
+    (unstable, keylocker_x86, "1.86.0", Some(134813)),
     // Allows setting the threshold for the `large_assignments` lint.
     (unstable, large_assignments, "1.52.0", Some(83518)),
     /// Allow to have type alias types for inter-crate use.
@@ -584,7 +584,7 @@ declare_features! (
     /// Allows diverging expressions to fall back to `!` rather than `()`.
     (unstable, never_type_fallback, "1.41.0", Some(65992)),
     /// Switch `..` syntax to use the new (`Copy + IntoIterator`) range types.
-    (unstable, new_range, "CURRENT_RUSTC_VERSION", Some(123741)),
+    (unstable, new_range, "1.86.0", Some(123741)),
     /// Allows `#![no_core]`.
     (unstable, no_core, "1.3.0", Some(29639)),
     /// Allows the use of `no_sanitize` attribute.
@@ -636,7 +636,7 @@ declare_features! (
     /// Allows string patterns to dereference values to match them.
     (unstable, string_deref_patterns, "1.67.0", Some(87121)),
     /// Allows subtrait items to shadow supertrait items.
-    (unstable, supertrait_item_shadowing, "CURRENT_RUSTC_VERSION", Some(89151)),
+    (unstable, supertrait_item_shadowing, "1.86.0", Some(89151)),
     /// Allows using `#[thread_local]` on `static` items.
     (unstable, thread_local, "1.0.0", Some(29594)),
     /// Allows defining `trait X = A + B;` alias items.

compiler/rustc_lint/src/deref_into_dyn_supertrait.rs

@@ -12,7 +12,7 @@ declare_lint! {
     /// for `dyn SubTrait` with a `dyn SuperTrait` type as the `Output` type.
     ///
     /// These implementations are "shadowed" by trait upcasting (stabilized since
-    /// CURRENT_RUSTC_VERSION). The `deref` functions is no longer called implicitly, which might
+    /// 1.86.0). The `deref` functions is no longer called implicitly, which might
     /// change behavior compared to previous rustc versions.
     ///
     /// ### Example

compiler/rustc_lint/src/lib.rs

@@ -21,7 +21,6 @@
 
 // tidy-alphabetical-start
 #![allow(internal_features)]
-#![cfg_attr(bootstrap, feature(trait_upcasting))]
 #![doc(html_root_url = "https://doc.rust-lang.org/nightly/nightly-rustc/")]
 #![doc(rust_logo)]
 #![feature(array_windows)]

compiler/rustc_middle/src/lib.rs

@@ -29,7 +29,6 @@
 #![allow(rustc::diagnostic_outside_of_impl)]
 #![allow(rustc::potential_query_instability)]
 #![allow(rustc::untranslatable_diagnostic)]
-#![cfg_attr(bootstrap, feature(trait_upcasting))]
 #![doc(html_root_url = "https://doc.rust-lang.org/nightly/nightly-rustc/")]
 #![doc(rust_logo)]
 #![feature(allocator_api)]

compiler/rustc_span/src/analyze_source_file.rs

@@ -29,132 +29,6 @@ pub(crate) fn analyze_source_file(src: &str) -> (Vec<RelativeBytePos>, Vec<Multi
     (lines, multi_byte_chars)
 }
 
-#[cfg(bootstrap)]
-cfg_match! {
-    cfg(any(target_arch = "x86", target_arch = "x86_64")) => {
-        fn analyze_source_file_dispatch(
-            src: &str,
-            lines: &mut Vec<RelativeBytePos>,
-            multi_byte_chars: &mut Vec<MultiByteChar>,
-        ) {
-            if is_x86_feature_detected!("sse2") {
-                unsafe {
-                    analyze_source_file_sse2(src, lines, multi_byte_chars);
-                }
-            } else {
-                analyze_source_file_generic(
-                    src,
-                    src.len(),
-                    RelativeBytePos::from_u32(0),
-                    lines,
-                    multi_byte_chars,
-                );
-            }
-        }
-
-        /// Checks 16 byte chunks of text at a time. If the chunk contains
-        /// something other than printable ASCII characters and newlines, the
-        /// function falls back to the generic implementation. Otherwise it uses
-        /// SSE2 intrinsics to quickly find all newlines.
-        #[target_feature(enable = "sse2")]
-        unsafe fn analyze_source_file_sse2(
-            src: &str,
-            lines: &mut Vec<RelativeBytePos>,
-            multi_byte_chars: &mut Vec<MultiByteChar>,
-        ) {
-            #[cfg(target_arch = "x86")]
-            use std::arch::x86::*;
-            #[cfg(target_arch = "x86_64")]
-            use std::arch::x86_64::*;
-
-            const CHUNK_SIZE: usize = 16;
-
-            let src_bytes = src.as_bytes();
-
-            let chunk_count = src.len() / CHUNK_SIZE;
-
-            // This variable keeps track of where we should start decoding a
-            // chunk. If a multi-byte character spans across chunk boundaries,
-            // we need to skip that part in the next chunk because we already
-            // handled it.
-            let mut intra_chunk_offset = 0;
-
-            for chunk_index in 0..chunk_count {
-                let ptr = src_bytes.as_ptr() as *const __m128i;
-                // We don't know if the pointer is aligned to 16 bytes, so we
-                // use `loadu`, which supports unaligned loading.
-                let chunk = unsafe { _mm_loadu_si128(ptr.add(chunk_index)) };
-
-                // For character in the chunk, see if its byte value is < 0, which
-                // indicates that it's part of a UTF-8 char.
-                let multibyte_test = unsafe { _mm_cmplt_epi8(chunk, _mm_set1_epi8(0)) };
-                // Create a bit mask from the comparison results.
-                let multibyte_mask = unsafe { _mm_movemask_epi8(multibyte_test) };
-
-                // If the bit mask is all zero, we only have ASCII chars here:
-                if multibyte_mask == 0 {
-                    assert!(intra_chunk_offset == 0);
-
-                    // Check for newlines in the chunk
-                    let newlines_test = unsafe { _mm_cmpeq_epi8(chunk, _mm_set1_epi8(b'\n' as i8)) };
-                    let mut newlines_mask = unsafe { _mm_movemask_epi8(newlines_test) };
-
-                    let output_offset = RelativeBytePos::from_usize(chunk_index * CHUNK_SIZE + 1);
-
-                    while newlines_mask != 0 {
-                        let index = newlines_mask.trailing_zeros();
-
-                        lines.push(RelativeBytePos(index) + output_offset);
-
-                        // Clear the bit, so we can find the next one.
-                        newlines_mask &= newlines_mask - 1;
-                    }
-                } else {
-                    // The slow path.
-                    // There are multibyte chars in here, fallback to generic decoding.
-                    let scan_start = chunk_index * CHUNK_SIZE + intra_chunk_offset;
-                    intra_chunk_offset = analyze_source_file_generic(
-                        &src[scan_start..],
-                        CHUNK_SIZE - intra_chunk_offset,
-                        RelativeBytePos::from_usize(scan_start),
-                        lines,
-                        multi_byte_chars,
-                    );
-                }
-            }
-
-            // There might still be a tail left to analyze
-            let tail_start = chunk_count * CHUNK_SIZE + intra_chunk_offset;
-            if tail_start < src.len() {
-                analyze_source_file_generic(
-                    &src[tail_start..],
-                    src.len() - tail_start,
-                    RelativeBytePos::from_usize(tail_start),
-                    lines,
-                    multi_byte_chars,
-                );
-            }
-        }
-    }
-    _ => {
-        // The target (or compiler version) does not support SSE2 ...
-        fn analyze_source_file_dispatch(
-            src: &str,
-            lines: &mut Vec<RelativeBytePos>,
-            multi_byte_chars: &mut Vec<MultiByteChar>,
-        ) {
-            analyze_source_file_generic(
-                src,
-                src.len(),
-                RelativeBytePos::from_u32(0),
-                lines,
-                multi_byte_chars,
-            );
-        }
-    }
-}
-
-#[cfg(not(bootstrap))]
 cfg_match! {
     any(target_arch = "x86", target_arch = "x86_64") => {
         fn analyze_source_file_dispatch(

library/alloc/src/boxed.rs

@@ -237,23 +237,13 @@ pub struct Box<
 /// the newly allocated memory. This is an intrinsic to avoid unnecessary copies.
 ///
 /// This is the surface syntax for `box <expr>` expressions.
-#[cfg(not(bootstrap))]
 #[rustc_intrinsic]
 #[rustc_intrinsic_must_be_overridden]
 #[unstable(feature = "liballoc_internals", issue = "none")]
 pub fn box_new<T>(_x: T) -> Box<T> {
     unreachable!()
 }
 
-/// Transition function for the next bootstrap bump.
-#[cfg(bootstrap)]
-#[unstable(feature = "liballoc_internals", issue = "none")]
-#[inline(always)]
-pub fn box_new<T>(x: T) -> Box<T> {
-    #[rustc_box]
-    Box::new(x)
-}
-
 impl<T> Box<T> {
     /// Allocates memory on the heap and then places `x` into it.
     ///