Rollup of 4 pull requests

compiler/rustc_codegen_ssa/src/back/link.rs

@@ -1117,14 +1117,14 @@ fn link_natively(
         let stripcmd = "rust-objcopy";
         match (strip, crate_type) {
             (Strip::Debuginfo, _) => {
-                strip_symbols_with_external_utility(sess, stripcmd, out_filename, Some("-S"))
+                strip_symbols_with_external_utility(sess, stripcmd, out_filename, &["-S"])
             }
             // Per the manpage, `-x` is the maximum safe strip level for dynamic libraries. (#93988)
             (Strip::Symbols, CrateType::Dylib | CrateType::Cdylib | CrateType::ProcMacro) => {
-                strip_symbols_with_external_utility(sess, stripcmd, out_filename, Some("-x"))
+                strip_symbols_with_external_utility(sess, stripcmd, out_filename, &["-x"])
             }
             (Strip::Symbols, _) => {
-                strip_symbols_with_external_utility(sess, stripcmd, out_filename, None)
+                strip_symbols_with_external_utility(sess, stripcmd, out_filename, &[])
             }
             (Strip::None, _) => {}
         }
@@ -1141,7 +1141,7 @@ fn link_natively(
         match strip {
             // Always preserve the symbol table (-x).
             Strip::Debuginfo => {
-                strip_symbols_with_external_utility(sess, stripcmd, out_filename, Some("-x"))
+                strip_symbols_with_external_utility(sess, stripcmd, out_filename, &["-x"])
             }
             // Strip::Symbols is handled via the --strip-all linker option.
             Strip::Symbols => {}
@@ -1158,11 +1158,15 @@ fn link_natively(
         match strip {
             Strip::Debuginfo => {
                 // FIXME: AIX's strip utility only offers option to strip line number information.
-                strip_symbols_with_external_utility(sess, stripcmd, out_filename, Some("-l"))
+                strip_symbols_with_external_utility(sess, stripcmd, out_filename, &[
+                    "-X32_64", "-l",
+                ])
             }
             Strip::Symbols => {
                 // Must be noted this option might remove symbol __aix_rust_metadata and thus removes .info section which contains metadata.
-                strip_symbols_with_external_utility(sess, stripcmd, out_filename, Some("-r"))
+                strip_symbols_with_external_utility(sess, stripcmd, out_filename, &[
+                    "-X32_64", "-r",
+                ])
             }
             Strip::None => {}
         }
@@ -1181,12 +1185,10 @@ fn strip_symbols_with_external_utility(
     sess: &Session,
     util: &str,
     out_filename: &Path,
-    option: Option<&str>,
+    options: &[&str],
 ) {
     let mut cmd = Command::new(util);
-    if let Some(option) = option {
-        cmd.arg(option);
-    }
+    cmd.args(options);
 
     let mut new_path = sess.get_tools_search_paths(false);
     if let Some(path) = env::var_os("PATH") {

compiler/rustc_lint_defs/src/builtin.rs

@@ -5173,7 +5173,7 @@ declare_lint! {
     Warn,
     "this function call or definition uses a vector type which is not enabled",
     @future_incompatible = FutureIncompatibleInfo {
-        reason: FutureIncompatibilityReason::FutureReleaseErrorDontReportInDeps,
+        reason: FutureIncompatibilityReason::FutureReleaseErrorReportInDeps,
         reference: "issue #116558 <https://github.com/rust-lang/rust/issues/116558>",
     };
 }

compiler/rustc_passes/src/stability.rs

@@ -590,16 +590,7 @@ impl<'tcx> MissingStabilityAnnotations<'tcx> {
     }
 
     fn check_missing_const_stability(&self, def_id: LocalDefId, span: Span) {
-        // if the const impl is derived using the `derive_const` attribute,
-        // then it would be "stable" at least for the impl.
-        // We gate usages of it using `feature(const_trait_impl)` anyways
-        // so there is no unstable leakage
-        if self.tcx.is_automatically_derived(def_id.to_def_id()) {
-            return;
-        }
-
-        let is_const = self.tcx.is_const_fn(def_id.to_def_id())
-            || self.tcx.is_const_trait_impl(def_id.to_def_id());
+        let is_const = self.tcx.is_const_fn(def_id.to_def_id());
 
         // Reachable const fn must have a stability attribute.
         if is_const

library/core/src/lib.rs

@@ -174,6 +174,7 @@
 #![feature(const_is_char_boundary)]
 #![feature(const_precise_live_drops)]
 #![feature(const_str_split_at)]
+#![feature(const_trait_impl)]
 #![feature(decl_macro)]
 #![feature(deprecated_suggestion)]
 #![feature(doc_cfg)]

library/core/src/ops/arith.rs

@@ -73,6 +73,7 @@
     append_const_msg
 )]
 #[doc(alias = "+")]
+#[cfg_attr(not(bootstrap), const_trait)]
 pub trait Add<Rhs = Self> {
     /// The resulting type after applying the `+` operator.
     #[stable(feature = "rust1", since = "1.0.0")]
@@ -94,6 +95,7 @@ pub trait Add<Rhs = Self> {
 macro_rules! add_impl {
     ($($t:ty)*) => ($(
         #[stable(feature = "rust1", since = "1.0.0")]
+        #[cfg(bootstrap)]
         impl Add for $t {
             type Output = $t;
 
@@ -103,6 +105,17 @@ macro_rules! add_impl {
             fn add(self, other: $t) -> $t { self + other }
         }
 
+        #[stable(feature = "rust1", since = "1.0.0")]
+        #[cfg(not(bootstrap))]
+        impl const Add for $t {
+            type Output = $t;
+
+            #[inline]
+            #[track_caller]
+            #[rustc_inherit_overflow_checks]
+            fn add(self, other: $t) -> $t { self + other }
+        }
+
         forward_ref_binop! { impl Add, add for $t, $t }
     )*)
 }

tests/ui/layout/aggregate-lang/struct-align.rs

@@ -0,0 +1,29 @@
+//@ run-pass
+//@ reference: layout.aggregate.struct-size-align
+//@ edition: 2018
+
+#[repr(align(64))]
+#[derive(Copy, Clone)]
+#[allow(dead_code)]
+pub struct Overaligned(u8);
+
+#[allow(dead_code)]
+struct ReprRustStruct {
+    x: i32,
+    y: [u32; 4],
+    z: f32,
+    a: u128,
+    b: Overaligned,
+}
+
+fn test_alignment_contains_all_fields() {
+    assert!(core::mem::align_of::<ReprRustStruct>() >= core::mem::align_of::<i32>());
+    assert!(core::mem::align_of::<ReprRustStruct>() >= core::mem::align_of::<[u32; 4]>());
+    assert!(core::mem::align_of::<ReprRustStruct>() >= core::mem::align_of::<f32>());
+    assert!(core::mem::align_of::<ReprRustStruct>() >= core::mem::align_of::<u128>());
+    assert!(core::mem::align_of::<ReprRustStruct>() >= core::mem::align_of::<Overaligned>());
+}
+
+fn main() {
+    test_alignment_contains_all_fields();
+}

tests/ui/layout/aggregate-lang/struct-offsets.rs

@@ -0,0 +1,78 @@
+//@ run-pass
+//@ reference: layout.aggregate.struct-offsets
+//@ edition: 2018
+
+#[repr(align(64))]
+#[derive(Copy, Clone)]
+#[allow(dead_code)]
+pub struct Overaligned(u8);
+
+#[allow(dead_code)]
+struct ReprRustStruct {
+    x: i32,
+    y: [u32; 4],
+    z: f32,
+    a: u128,
+    b: Overaligned,
+}
+
+macro_rules! span_of {
+    ($ty:ty , $field:tt) => {{
+        let __field = unsafe { ::core::mem::zeroed::<$ty>() };
+
+        (
+            core::mem::offset_of!($ty, $field),
+            core::mem::offset_of!($ty, $field) + core::mem::size_of_val(&__field.$field),
+        )
+    }};
+}
+
+fn test_fields_make_sense(a: &(usize, usize)) {
+    assert!(a.0 <= a.1);
+}
+
+// order is `begin, end`
+fn test_non_overlapping(a: &(usize, usize), b: &(usize, usize)) {
+    assert!((a.1 <= b.0) || (b.1 <= a.0));
+}
+
+fn test_fields_non_overlapping() {
+    let fields = [
+        span_of!(ReprRustStruct, x),
+        span_of!(ReprRustStruct, y),
+        span_of!(ReprRustStruct, z),
+        span_of!(ReprRustStruct, a),
+        span_of!(ReprRustStruct, b),
+    ];
+
+    test_fields_make_sense(&fields[0]);
+    test_fields_make_sense(&fields[1]);
+    test_fields_make_sense(&fields[2]);
+    test_fields_make_sense(&fields[3]);
+    test_fields_make_sense(&fields[4]);
+
+    test_non_overlapping(&fields[0], &fields[1]);
+    test_non_overlapping(&fields[0], &fields[2]);
+    test_non_overlapping(&fields[0], &fields[3]);
+    test_non_overlapping(&fields[0], &fields[4]);
+    test_non_overlapping(&fields[1], &fields[2]);
+    test_non_overlapping(&fields[2], &fields[3]);
+    test_non_overlapping(&fields[2], &fields[4]);
+    test_non_overlapping(&fields[3], &fields[4]);
+}
+
+fn test_fields_aligned() {
+    assert_eq!((core::mem::offset_of!(ReprRustStruct, x) % (core::mem::align_of::<i32>())), 0);
+    assert_eq!((core::mem::offset_of!(ReprRustStruct, y) % (core::mem::align_of::<[u32; 4]>())), 0);
+    assert_eq!((core::mem::offset_of!(ReprRustStruct, z) % (core::mem::align_of::<f32>())), 0);
+    assert_eq!((core::mem::offset_of!(ReprRustStruct, a) % (core::mem::align_of::<u128>())), 0);
+    assert_eq!(
+        (core::mem::offset_of!(ReprRustStruct, b) % (core::mem::align_of::<Overaligned>())),
+        0
+    );
+}
+
+fn main() {
+    test_fields_non_overlapping();
+    test_fields_aligned();
+}

tests/ui/layout/aggregate-lang/struct-size.rs

@@ -0,0 +1,50 @@
+//@ run-pass
+//@ reference: layout.aggregate.struct-size-align
+//@ edition: 2018
+
+#[allow(dead_code)]
+struct ReprRustStruct {
+    x: i32,
+    y: [u32; 4],
+    z: f32,
+    a: u128,
+}
+
+fn test_size_contains_all_types() {
+    assert!(
+        core::mem::size_of::<ReprRustStruct>()
+            >= (core::mem::size_of::<i32>()
+                + core::mem::size_of::<[u32; 4]>()
+                + core::mem::size_of::<f32>()
+                + core::mem::size_of::<u128>())
+    );
+}
+
+fn test_size_contains_all_fields() {
+    assert!(
+        (core::mem::offset_of!(ReprRustStruct, x) + core::mem::size_of::<i32>())
+            <= core::mem::size_of::<ReprRustStruct>()
+    );
+    assert!(
+        (core::mem::offset_of!(ReprRustStruct, y) + core::mem::size_of::<[u32; 4]>())
+            <= core::mem::size_of::<ReprRustStruct>()
+    );
+    assert!(
+        (core::mem::offset_of!(ReprRustStruct, z) + core::mem::size_of::<f32>())
+            <= core::mem::size_of::<ReprRustStruct>()
+    );
+    assert!(
+        (core::mem::offset_of!(ReprRustStruct, a) + core::mem::size_of::<u128>())
+            <= core::mem::size_of::<ReprRustStruct>()
+    );
+}
+
+fn test_size_modulo_align() {
+    assert_eq!(core::mem::size_of::<ReprRustStruct>() % core::mem::align_of::<ReprRustStruct>(), 0);
+}
+
+fn main() {
+    test_size_contains_all_fields();
+    test_size_contains_all_types();
+    test_size_modulo_align();
+}

tests/ui/layout/aggregate-lang/union-align.rs

@@ -0,0 +1,29 @@
+//@ run-pass
+//@ reference: layout.aggregate.struct-size-align
+//@ edition: 2018
+
+#[repr(align(64))]
+#[derive(Copy, Clone)]
+#[allow(dead_code)]
+pub struct Overaligned(u8);
+
+#[allow(dead_code)]
+union ReprRustUnion {
+    x: i32,
+    y: [u32; 4],
+    z: f32,
+    a: u128,
+    b: Overaligned,
+}
+
+fn test_alignment_contains_all_fields() {
+    assert!(core::mem::align_of::<ReprRustUnion>() >= core::mem::align_of::<i32>());
+    assert!(core::mem::align_of::<ReprRustUnion>() >= core::mem::align_of::<[u32; 4]>());
+    assert!(core::mem::align_of::<ReprRustUnion>() >= core::mem::align_of::<f32>());
+    assert!(core::mem::align_of::<ReprRustUnion>() >= core::mem::align_of::<u128>());
+    assert!(core::mem::align_of::<ReprRustUnion>() >= core::mem::align_of::<Overaligned>());
+}
+
+fn main() {
+    test_alignment_contains_all_fields();
+}

tests/ui/layout/aggregate-lang/union-offsets.rs

@@ -0,0 +1,32 @@
+//@ run-pass
+//@ reference: layout.aggregate.struct-offsets
+//@ edition: 2018
+
+#[repr(align(64))]
+#[derive(Copy, Clone)]
+#[allow(dead_code)]
+pub struct Overaligned(u8);
+
+#[allow(dead_code)]
+union ReprRustUnion {
+    x: i32,
+    y: [u32; 4],
+    z: f32,
+    a: u128,
+    b: Overaligned,
+}
+
+fn test_fields_aligned() {
+    assert_eq!((core::mem::offset_of!(ReprRustUnion, x) % (core::mem::align_of::<i32>())), 0);
+    assert_eq!((core::mem::offset_of!(ReprRustUnion, y) % (core::mem::align_of::<[u32; 4]>())), 0);
+    assert_eq!((core::mem::offset_of!(ReprRustUnion, z) % (core::mem::align_of::<f32>())), 0);
+    assert_eq!((core::mem::offset_of!(ReprRustUnion, a) % (core::mem::align_of::<u128>())), 0);
+    assert_eq!(
+        (core::mem::offset_of!(ReprRustUnion, b) % (core::mem::align_of::<Overaligned>())),
+        0
+    );
+}
+
+fn main() {
+    test_fields_aligned();
+}

tests/ui/layout/aggregate-lang/union-size.rs

@@ -0,0 +1,47 @@
+//@ run-pass
+//@ reference: layout.aggregate.struct-size-align
+//@ edition: 2018
+
+#[allow(dead_code)]
+union ReprRustUnion {
+    x: i32,
+    y: [u32; 4],
+    z: f32,
+    a: u128,
+}
+
+fn test_size_contains_each_type() {
+    assert!(core::mem::size_of::<i32>() <= core::mem::size_of::<ReprRustUnion>());
+    assert!(core::mem::size_of::<[u32; 4]>() <= core::mem::size_of::<ReprRustUnion>());
+    assert!(core::mem::size_of::<f32>() <= core::mem::size_of::<ReprRustUnion>());
+    assert!(core::mem::size_of::<u128>() <= core::mem::size_of::<ReprRustUnion>());
+}
+
+fn test_size_contains_all_fields() {
+    assert!(
+        (core::mem::offset_of!(ReprRustUnion, x) + core::mem::size_of::<i32>())
+            <= core::mem::size_of::<ReprRustUnion>()
+    );
+    assert!(
+        (core::mem::offset_of!(ReprRustUnion, y) + core::mem::size_of::<[u32; 4]>())
+            <= core::mem::size_of::<ReprRustUnion>()
+    );
+    assert!(
+        (core::mem::offset_of!(ReprRustUnion, z) + core::mem::size_of::<f32>())
+            <= core::mem::size_of::<ReprRustUnion>()
+    );
+    assert!(
+        (core::mem::offset_of!(ReprRustUnion, a) + core::mem::size_of::<u128>())
+            <= core::mem::size_of::<ReprRustUnion>()
+    );
+}
+
+fn test_size_modulo_align() {
+    assert_eq!(core::mem::size_of::<ReprRustUnion>() % core::mem::align_of::<ReprRustUnion>(), 0);
+}
+
+fn main() {
+    test_size_contains_each_type();
+    test_size_contains_all_fields();
+    test_size_modulo_align();
+}