Rollup of 16 pull requests

RELEASES.md

@@ -67,6 +67,8 @@ Stabilized APIs
 - [`Atomic<T>::get_mut_slice`](https://doc.rust-lang.org/stable/core/sync/atomic/struct.Atomic.html#method.get_mut_slice)
 - [`Atomic<T>::from_mut_slice`](https://doc.rust-lang.org/stable/core/sync/atomic/struct.Atomic.html#method.from_mut_slice)
 - [`std::range::legacy`](https://doc.rust-lang.org/stable/std/range/legacy/index.html)
+- [`bool::ok_or`](https://doc.rust-lang.org/stable/std/primitive.bool.html#method.ok_or)
+- [`bool::ok_or_else`](https://doc.rust-lang.org/stable/std/primitive.bool.html#method.ok_or_else)
 
 
 <a id="1.98.0-Compatibility-Notes"></a>

compiler/rustc_arena/src/lib.rs

@@ -13,7 +13,7 @@
 #![cfg_attr(bootstrap, feature(never_type))]
 #![cfg_attr(test, feature(test))]
 #![deny(unsafe_op_in_unsafe_fn)]
-#![doc(test(no_crate_inject, attr(deny(warnings), allow(internal_features))))]
+#![doc(test(no_crate_inject, attr(deny(warnings))))]
 #![feature(decl_macro)]
 #![feature(dropck_eyepatch)]
 #![feature(rustc_attrs)]

compiler/rustc_ast/src/lib.rs

@@ -5,7 +5,7 @@
 //! This API is completely unstable and subject to change.
 
 // tidy-alphabetical-start
-#![doc(test(attr(deny(warnings), allow(internal_features))))]
+#![doc(test(attr(deny(warnings))))]
 #![feature(associated_type_defaults)]
 #![feature(deref_patterns)]
 #![feature(iter_order_by)]

compiler/rustc_builtin_macros/src/contracts.rs

@@ -137,6 +137,21 @@ fn expand_contract_clause_tts(
     annotated: TokenStream,
     clause_keyword: rustc_span::Symbol,
 ) -> Result<TokenStream, ErrorGuaranteed> {
+    if annotation.is_empty() {
+        let (name, example) = if clause_keyword == kw::ContractRequires {
+            ("requires", "condition")
+        } else {
+            ("ensures", "|result: &T| condition")
+        };
+        ecx.sess.dcx().span_err(
+            attr_span,
+            format!("`{name}` attribute requires an argument, e.g., `#[{name}({example})]`"),
+        );
+        // Returning `Err` would replace it with a dummy fragment and cause cascading name-resolution errors.
+        // Instead, we return the original token stream so that there is no later noises.
+        return Ok(annotated);
+    }
+
     let feature_span = ecx.with_def_site_ctxt(attr_span);
     expand_contract_clause(ecx, attr_span, annotated, |new_tts| {
         new_tts.push(TokenTree::Token(

compiler/rustc_codegen_llvm/src/asm.rs

@@ -16,12 +16,12 @@ use rustc_target::spec::HasTargetSpec;
 use smallvec::SmallVec;
 use tracing::debug;
 
-use crate::attributes;
 use crate::builder::Builder;
 use crate::common::Funclet;
 use crate::context::CodegenCx;
 use crate::llvm::{self, ToLlvmBool, Type, Value};
 use crate::type_of::LayoutLlvmExt;
+use crate::{attributes, llvm_util};
 
 impl<'ll, 'tcx> AsmBuilderMethods<'tcx> for Builder<'_, 'll, 'tcx> {
     fn codegen_inline_asm(
@@ -499,7 +499,15 @@ impl<'tcx> AsmCodegenMethods<'tcx> for CodegenCx<'_, 'tcx> {
             template_str.push_str("\n.att_syntax\n");
         }
 
-        llvm::append_module_inline_asm(self.llmod, template_str.as_bytes());
+        let target_features = self.tcx.global_backend_features(()).join(",");
+        let target_cpu = llvm_util::target_cpu(self.tcx.sess);
+
+        llvm::append_module_inline_asm(
+            self.llmod,
+            template_str.as_bytes(),
+            &target_features,
+            target_cpu,
+        );
     }
 
     fn mangled_name(&self, instance: Instance<'tcx>) -> String {

compiler/rustc_codegen_llvm/src/back/write.rs

@@ -1303,9 +1303,9 @@ fn embed_bitcode(
         // We need custom section flags, so emit module-level inline assembly.
         let section_flags = if cgcx.is_pe_coff { "n" } else { "e" };
         let asm = create_section_with_flags_asm(".llvmbc", section_flags, bitcode);
-        llvm::append_module_inline_asm(llmod, &asm);
+        llvm::append_module_inline_asm(llmod, &asm, "", "");
         let asm = create_section_with_flags_asm(".llvmcmd", section_flags, &[]);
-        llvm::append_module_inline_asm(llmod, &asm);
+        llvm::append_module_inline_asm(llmod, &asm, "", "");
     }
 }
 

compiler/rustc_codegen_llvm/src/llvm/ffi.rs

@@ -907,13 +907,6 @@ unsafe extern "C" {
     pub(crate) fn LLVMGetDataLayoutStr(M: &Module) -> *const c_char;
     pub(crate) fn LLVMSetDataLayout(M: &Module, Triple: *const c_char);
 
-    /// Append inline assembly to a module. See `Module::appendModuleInlineAsm`.
-    pub(crate) fn LLVMAppendModuleInlineAsm(
-        M: &Module,
-        Asm: *const c_uchar, // See "PTR_LEN_STR".
-        Len: size_t,
-    );
-
     /// Create the specified uniqued inline asm string. See `InlineAsm::get()`.
     pub(crate) fn LLVMGetInlineAsm<'ll>(
         Ty: &'ll Type,
@@ -2119,6 +2112,17 @@ unsafe extern "C" {
         ConstraintsLen: size_t,
     ) -> bool;
 
+    /// Append inline assembly to a module. See `Module::appendModuleInlineAsm`.
+    pub(crate) fn LLVMRustAppendModuleInlineAsm(
+        M: &Module,
+        Asm: *const c_uchar, // See "PTR_LEN_STR".
+        AsmLen: size_t,
+        TargetFeatures: *const c_uchar, // See "PTR_LEN_STR".
+        TargetFeaturesLen: size_t,
+        TargetCpu: *const c_uchar, // See "PTR_LEN_STR".
+        TargetCpuLen: size_t,
+    );
+
     /// A list of pointer-length strings is passed as two pointer-length slices,
     /// one slice containing pointers and one slice containing their corresponding
     /// lengths. The implementation will check that both slices have the same length.

compiler/rustc_codegen_llvm/src/llvm/mod.rs

@@ -474,11 +474,24 @@ pub(crate) fn set_dso_local<'ll>(v: &'ll Value) {
     }
 }
 
-/// Safe wrapper for `LLVMAppendModuleInlineAsm`, which delegates to
+/// Safe wrapper for `LLVMRustAppendModuleInlineAsm`, which delegates to
 /// `Module::appendModuleInlineAsm`.
-pub(crate) fn append_module_inline_asm<'ll>(llmod: &'ll Module, asm: &[u8]) {
+pub(crate) fn append_module_inline_asm<'ll>(
+    llmod: &'ll Module,
+    asm: &[u8],
+    target_features: &str,
+    target_cpu: &str,
+) {
     unsafe {
-        LLVMAppendModuleInlineAsm(llmod, asm.as_ptr(), asm.len());
+        LLVMRustAppendModuleInlineAsm(
+            llmod,
+            asm.as_ptr(),
+            asm.len(),
+            target_features.as_ptr(),
+            target_features.len(),
+            target_cpu.as_ptr(),
+            target_cpu.len(),
+        );
     }
 }
 

compiler/rustc_graphviz/src/lib.rs

@@ -270,7 +270,7 @@
 //! * [DOT language](https://www.graphviz.org/doc/info/lang.html)
 
 // tidy-alphabetical-start
-#![doc(test(attr(allow(unused_variables), deny(warnings), allow(internal_features))))]
+#![doc(test(attr(allow(unused_variables), deny(warnings))))]
 // tidy-alphabetical-end
 
 use std::borrow::Cow;

compiler/rustc_lint_defs/src/builtin.rs

@@ -823,7 +823,7 @@ declare_lint! {
     ///
     /// ### Example
     ///
-    /// ```rust
+    /// ```rust,compile_fail
     /// #![deny(dead_code_pub_in_binary)]
     ///
     /// pub fn unused_pub_fn() {}
@@ -1132,9 +1132,9 @@ declare_lint! {
     ///
     /// ### Example
     ///
-    /// ```rust
+    /// ```rust,compile_fail
     /// #![deny(warnings)]
-    /// fn foo() {}
+    /// struct non_standard_name;
     /// ```
     ///
     /// {{produces}}

compiler/rustc_llvm/llvm-wrapper/RustWrapper.cpp

@@ -661,6 +661,20 @@ extern "C" bool LLVMRustInlineAsmVerify(LLVMTypeRef Ty, char *Constraints,
       unwrap<FunctionType>(Ty), StringRef(Constraints, ConstraintsLen)));
 }
 
+extern "C" void LLVMRustAppendModuleInlineAsm(
+    LLVMModuleRef M, const char *Asm, size_t AsmLen, const char *TargetFeatures,
+    size_t TargetFeaturesLen, const char *TargetCPU, size_t TargetCPULen) {
+#if LLVM_VERSION_GE(23, 0)
+  Module::GlobalAsmProperties Props;
+  Props.TargetFeatures = std::string(TargetFeatures, TargetFeaturesLen);
+  Props.TargetCPU = std::string(TargetCPU, TargetCPULen);
+  unwrap(M)->appendModuleInlineAsm(
+      Module::GlobalAsmFragment(std::string(Asm, AsmLen), Props));
+#else
+  unwrap(M)->appendModuleInlineAsm(StringRef(Asm, AsmLen));
+#endif
+}
+
 template <typename DIT> DIT *unwrapDIPtr(LLVMMetadataRef Ref) {
   return (DIT *)(Ref ? unwrap<Metadata>(Ref) : nullptr);
 }

compiler/rustc_parse_format/src/lib.rs

@@ -8,7 +8,7 @@
 // We want to be able to build this crate with a stable compiler,
 // so no `#![feature]` attributes should be added.
 #![deny(unstable_features)]
-#![doc(test(attr(deny(warnings), allow(internal_features))))]
+#![doc(test(attr(deny(warnings))))]
 // tidy-alphabetical-end
 
 use std::ops::Range;

compiler/rustc_public/src/lib.rs

@@ -43,7 +43,7 @@
 //! For more information, see <https://github.com/rust-lang/rustc_public>.
 
 #![allow(rustc::usage_of_ty_tykind)]
-#![doc(test(attr(allow(unused_variables), deny(warnings), allow(internal_features))))]
+#![doc(test(attr(allow(unused_variables), deny(warnings))))]
 #![feature(sized_hierarchy)]
 
 use std::fmt::Debug;

compiler/rustc_public_bridge/src/lib.rs

@@ -13,7 +13,7 @@
 
 // tidy-alphabetical-start
 #![allow(rustc::usage_of_ty_tykind)]
-#![doc(test(attr(allow(unused_variables), deny(warnings), allow(internal_features))))]
+#![doc(test(attr(allow(unused_variables), deny(warnings))))]
 #![feature(trait_alias)]
 // tidy-alphabetical-end
 

compiler/rustc_serialize/src/lib.rs

@@ -4,7 +4,7 @@
 #![allow(internal_features)]
 #![allow(rustc::internal)]
 #![cfg_attr(bootstrap, feature(never_type))]
-#![doc(test(attr(allow(unused_variables), deny(warnings), allow(internal_features))))]
+#![doc(test(attr(allow(unused_variables), deny(warnings))))]
 #![feature(core_intrinsics)]
 #![feature(min_specialization)]
 #![feature(nonzero_internals)]

compiler/rustc_session/src/config.rs

@@ -3647,11 +3647,14 @@ pub enum Polonius {
 
 impl Default for Polonius {
     fn default() -> Self {
-        if option_env!("CFG_DEFAULT_POLONIUS_NEXT").is_some() { Self::Next } else { Self::Off }
+        Self::DEFAULT
     }
 }
 
 impl Polonius {
+    pub(crate) const DEFAULT: Self =
+        if option_env!("CFG_DEFAULT_POLONIUS_NEXT").is_some() { Self::Next } else { Self::Off };
+
     /// Returns whether the legacy version of polonius is enabled
     pub fn is_legacy_enabled(&self) -> bool {
         matches!(self, Polonius::Legacy)

compiler/rustc_session/src/options.rs

@@ -510,7 +510,7 @@ macro_rules! options {
                 $( { TARGET_MODIFIER: $tmod_variant:ident } )?
                 $( { MITIGATION: $mitigation_variant:ident } )?
                 ,
-                $desc:literal
+                $desc:expr
                 $(, removed: $removed:ident )?
             ),
         )*
@@ -2350,6 +2350,12 @@ options! {
     // - src/doc/rustc/src/codegen-options/index.md
 }
 
+const POLONIUS_HELP: &str = match Polonius::DEFAULT {
+    Polonius::Off => "enable polonius-based borrow-checker (default: no)",
+    Polonius::Next => "enable polonius-based borrow-checker (default: next)",
+    Polonius::Legacy => panic!("Polonius::Legacy is not a valid default value"),
+};
+
 options! {
     UnstableOptions, UnstableOptionsTargetModifiers, Z_OPTIONS, dbopts, "Z", "unstable",
 
@@ -2750,7 +2756,7 @@ options! {
         `vt-ptr-type-discrimination - incorporate type discrimination in authenticated vtable pointers
         Example: `-Zpointer-authentication=+calls,-init-fini`."),
     polonius: Polonius = (Polonius::default(), parse_polonius, [TRACKED],
-        "enable polonius-based borrow-checker (default: no)"),
+        POLONIUS_HELP),
     pre_link_arg: (/* redirected to pre_link_args */) = ((), parse_string_push, [UNTRACKED],
         "a single extra argument to prepend the linker invocation (can be used several times)"),
     pre_link_args: Vec<String> = (Vec::new(), parse_list, [UNTRACKED],

compiler/rustc_target/src/asm/loongarch.rs

@@ -53,7 +53,7 @@ impl LoongArchInlineAsmRegClass {
             (Self::vreg, _) => {
                 if allow_experimental_reg {
                     types! {
-                        lsx: F16, F32, F64,
+                        lsx: I128, F16, F32, F64,
                             VecI8(16), VecI16(8), VecI32(4), VecI64(2), VecF32(4), VecF64(2);
                     }
                 } else {
@@ -63,7 +63,7 @@ impl LoongArchInlineAsmRegClass {
             (Self::xreg, _) => {
                 if allow_experimental_reg {
                     types! {
-                        lasx: F16, F32, F64,
+                        lasx: I128, F16, F32, F64,
                             VecI8(16), VecI16(8), VecI32(4), VecI64(2), VecF32(4), VecF64(2),
                             VecI8(32), VecI16(16), VecI32(8), VecI64(4), VecF32(8), VecF64(4);
                     }

compiler/rustc_traits/src/normalize_projection_ty.rs

@@ -59,12 +59,6 @@ fn normalize_canonicalized_projection<'tcx>(
                 0,
                 &mut obligations,
             );
-            obligations.extend(const_arg_has_type_obligation(
-                tcx,
-                param_env,
-                normalized_term,
-                goal,
-            ));
             ocx.register_obligations(obligations);
             // #112047: With projections and opaques, we are able to create opaques that
             // are recursive (given some generic parameters of the opaque's type variables).
@@ -147,12 +141,6 @@ fn normalize_canonicalized_inherent_projection<'tcx>(
                 0,
                 &mut obligations,
             );
-            obligations.extend(const_arg_has_type_obligation(
-                tcx,
-                param_env,
-                normalized_term,
-                goal,
-            ));
             ocx.register_obligations(obligations);
 
             Ok(NormalizationResult { normalized_term })

library/alloc/src/boxed/thin.rs

@@ -11,7 +11,7 @@ use core::marker::PhantomData;
 use core::marker::Unsize;
 #[cfg(not(no_global_oom_handling))]
 use core::mem;
-use core::mem::SizedTypeProperties;
+use core::mem::{DropGuard, SizedTypeProperties};
 use core::ops::{Deref, DerefMut};
 use core::ptr::{self, NonNull, Pointee};
 
@@ -360,38 +360,23 @@ impl<H> WithHeader<H> {
     // - Assumes that either `value` can be dereferenced, or is the
     //   `NonNull::dangling()` we use when both `T` and `H` are ZSTs.
     unsafe fn drop<T: ?Sized>(&self, value: *mut T) {
-        struct DropGuard<H> {
-            ptr: NonNull<u8>,
-            value_layout: Layout,
-            _marker: PhantomData<H>,
-        }
-
-        impl<H> Drop for DropGuard<H> {
-            fn drop(&mut self) {
-                // All ZST are allocated statically.
-                if self.value_layout.size() == 0 {
-                    return;
-                }
+        unsafe {
+            // `_guard` will deallocate the memory when dropped, even if `drop_in_place` unwinds.
+            let _guard =
+                DropGuard::new((self.0, Layout::for_value_raw(value)), |(ptr, value_layout)| {
+                    // All ZST are allocated statically.
+                    if value_layout.size() == 0 {
+                        return;
+                    }
 
-                unsafe {
                     // SAFETY: Layout must have been computable if we're in drop
                     let (layout, value_offset) =
-                        WithHeader::<H>::alloc_layout(self.value_layout).unwrap_unchecked();
+                        WithHeader::<H>::alloc_layout(value_layout).unwrap_unchecked();
 
                     // Since we only allocate for non-ZSTs, the layout size cannot be zero.
-                    debug_assert!(layout.size() != 0);
-                    alloc::dealloc(self.ptr.as_ptr().sub(value_offset), layout);
-                }
-            }
-        }
-
-        unsafe {
-            // `_guard` will deallocate the memory when dropped, even if `drop_in_place` unwinds.
-            let _guard = DropGuard {
-                ptr: self.0,
-                value_layout: Layout::for_value_raw(value),
-                _marker: PhantomData::<H>,
-            };
+                    debug_assert_ne!(layout.size(), 0);
+                    alloc::dealloc(ptr.as_ptr().sub(value_offset), layout);
+                });
 
             // We only drop the value because the Pointee trait requires that the metadata is copy
             // aka trivially droppable.