Rollup of 10 pull requests

compiler/rustc_abi/src/extern_abi.rs

@@ -369,6 +369,43 @@ impl ExternAbi {
             | Self::Swift => true,
         }
     }
+
+    /// Returns whether safe functions with this ABI implement the `Fn` traits.
+    /// `false` only for uncallable or internal ABIs.
+    pub fn is_fn_trait_compatible(self) -> bool {
+        match self {
+            ExternAbi::C { .. }
+            | ExternAbi::System { .. }
+            | ExternAbi::Rust
+            | ExternAbi::RustCold
+            | ExternAbi::RustPreserveNone
+            | ExternAbi::RustTail
+            | ExternAbi::EfiApi
+            | ExternAbi::Swift
+            | ExternAbi::Aapcs { .. }
+            | ExternAbi::CmseNonSecureCall
+            | ExternAbi::CmseNonSecureEntry
+            | ExternAbi::Cdecl { .. }
+            | ExternAbi::Stdcall { .. }
+            | ExternAbi::Fastcall { .. }
+            | ExternAbi::Thiscall { .. }
+            | ExternAbi::Vectorcall { .. }
+            | ExternAbi::SysV64 { .. }
+            | ExternAbi::Win64 { .. } => true,
+            ExternAbi::RustCall
+            | ExternAbi::RustInvalid
+            | ExternAbi::LlvmIntrinsic
+            | ExternAbi::Custom
+            | ExternAbi::GpuKernel
+            | ExternAbi::PtxKernel
+            | ExternAbi::AvrInterrupt
+            | ExternAbi::AvrNonBlockingInterrupt
+            | ExternAbi::Msp430Interrupt
+            | ExternAbi::RiscvInterruptM
+            | ExternAbi::RiscvInterruptS
+            | ExternAbi::X86Interrupt => false,
+        }
+    }
 }
 
 pub fn all_names() -> Vec<&'static str> {

compiler/rustc_attr_ir/src/data_structures.rs

@@ -503,7 +503,7 @@ pub struct DocAttribute {
     pub keyword: Option<(Symbol, Span)>,
     pub attribute: Option<(Symbol, Span)>,
     pub masked: Option<Span>,
-    pub notable_trait: Option<Span>,
+    pub notable_trait: Option<(Option<(NotableTraitColor, Span)>, Span)>,
     pub search_unbox: Option<Span>,
 
     // valid on crate
@@ -520,6 +520,41 @@ pub struct DocAttribute {
     pub no_crate_inject: Option<Span>,
 }
 
+#[derive(Clone, Copy, Debug, Eq, PartialEq)]
+#[derive(StableHash, Encodable, Decodable, PrintAttribute)]
+pub enum NotableTraitColor {
+    Grey,
+    Red,
+    Green,
+    Yellow,
+    Blue,
+    Magenta,
+    Cyan,
+    Transparent,
+}
+
+impl From<NotableTraitColor> for &'static str {
+    fn from(color: NotableTraitColor) -> &'static str {
+        use NotableTraitColor::*;
+        match color {
+            Grey => "grey",
+            Red => "red",
+            Green => "green",
+            Yellow => "yellow",
+            Blue => "blue",
+            Magenta => "magenta",
+            Cyan => "cyan",
+            Transparent => "transparent",
+        }
+    }
+}
+
+impl std::fmt::Display for NotableTraitColor {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        f.write_str((*self).into())
+    }
+}
+
 impl<E: rustc_span::SpanEncoder> rustc_serialize::Encodable<E> for DocAttribute {
     fn encode(&self, encoder: &mut E) {
         let DocAttribute {

compiler/rustc_attr_parsing/src/attributes/doc.rs

@@ -2,7 +2,7 @@ use rustc_ast::ast::{AttrStyle, LitKind, MetaItemLit};
 use rustc_attr_ir::target::{AstTarget, ConstTypeAstTarget, Target};
 use rustc_attr_ir::{
     AttributeKind, CfgEntry, CfgHideShow, DocAttribute, DocCfgHideShow, DocCfgHideShowValue,
-    DocInline, HideOrShow,
+    DocInline, HideOrShow, NotableTraitColor,
 };
 use rustc_data_structures::fx::{FxHashSet, FxIndexMap, IndexEntry};
 use rustc_errors::{Applicability, MultiSpan, msg};
@@ -15,13 +15,14 @@ use super::{AcceptMapping, AttributeParser, template};
 use crate::context::{AcceptContext, FinalizeContext};
 use crate::diagnostics::{
     DocAliasBadChar, DocAliasDuplicated, DocAliasEmpty, DocAliasMalformed, DocAliasStartEnd,
-    DocAttrNotCrateLevel, DocAttributeNotAttribute, DocAutoCfgExpectsHideOrShow,
-    DocAutoCfgHideShowExpectsList, DocAutoCfgHideShowNoIdentBeforeValues,
-    DocAutoCfgHideShowUnexpectedItem, DocAutoCfgHideShowUnexpectedItemAfterValues,
-    DocAutoCfgHideShowValuesMix, DocAutoCfgWrongLiteral, DocInlineConflict, DocInlineOnlyUse,
-    DocKeywordAttributeNotAnonConst, DocKeywordNotKeyword, DocTestLiteral, DocTestTakesList,
-    DocTestUnknown, DocUnknownAny, DocUnknownInclude, DocUnknownPasses, DocUnknownPlugins,
-    DocUnknownSpotlight, ExpectedNameValue, ExpectedNoArgs, IllFormedAttributeInput, MalformedDoc,
+    DocAttrNotCrateLevel, DocAttrNotTraitLevel, DocAttributeNotAttribute,
+    DocAutoCfgExpectsHideOrShow, DocAutoCfgHideShowExpectsList,
+    DocAutoCfgHideShowNoIdentBeforeValues, DocAutoCfgHideShowUnexpectedItem,
+    DocAutoCfgHideShowUnexpectedItemAfterValues, DocAutoCfgHideShowValuesMix,
+    DocAutoCfgWrongLiteral, DocInlineConflict, DocInlineOnlyUse, DocKeywordAttributeNotAnonConst,
+    DocKeywordNotKeyword, DocTestLiteral, DocTestTakesList, DocTestUnknown, DocUnknownAny,
+    DocUnknownInclude, DocUnknownPasses, DocUnknownPlugins, DocUnknownSpotlight, ExpectedNameValue,
+    ExpectedNoArgs, IllFormedAttributeInput, InvalidNotableTraitAttr, MalformedDoc,
     UnusedDuplicate,
 };
 use crate::parser::{
@@ -85,6 +86,82 @@ fn expected_string_literal(
     cx.emit_lint(INVALID_DOC_ATTRIBUTES, MalformedDoc, span);
 }
 
+fn parse_notable_trait(
+    cx: &mut AcceptContext<'_, '_>,
+    path: &OwnedPathParser,
+    args: &ArgParser,
+    attr_value: &mut Option<(Option<(NotableTraitColor, Span)>, Span)>,
+    attr_name: Symbol,
+) {
+    let span = path.span();
+
+    let notable_trait_color_attr = match args {
+        ArgParser::NoArgs => None,
+        ArgParser::List(meta_item_list_parser) => {
+            if meta_item_list_parser.is_empty() {
+                None
+            } else if let Some(meta_item) = meta_item_list_parser.as_single() {
+                Some(meta_item)
+            } else {
+                cx.emit_lint(INVALID_DOC_ATTRIBUTES, InvalidNotableTraitAttr, span);
+                return;
+            }
+        }
+        ArgParser::NameValue(_) => {
+            // FIXME(164728): every invalid notable trait attribute lint produces exactly
+            // the same warning and we should switch to more specific diagnostics
+            cx.emit_lint(INVALID_DOC_ATTRIBUTES, InvalidNotableTraitAttr, span);
+            return;
+        }
+    };
+
+    let notable_trait_color_and_span =
+        if let Some(notable_trait_color_attr) = notable_trait_color_attr {
+            let Some(notable_trait_color_attr) = notable_trait_color_attr.meta_item() else {
+                // FIXME(164728): every invalid notable trait attribute lint produces exactly
+                // the same warning and we should switch to more specific diagnostics
+                cx.emit_lint(INVALID_DOC_ATTRIBUTES, InvalidNotableTraitAttr, span);
+                return;
+            };
+            if !notable_trait_color_attr.path().word_is(sym::color) {
+                cx.emit_lint(INVALID_DOC_ATTRIBUTES, InvalidNotableTraitAttr, span);
+                return;
+            }
+            let Some(notable_trait_color) = notable_trait_color_attr.args().as_name_value() else {
+                cx.emit_lint(INVALID_DOC_ATTRIBUTES, InvalidNotableTraitAttr, span);
+                return;
+            };
+            let Some(notable_trait_color) = notable_trait_color.value_as_str() else {
+                cx.emit_lint(INVALID_DOC_ATTRIBUTES, InvalidNotableTraitAttr, span);
+                return;
+            };
+            let notable_trait_color = match notable_trait_color.as_str() {
+                "grey" | "gray" => NotableTraitColor::Grey,
+                "red" => NotableTraitColor::Red,
+                "green" => NotableTraitColor::Green,
+                "yellow" => NotableTraitColor::Yellow,
+                "blue" => NotableTraitColor::Blue,
+                "magenta" => NotableTraitColor::Magenta,
+                "cyan" => NotableTraitColor::Cyan,
+                "transparent" => NotableTraitColor::Transparent,
+                _ => {
+                    cx.emit_lint(INVALID_DOC_ATTRIBUTES, InvalidNotableTraitAttr, span);
+                    return;
+                }
+            };
+            Some((notable_trait_color, notable_trait_color_attr.span()))
+        } else {
+            None
+        };
+
+    if cx.shared.target != Target::Trait {
+        cx.emit_lint(INVALID_DOC_ATTRIBUTES, DocAttrNotTraitLevel { span, attr_name }, span);
+        return;
+    }
+
+    *attr_value = Some((notable_trait_color_and_span, span));
+}
+
 fn parse_keyword_and_attribute(
     cx: &mut AcceptContext<'_, '_>,
     path: &OwnedPathParser,
@@ -174,14 +251,14 @@ impl DocParser {
             }
             Some(sym::attr) => {
                 let Some(list) = args.as_list() else {
-                    // FIXME: remove this method once merged and uncomment the line below instead.
-                    // cx.expected_list(cx.attr_span, args);
+                    // FIXME(164728): remove this method once merged and uncomment the line
+                    // below instead. cx.expected_list(cx.attr_span, args);
                     let span = cx.attr_span;
                     cx.emit_lint(INVALID_DOC_ATTRIBUTES, MalformedDoc, span);
                     return;
                 };
-
-                // FIXME: convert list into a Vec of `AttributeKind` because current code is awful.
+                // FIXME(164728): remove this method once merged and uncomment the line
+                // below instead. cx.expected_list(cx.attr_span, args);
                 for attr in list.mixed() {
                     // Arguments of `attr` are checked via the span, so can be safely ignored
                     attr.ignore_args();
@@ -621,7 +698,13 @@ impl DocParser {
             }
             Some(sym::notable_trait) => {
                 gated!(doc_notable_trait);
-                no_args!(notable_trait)
+                parse_notable_trait(
+                    cx,
+                    path,
+                    args,
+                    &mut self.attribute.notable_trait,
+                    sym::notable_trait,
+                )
             }
             Some(sym::keyword) => {
                 gated!(rustdoc_internals);

compiler/rustc_attr_parsing/src/diagnostics.rs

@@ -400,6 +400,13 @@ pub(crate) struct ExpectedNoArgs;
 )]
 pub(crate) struct ExpectedNameValue;
 
+#[derive(Diagnostic)]
+#[diag("expected either `doc(notable_trait)` or `doc(notable_trait(color=\"...\"))`")]
+#[warning(
+    "this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!"
+)]
+pub(crate) struct InvalidNotableTraitAttr;
+
 #[derive(Diagnostic)]
 #[diag("malformed `{$attribute}` attribute")]
 #[help("{$options}")]
@@ -1052,6 +1059,17 @@ pub(crate) struct DocAttributeNotAttribute {
     pub attribute: Symbol,
 }
 
+#[derive(Diagnostic)]
+#[diag("`#![doc({$attr_name})]` must be a trait attribute")]
+#[warning(
+    "this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!"
+)]
+pub(crate) struct DocAttrNotTraitLevel {
+    #[primary_span]
+    pub span: Span,
+    pub attr_name: Symbol,
+}
+
 #[derive(Diagnostic)]
 #[diag(
     "`#[target_feature]` cannot be applied to a {$kind ->

compiler/rustc_codegen_cranelift/patches/0028-sysroot_tests-Disable-long-running-tests.patch

@@ -46,16 +46,6 @@ index 8402833..84592e0 100644
  split_off_tests! {
      slice: &mut [(); usize::MAX], method: split_off_mut,
      (split_off_mut_in_bounds_max_range_to, (..usize::MAX), Some(empty_max_mut!()), &mut [(); 0]),
-diff --git a/alloctests/tests/sort/tests.rs b/alloctests/tests/sort/tests.rs
-index d321f8d..8b2040a 100644
---- a/alloctests/tests/sort/tests.rs
-+++ b/alloctests/tests/sort/tests.rs
-@@ -1,3 +1,5 @@
-+#![cfg(any())]
-+
- use std::cell::Cell;
- use std::cmp::Ordering;
- use std::fmt::Debug;
 diff --git a/alloctests/tests/str.rs b/alloctests/tests/str.rs
 index 906fa2d..b82fa99 100644
 --- a/alloctests/tests/str.rs

compiler/rustc_codegen_llvm/src/back/llvm_backend.rs

@@ -443,7 +443,7 @@ impl CodegenBackend for LlvmCodegenBackend {
 
 pub struct ModuleLlvm {
     llcx_raw: ptr::NonNull<llvm::ContextRaw>,
-    llmod_raw: *const llvm::Module,
+    llmod_raw: ptr::NonNull<llvm::ModuleRaw>,
 
     // This field is `ManuallyDrop` because it is important that the `TargetMachine`
     // is disposed prior to the `Context` being disposed otherwise UAFs can occur.
@@ -461,22 +461,15 @@ pub struct ModuleLlvm {
 // `ModuleLlvm` owns the context and only allows borrowing LLVM objects tied to the context.
 unsafe impl Send for ModuleLlvm {}
 
-/// Converts an unbranded pointer-to-context to a lifetime-branded [`llvm::Context`].
-///
-/// # Safety
-/// - The pointer must be a valid LLVM context.
-/// - If the context is passed to safe code, its caller-requested lifetime must be distinct
-///   from that of any other context, and must not outlive the underlying context.
-unsafe fn wrap_llcx<'ll>(llcx_raw: ptr::NonNull<llvm::ContextRaw>) -> llvm::Context<'ll> {
-    llvm::Context { llcx_raw, _invariant_ll: PhantomData }
-}
-
 /// Shared helper to call [`llvm::LLVMContextCreate`] and then configure
 /// [`llvm::LLVMContextSetDiscardValueNames`].
 fn create_context_and_set_fewer_names(fewer_names: bool) -> ptr::NonNull<llvm::ContextRaw> {
     unsafe {
         let llcx_raw = llvm::LLVMContextCreate();
-        llvm::LLVMContextSetDiscardValueNames(wrap_llcx(llcx_raw), fewer_names.to_llvm_bool());
+        llvm::LLVMContextSetDiscardValueNames(
+            llvm::wrap_llcx(llcx_raw),
+            fewer_names.to_llvm_bool(),
+        );
         llcx_raw
     }
 }
@@ -485,7 +478,8 @@ impl ModuleLlvm {
     pub(crate) fn new(tcx: TyCtxt<'_>, mod_name: &str) -> Self {
         unsafe {
             let llcx_raw = create_context_and_set_fewer_names(tcx.sess.fewer_names());
-            let llmod_raw = context::create_module(tcx, wrap_llcx(llcx_raw), mod_name);
+            let llmod_raw =
+                context::create_module(tcx, llvm::wrap_llcx(llcx_raw), mod_name).llmod_raw();
             ModuleLlvm {
                 llmod_raw,
                 llcx_raw,
@@ -498,7 +492,8 @@ impl ModuleLlvm {
     pub(crate) fn new_metadata(tcx: TyCtxt<'_>, mod_name: &str) -> Self {
         unsafe {
             let llcx_raw = create_context_and_set_fewer_names(tcx.sess.fewer_names());
-            let llmod_raw = context::create_module(tcx, wrap_llcx(llcx_raw), mod_name);
+            let llmod_raw =
+                context::create_module(tcx, llvm::wrap_llcx(llcx_raw), mod_name).llmod_raw();
             ModuleLlvm {
                 llmod_raw,
                 llcx_raw,
@@ -517,7 +512,8 @@ impl ModuleLlvm {
     ) -> Self {
         unsafe {
             let llcx_raw = create_context_and_set_fewer_names(cgcx.fewer_names);
-            let llmod_raw = back::lto::parse_module(wrap_llcx(llcx_raw), name, buffer, dcx);
+            let llmod_raw =
+                back::lto::parse_module(llvm::wrap_llcx(llcx_raw), name, buffer, dcx).llmod_raw();
             let tm = tm_factory(dcx, TargetMachineFactoryConfig::new(cgcx, name.to_str().unwrap()));
 
             ModuleLlvm {
@@ -538,12 +534,9 @@ impl ModuleLlvm {
         &self,
         inner_fn: impl for<'ll> FnOnce(ModuleRefs<'ll>) -> R,
     ) -> R {
-        inner_fn(ModuleRefs {
-            llcx: unsafe { wrap_llcx(self.llcx_raw) },
-            llmod: unsafe { &*self.llmod_raw },
-            tm: self.tm.raw(),
-            _ph: PhantomData,
-        })
+        let llcx = unsafe { llvm::wrap_llcx(self.llcx_raw) };
+        let llmod = unsafe { llvm::wrap_llmod(llcx, self.llmod_raw) };
+        inner_fn(ModuleRefs { llcx, llmod, tm: self.tm.raw(), _ph: PhantomData })
     }
 }
 
@@ -560,7 +553,7 @@ impl Drop for ModuleLlvm {
 #[derive(Clone, Copy)]
 pub(crate) struct ModuleRefs<'ll> {
     pub(crate) llcx: llvm::Context<'ll>,
-    pub(crate) llmod: &'ll llvm::Module,
+    pub(crate) llmod: llvm::Module<'ll>,
     pub(crate) tm: &'ll llvm::TargetMachine,
     /// Make sure `'ll` is invariant, even if no fields happen to require that.
     ///