Auto merge of rust-lang#136533 - jhpratt:rollup-s0ign8n, r=jhpratt

Rollup of 5 pull requests

Successful merges:

 - rust-lang#134777 (Enable more tests on Windows)
 - rust-lang#135621 (Move some std tests to integration tests)
 - rust-lang#135844 ( Add new tool for dumping feature status based on tidy )
 - rust-lang#136167 (Implement unstable `new_range` feature)
 - rust-lang#136334 (Extract `core::ffi` primitives to a separate (internal) module)

Failed merges:

 - rust-lang#136201 (Removed dependency on the field-offset crate, alternate approach)

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

Author: bors

Diff for: Cargo.lock

@@ -186,6 +186,9 @@ name = "anyhow"
 version = "1.0.95"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "34ac096ce696dc2fcabef30516bb13c0a68a11d30131d3df6f04711467681b04"
+dependencies = [
+ "backtrace",
+]
 
 [[package]]
 name = "ar_archive_writer"
@@ -1195,6 +1198,17 @@ version = "2.3.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "37909eebbb50d72f9059c3b6d82c0463f2ff062c9e95845c43a6c9c0355411be"
 
+[[package]]
+name = "features-status-dump"
+version = "0.1.0"
+dependencies = [
+ "anyhow",
+ "clap",
+ "serde",
+ "serde_json",
+ "tidy",
+]
+
 [[package]]
 name = "field-offset"
 version = "0.3.6"
@@ -5418,6 +5432,7 @@ dependencies = [
  "regex",
  "rustc-hash 2.1.0",
  "semver",
+ "serde",
  "similar",
  "termcolor",
  "walkdir",

Diff for: Cargo.toml

@@ -47,6 +47,7 @@ members = [
   "src/tools/coverage-dump",
   "src/tools/rustc-perf-wrapper",
   "src/tools/wasm-component-ld",
+  "src/tools/features-status-dump",
 ]
 
 exclude = [

Diff for: compiler/rustc_ast_lowering/src/expr.rs

@@ -284,9 +284,6 @@ impl<'hir> LoweringContext<'_, 'hir> {
                 ExprKind::Index(el, er, brackets_span) => {
                     hir::ExprKind::Index(self.lower_expr(el), self.lower_expr(er), *brackets_span)
                 }
-                ExprKind::Range(Some(e1), Some(e2), RangeLimits::Closed) => {
-                    self.lower_expr_range_closed(e.span, e1, e2)
-                }
                 ExprKind::Range(e1, e2, lims) => {
                     self.lower_expr_range(e.span, e1.as_deref(), e2.as_deref(), *lims)
                 }
@@ -1512,15 +1509,39 @@ impl<'hir> LoweringContext<'_, 'hir> {
 
         let lang_item = match (e1, e2, lims) {
             (None, None, HalfOpen) => hir::LangItem::RangeFull,
-            (Some(..), None, HalfOpen) => hir::LangItem::RangeFrom,
+            (Some(..), None, HalfOpen) => {
+                if self.tcx.features().new_range() {
+                    hir::LangItem::RangeFromCopy
+                } else {
+                    hir::LangItem::RangeFrom
+                }
+            }
             (None, Some(..), HalfOpen) => hir::LangItem::RangeTo,
-            (Some(..), Some(..), HalfOpen) => hir::LangItem::Range,
+            (Some(..), Some(..), HalfOpen) => {
+                if self.tcx.features().new_range() {
+                    hir::LangItem::RangeCopy
+                } else {
+                    hir::LangItem::Range
+                }
+            }
             (None, Some(..), Closed) => hir::LangItem::RangeToInclusive,
-            (Some(..), Some(..), Closed) => unreachable!(),
+            (Some(e1), Some(e2), Closed) => {
+                if self.tcx.features().new_range() {
+                    hir::LangItem::RangeInclusiveCopy
+                } else {
+                    return self.lower_expr_range_closed(span, e1, e2);
+                }
+            }
             (start, None, Closed) => {
                 self.dcx().emit_err(InclusiveRangeWithNoEnd { span });
                 match start {
-                    Some(..) => hir::LangItem::RangeFrom,
+                    Some(..) => {
+                        if self.tcx.features().new_range() {
+                            hir::LangItem::RangeFromCopy
+                        } else {
+                            hir::LangItem::RangeFrom
+                        }
+                    }
                     None => hir::LangItem::RangeFull,
                 }
             }

Diff for: compiler/rustc_feature/src/unstable.rs

@@ -570,6 +570,8 @@ declare_features! (
     (unstable, never_type, "1.13.0", Some(35121)),
     /// 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)),
     /// Allows `#![no_core]`.
     (unstable, no_core, "1.3.0", Some(29639)),
     /// Allows the use of `no_sanitize` attribute.

Diff for: compiler/rustc_hir/src/hir.rs

@@ -2313,6 +2313,18 @@ impl Expr<'_> {
                     [val2],
                     StructTailExpr::None,
                 ),
+            )
+            | (
+                ExprKind::Struct(
+                    QPath::LangItem(LangItem::RangeFromCopy, _),
+                    [val1],
+                    StructTailExpr::None,
+                ),
+                ExprKind::Struct(
+                    QPath::LangItem(LangItem::RangeFromCopy, _),
+                    [val2],
+                    StructTailExpr::None,
+                ),
             ) => val1.expr.equivalent_for_indexing(val2.expr),
             (
                 ExprKind::Struct(
@@ -2325,6 +2337,30 @@ impl Expr<'_> {
                     [val2, val4],
                     StructTailExpr::None,
                 ),
+            )
+            | (
+                ExprKind::Struct(
+                    QPath::LangItem(LangItem::RangeCopy, _),
+                    [val1, val3],
+                    StructTailExpr::None,
+                ),
+                ExprKind::Struct(
+                    QPath::LangItem(LangItem::RangeCopy, _),
+                    [val2, val4],
+                    StructTailExpr::None,
+                ),
+            )
+            | (
+                ExprKind::Struct(
+                    QPath::LangItem(LangItem::RangeInclusiveCopy, _),
+                    [val1, val3],
+                    StructTailExpr::None,
+                ),
+                ExprKind::Struct(
+                    QPath::LangItem(LangItem::RangeInclusiveCopy, _),
+                    [val2, val4],
+                    StructTailExpr::None,
+                ),
             ) => {
                 val1.expr.equivalent_for_indexing(val2.expr)
                     && val3.expr.equivalent_for_indexing(val4.expr)
@@ -2354,7 +2390,10 @@ pub fn is_range_literal(expr: &Expr<'_>) -> bool {
                     | LangItem::RangeTo
                     | LangItem::RangeFrom
                     | LangItem::RangeFull
-                    | LangItem::RangeToInclusive,
+                    | LangItem::RangeToInclusive
+                    | LangItem::RangeCopy
+                    | LangItem::RangeFromCopy
+                    | LangItem::RangeInclusiveCopy,
                 ..
             )
         ),

Diff for: compiler/rustc_hir/src/lang_items.rs

@@ -416,6 +416,11 @@ language_item_table! {
     RangeToInclusive,        sym::RangeToInclusive,    range_to_inclusive_struct,  Target::Struct,         GenericRequirement::None;
     RangeTo,                 sym::RangeTo,             range_to_struct,            Target::Struct,         GenericRequirement::None;
 
+    // `new_range` types that are `Copy + IntoIterator`
+    RangeFromCopy,           sym::RangeFromCopy,       range_from_copy_struct,     Target::Struct,         GenericRequirement::None;
+    RangeCopy,               sym::RangeCopy,           range_copy_struct,          Target::Struct,         GenericRequirement::None;
+    RangeInclusiveCopy,      sym::RangeInclusiveCopy,  range_inclusive_copy_struct, Target::Struct,         GenericRequirement::None;
+
     String,                  sym::String,              string,                     Target::Struct,         GenericRequirement::None;
     CStr,                    sym::CStr,                c_str,                      Target::Struct,         GenericRequirement::None;
 }

Diff for: compiler/rustc_hir_typeck/src/method/suggest.rs

@@ -2395,6 +2395,10 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
                     let lang_item = match parent_expr.kind {
                         ExprKind::Struct(qpath, _, _) => match *qpath {
                             QPath::LangItem(LangItem::Range, ..) => Some(LangItem::Range),
+                            QPath::LangItem(LangItem::RangeCopy, ..) => Some(LangItem::RangeCopy),
+                            QPath::LangItem(LangItem::RangeInclusiveCopy, ..) => {
+                                Some(LangItem::RangeInclusiveCopy)
+                            }
                             QPath::LangItem(LangItem::RangeTo, ..) => Some(LangItem::RangeTo),
                             QPath::LangItem(LangItem::RangeToInclusive, ..) => {
                                 Some(LangItem::RangeToInclusive)

Diff for: compiler/rustc_span/src/symbol.rs

@@ -294,9 +294,12 @@ symbols! {
         ProceduralMasqueradeDummyType,
         Range,
         RangeBounds,
+        RangeCopy,
         RangeFrom,
+        RangeFromCopy,
         RangeFull,
         RangeInclusive,
+        RangeInclusiveCopy,
         RangeTo,
         RangeToInclusive,
         Rc,
@@ -1364,6 +1367,7 @@ symbols! {
         new_lower_hex,
         new_octal,
         new_pointer,
+        new_range,
         new_unchecked,
         new_upper_exp,
         new_upper_hex,

Diff for: library/core/src/ffi/mod.rs

@@ -37,175 +37,14 @@ pub use self::va_list::{VaList, VaListImpl};
 )]
 pub mod va_list;
 
-macro_rules! type_alias {
-    {
-      $Docfile:tt, $Alias:ident = $Real:ty;
-      $( $Cfg:tt )*
-    } => {
-        #[doc = include_str!($Docfile)]
-        $( $Cfg )*
-        #[stable(feature = "core_ffi_c", since = "1.64.0")]
-        pub type $Alias = $Real;
-    }
-}
-
-type_alias! { "c_char.md", c_char = c_char_definition::c_char; #[doc(cfg(all()))] }
-
-type_alias! { "c_schar.md", c_schar = i8; }
-type_alias! { "c_uchar.md", c_uchar = u8; }
-type_alias! { "c_short.md", c_short = i16; }
-type_alias! { "c_ushort.md", c_ushort = u16; }
-
-type_alias! { "c_int.md", c_int = c_int_definition::c_int; #[doc(cfg(all()))] }
-type_alias! { "c_uint.md", c_uint = c_int_definition::c_uint; #[doc(cfg(all()))] }
-
-type_alias! { "c_long.md", c_long = c_long_definition::c_long; #[doc(cfg(all()))] }
-type_alias! { "c_ulong.md", c_ulong = c_long_definition::c_ulong; #[doc(cfg(all()))] }
-
-type_alias! { "c_longlong.md", c_longlong = i64; }
-type_alias! { "c_ulonglong.md", c_ulonglong = u64; }
-
-type_alias! { "c_float.md", c_float = f32; }
-type_alias! { "c_double.md", c_double = f64; }
-
-/// Equivalent to C's `size_t` type, from `stddef.h` (or `cstddef` for C++).
-///
-/// This type is currently always [`usize`], however in the future there may be
-/// platforms where this is not the case.
-#[unstable(feature = "c_size_t", issue = "88345")]
-pub type c_size_t = usize;
-
-/// Equivalent to C's `ptrdiff_t` type, from `stddef.h` (or `cstddef` for C++).
-///
-/// This type is currently always [`isize`], however in the future there may be
-/// platforms where this is not the case.
+mod primitives;
+#[stable(feature = "core_ffi_c", since = "1.64.0")]
+pub use self::primitives::{
+    c_char, c_double, c_float, c_int, c_long, c_longlong, c_schar, c_short, c_uchar, c_uint,
+    c_ulong, c_ulonglong, c_ushort,
+};
 #[unstable(feature = "c_size_t", issue = "88345")]
-pub type c_ptrdiff_t = isize;
-
-/// Equivalent to C's `ssize_t` (on POSIX) or `SSIZE_T` (on Windows) type.
-///
-/// This type is currently always [`isize`], however in the future there may be
-/// platforms where this is not the case.
-#[unstable(feature = "c_size_t", issue = "88345")]
-pub type c_ssize_t = isize;
-
-mod c_char_definition {
-    cfg_if! {
-        // These are the targets on which c_char is unsigned. Usually the
-        // signedness is the same for all target_os values on a given architecture
-        // but there are some exceptions (see isSignedCharDefault() in clang).
-        //
-        // aarch64:
-        //   Section 10 "Arm C and C++ language mappings" in Procedure Call Standard for the Arm®
-        //   64-bit Architecture (AArch64) says C/C++ char is unsigned byte.
-        //   https://github.com/ARM-software/abi-aa/blob/2024Q3/aapcs64/aapcs64.rst#arm-c-and-c-language-mappings
-        // arm:
-        //   Section 8 "Arm C and C++ Language Mappings" in Procedure Call Standard for the Arm®
-        //   Architecture says C/C++ char is unsigned byte.
-        //   https://github.com/ARM-software/abi-aa/blob/2024Q3/aapcs32/aapcs32.rst#arm-c-and-c-language-mappings
-        // csky:
-        //   Section 2.1.2 "Primary Data Type" in C-SKY V2 CPU Applications Binary Interface
-        //   Standards Manual says ANSI C char is unsigned byte.
-        //   https://github.com/c-sky/csky-doc/blob/9f7121f7d40970ba5cc0f15716da033db2bb9d07/C-SKY_V2_CPU_Applications_Binary_Interface_Standards_Manual.pdf
-        //   Note: this doesn't seem to match Clang's default (https://github.com/rust-lang/rust/issues/129945).
-        // hexagon:
-        //   Section 3.1 "Basic data type" in Qualcomm Hexagon™ Application
-        //   Binary Interface User Guide says "By default, the `char` data type is unsigned."
-        //   https://docs.qualcomm.com/bundle/publicresource/80-N2040-23_REV_K_Qualcomm_Hexagon_Application_Binary_Interface_User_Guide.pdf
-        // msp430:
-        //   Section 2.1 "Basic Types" in MSP430 Embedded Application Binary
-        //   Interface says "The char type is unsigned by default".
-        //   https://www.ti.com/lit/an/slaa534a/slaa534a.pdf
-        // powerpc/powerpc64:
-        //   - PPC32 SysV: "Table 3-1 Scalar Types" in System V Application Binary Interface PowerPC
-        //     Processor Supplement says ANSI C char is unsigned byte
-        //     https://refspecs.linuxfoundation.org/elf/elfspec_ppc.pdf
-        //   - PPC64 ELFv1: Section 3.1.4 "Fundamental Types" in 64-bit PowerPC ELF Application
-        //     Binary Interface Supplement 1.9 says ANSI C is unsigned byte
-        //     https://refspecs.linuxfoundation.org/ELF/ppc64/PPC-elf64abi.html#FUND-TYPE
-        //   - PPC64 ELFv2: Section 2.1.2.2 "Fundamental Types" in 64-Bit ELF V2 ABI Specification
-        //     says char is unsigned byte
-        //     https://openpowerfoundation.org/specifications/64bitelfabi/
-        //   - AIX: XL C for AIX Language Reference says "By default, char behaves like an unsigned char."
-        //     https://www.ibm.com/docs/en/xl-c-aix/13.1.3?topic=specifiers-character-types
-        // riscv32/riscv64:
-        //   C/C++ type representations section in RISC-V Calling Conventions
-        //   page in RISC-V ELF psABI Document says "char is unsigned."
-        //   https://github.com/riscv-non-isa/riscv-elf-psabi-doc/blob/draft-20240829-13bfa9f54634cb60d86b9b333e109f077805b4b3/riscv-cc.adoc#cc-type-representations
-        // s390x:
-        //   - ELF: "Table 1.1.: Scalar types" in ELF Application Binary Interface s390x Supplement
-        //     Version 1.6.1 categorize ISO C char in unsigned integer
-        //     https://github.com/IBM/s390x-abi/releases/tag/v1.6.1
-        //   - z/OS: XL C/C++ Language Reference says: "By default, char behaves like an unsigned char."
-        //     https://www.ibm.com/docs/en/zos/3.1.0?topic=specifiers-character-types
-        // xtensa:
-        //   Section 2.17.1 "Data Types and Alignment" of Xtensa LX Microprocessor Overview handbook
-        //   says "`char` type is unsigned by default".
-        //   https://loboris.eu/ESP32/Xtensa_lx%20Overview%20handbook.pdf
-        //
-        // On the following operating systems, c_char is signed by default, regardless of architecture.
-        // Darwin (macOS, iOS, etc.):
-        //   Apple targets' c_char is signed by default even on arm
-        //   https://developer.apple.com/documentation/xcode/writing-arm64-code-for-apple-platforms#Handle-data-types-and-data-alignment-properly
-        // Windows:
-        //   Windows MSVC C++ Language Reference says "Microsoft-specific: Variables of type char
-        //   are promoted to int as if from type signed char by default, unless the /J compilation
-        //   option is used."
-        //   https://learn.microsoft.com/en-us/cpp/cpp/fundamental-types-cpp?view=msvc-170#character-types
-        // L4Re:
-        //   The kernel builds with -funsigned-char on all targets (but useserspace follows the
-        //   architecture defaults). As we only have a target for userspace apps so there are no
-        //   special cases for L4Re below.
-        //   https://github.com/rust-lang/rust/pull/132975#issuecomment-2484645240
-        if #[cfg(all(
-            not(windows),
-            not(target_vendor = "apple"),
-            any(
-                target_arch = "aarch64",
-                target_arch = "arm",
-                target_arch = "csky",
-                target_arch = "hexagon",
-                target_arch = "msp430",
-                target_arch = "powerpc",
-                target_arch = "powerpc64",
-                target_arch = "riscv32",
-                target_arch = "riscv64",
-                target_arch = "s390x",
-                target_arch = "xtensa",
-            )
-        ))] {
-            pub(super) type c_char = u8;
-        } else {
-            // On every other target, c_char is signed.
-            pub(super) type c_char = i8;
-        }
-    }
-}
-
-mod c_int_definition {
-    cfg_if! {
-        if #[cfg(any(target_arch = "avr", target_arch = "msp430"))] {
-            pub(super) type c_int = i16;
-            pub(super) type c_uint = u16;
-        } else {
-            pub(super) type c_int = i32;
-            pub(super) type c_uint = u32;
-        }
-    }
-}
-
-mod c_long_definition {
-    cfg_if! {
-        if #[cfg(all(target_pointer_width = "64", not(windows)))] {
-            pub(super) type c_long = i64;
-            pub(super) type c_ulong = u64;
-        } else {
-            // The minimal size of `long` in the C standard is 32 bits
-            pub(super) type c_long = i32;
-            pub(super) type c_ulong = u32;
-        }
-    }
-}
+pub use self::primitives::{c_ptrdiff_t, c_size_t, c_ssize_t};
 
 // N.B., for LLVM to recognize the void pointer type and by extension
 //     functions like malloc(), we need to have it represented as i8* in