Rollup of 3 pull requests

compiler/rustc_ast_lowering/src/item.rs

@@ -1397,7 +1397,7 @@ impl<'hir> LoweringContext<'_, 'hir> {
             // create a fake body so that the entire rest of the compiler doesn't have to deal with
             // this as a special case.
             return self.lower_fn_body(decl, contract, |this| {
-                if attrs.iter().any(|a| a.has_name(sym::rustc_intrinsic))
+                if find_attr!(attrs, AttributeKind::RustcIntrinsic)
                     || this.tcx.is_sdylib_interface_build()
                 {
                     let span = this.lower_span(span);

compiler/rustc_attr_parsing/src/attributes/rustc_internal.rs

@@ -490,6 +490,7 @@ impl<S: Stage> CombineAttributeParser<S> for RustcMirParser {
             .collect()
     }
 }
+
 pub(crate) struct RustcNonConstTraitMethodParser;
 
 impl<S: Stage> NoArgsAttributeParser<S> for RustcNonConstTraitMethodParser {
@@ -721,6 +722,8 @@ impl<S: Stage> CombineAttributeParser<S> for RustcThenThisWouldNeedParser {
         Some(ident)
     }
 }
+<<<<<<< Conflict 1 of 1
++++++++ Contents of side #1
 
 pub(crate) struct RustcEffectiveVisibilityParser;
 
@@ -760,3 +763,21 @@ impl<S: Stage> NoArgsAttributeParser<S> for RustcEffectiveVisibilityParser {
     ]);
     const CREATE: fn(Span) -> AttributeKind = |_| AttributeKind::RustcEffectiveVisibility;
 }
+
+pub(crate) struct RustcIntrinsicParser;
+
+impl<S: Stage> NoArgsAttributeParser<S> for RustcIntrinsicParser {
+    const PATH: &'static [Symbol] = &[sym::rustc_intrinsic];
+    const ON_DUPLICATE: OnDuplicate<S> = OnDuplicate::Error;
+    const ALLOWED_TARGETS: AllowedTargets = AllowedTargets::AllowList(&[Allow(Target::Fn)]);
+    const CREATE: fn(Span) -> AttributeKind = |_| AttributeKind::RustcIntrinsic;
+}
+
+pub(crate) struct RustcIntrinsicConstStableIndirectParser;
+
+impl<S: Stage> NoArgsAttributeParser<S> for RustcIntrinsicConstStableIndirectParser {
+    const PATH: &'static [Symbol] = &[sym::rustc_intrinsic_const_stable_indirect];
+    const ON_DUPLICATE: OnDuplicate<S> = OnDuplicate::Error;
+    const ALLOWED_TARGETS: AllowedTargets = AllowedTargets::AllowList(&[Allow(Target::Fn)]);
+    const CREATE: fn(Span) -> AttributeKind = |_| AttributeKind::RustcIntrinsicConstStableIndirect;
+}

compiler/rustc_attr_parsing/src/context.rs

@@ -262,6 +262,8 @@ attribute_parsers!(
         Single<WithoutArgs<RustcEffectiveVisibilityParser>>,
         Single<WithoutArgs<RustcHasIncoherentInherentImplsParser>>,
         Single<WithoutArgs<RustcHiddenTypeOfOpaquesParser>>,
+        Single<WithoutArgs<RustcIntrinsicConstStableIndirectParser>>,
+        Single<WithoutArgs<RustcIntrinsicParser>>,
         Single<WithoutArgs<RustcLintOptTyParser>>,
         Single<WithoutArgs<RustcLintQueryInstabilityParser>>,
         Single<WithoutArgs<RustcLintUntrackedQueryInformationParser>>,

compiler/rustc_codegen_llvm/src/errors.rs

@@ -214,5 +214,5 @@ pub(crate) struct FixedX18InvalidArch<'a> {
 }
 
 #[derive(Diagnostic)]
-#[diag("`-Zsanitizer-kcfi-arity` requires LLVM 21.0.0 or later.")]
+#[diag("`-Zsanitizer-kcfi-arity` requires LLVM 21.0.0 or later")]
 pub(crate) struct SanitizerKcfiArityRequiresLLVM2100;

compiler/rustc_codegen_ssa/src/errors.rs

@@ -59,7 +59,7 @@ pub(crate) struct MissingQueryDepGraph {
 
 #[derive(Diagnostic)]
 #[diag(
-    "found malformed codegen unit name `{$user_path}`. codegen units names must always start with the name of the crate (`{$crate_name}` in this case)."
+    "found malformed codegen unit name `{$user_path}`. codegen units names must always start with the name of the crate (`{$crate_name}` in this case)"
 )]
 pub(crate) struct MalformedCguName {
     #[primary_span]
@@ -562,12 +562,12 @@ pub(crate) struct SelfContainedLinkerMissing;
 
 #[derive(Diagnostic)]
 #[diag(
-    "please ensure that Visual Studio 2017 or later, or Build Tools for Visual Studio were installed with the Visual C++ option."
+    "please ensure that Visual Studio 2017 or later, or Build Tools for Visual Studio were installed with the Visual C++ option"
 )]
 pub(crate) struct CheckInstalledVisualStudio;
 
 #[derive(Diagnostic)]
-#[diag("VS Code is a different product, and is not sufficient.")]
+#[diag("VS Code is a different product, and is not sufficient")]
 pub(crate) struct InsufficientVSCodeProduct;
 
 #[derive(Diagnostic)]
@@ -610,13 +610,13 @@ pub(crate) struct LinkerFileStem;
 
 #[derive(Diagnostic)]
 #[diag(
-    "link against the following native artifacts when linking against this static library. The order and any duplication can be significant on some platforms."
+    "link against the following native artifacts when linking against this static library. The order and any duplication can be significant on some platforms"
 )]
 pub(crate) struct StaticLibraryNativeArtifacts;
 
 #[derive(Diagnostic)]
 #[diag(
-    "native artifacts to link against have been written to {$path}. The order and any duplication can be significant on some platforms."
+    "native artifacts to link against have been written to {$path}. The order and any duplication can be significant on some platforms"
 )]
 pub(crate) struct StaticLibraryNativeArtifactsToFile<'a> {
     pub path: &'a Path,

compiler/rustc_const_eval/src/errors.rs

@@ -309,7 +309,7 @@ pub(crate) struct UnallowedHeapAllocations {
     pub span: Span,
     pub kind: ConstContext,
     #[note(
-        "The runtime heap is not yet available at compile-time, so no runtime heap allocations can be created."
+        "the runtime heap is not yet available at compile-time, so no runtime heap allocations can be created"
     )]
     pub teach: bool,
 }
@@ -347,7 +347,7 @@ pub(crate) struct InteriorMutableBorrowEscaping {
 #[diag("constant evaluation is taking a long time")]
 #[note(
     "this lint makes sure the compiler doesn't get stuck due to infinite loops in const eval.
-    If your compilation actually takes a long time, you can safely allow the lint."
+    If your compilation actually takes a long time, you can safely allow the lint"
 )]
 pub struct LongRunning {
     #[help("the constant being evaluated")]

compiler/rustc_driver_impl/src/session_diagnostics.rs

@@ -51,7 +51,7 @@ pub(crate) struct RlinkCorruptFile<'a> {
 }
 
 #[derive(Diagnostic)]
-#[diag("the compiler unexpectedly panicked. this is a bug.")]
+#[diag("the compiler unexpectedly panicked. This is a bug")]
 pub(crate) struct Ice;
 
 #[derive(Diagnostic)]

compiler/rustc_feature/src/unstable.rs

@@ -373,6 +373,8 @@ declare_features! (
     (unstable, async_for_loop, "1.77.0", Some(118898)),
     /// Allows `async` trait bound modifier.
     (unstable, async_trait_bounds, "1.85.0", Some(62290)),
+    /// Target features on avr.
+    (unstable, avr_target_feature, "CURRENT_RUSTC_VERSION", Some(146889)),
     /// Allows using Intel AVX10 target features and intrinsics
     (unstable, avx10_target_feature, "1.88.0", Some(138843)),
     /// Target features on bpf.

compiler/rustc_hir/src/attrs/data_structures.rs

@@ -1117,6 +1117,12 @@ pub enum AttributeKind {
     /// Represents `#[rustc_if_this_changed]`
     RustcIfThisChanged(Span, Option<Symbol>),
 
+    /// Represents `#[rustc_intrinsic]`
+    RustcIntrinsic,
+
+    /// Represents `#[rustc_intrinsic_const_stable_indirect]`
+    RustcIntrinsicConstStableIndirect,
+
     /// Represents `#[rustc_layout]`
     RustcLayout(ThinVec<RustcLayoutType>),
 

compiler/rustc_hir/src/attrs/encode_cross_crate.rs

@@ -117,6 +117,8 @@ impl AttributeKind {
             RustcHasIncoherentInherentImpls => Yes,
             RustcHiddenTypeOfOpaques => No,
             RustcIfThisChanged(..) => No,
+            RustcIntrinsic => Yes,
+            RustcIntrinsicConstStableIndirect => No,
             RustcLayout(..) => No,
             RustcLayoutScalarValidRangeEnd(..) => Yes,
             RustcLayoutScalarValidRangeStart(..) => Yes,

compiler/rustc_hir_typeck/src/errors.rs

@@ -1145,7 +1145,7 @@ pub(crate) struct CastThinPointerToWidePointer<'tcx> {
     pub expr_ty: Ty<'tcx>,
     pub cast_ty: Ty<'tcx>,
     #[note(
-        "Thin pointers are \"simple\" pointers: they are purely a reference to a
+        "thin pointers are \"simple\" pointers: they are purely a reference to a
         memory address.
 
         Wide pointers are pointers referencing \"Dynamically Sized Types\" (also

compiler/rustc_incremental/src/errors.rs

@@ -281,7 +281,7 @@ pub(crate) struct DeleteWorkProduct<'a> {
 
 #[derive(Diagnostic)]
 #[diag(
-    "corrupt incremental compilation artifact found at `{$path}`. This file will automatically be ignored and deleted. If you see this message repeatedly or can provoke it without manually manipulating the compiler's artifacts, please file an issue. The incremental compilation system relies on hardlinks and filesystem locks behaving correctly, and may not deal well with OS crashes, so whatever information you can provide about your filesystem or other state may be very relevant."
+    "corrupt incremental compilation artifact found at `{$path}`. This file will automatically be ignored and deleted. If you see this message repeatedly or can provoke it without manually manipulating the compiler's artifacts, please file an issue. The incremental compilation system relies on hardlinks and filesystem locks behaving correctly, and may not deal well with OS crashes, so whatever information you can provide about your filesystem or other state may be very relevant"
 )]
 pub(crate) struct CorruptFile<'a> {
     pub path: &'a Path,

compiler/rustc_macros/src/diagnostics/message.rs

@@ -23,9 +23,7 @@ impl Message {
                 quote! { crate::fluent_generated::#slug }
             }
             Message::Inline(message_span, message) => {
-                if let Some(variant) = variant {
-                    verify_fluent_message(*message_span, &message, variant);
-                }
+                verify_fluent_message(*message_span, &message, variant);
                 quote! { rustc_errors::DiagMessage::Inline(std::borrow::Cow::Borrowed(#message)) }
             }
         }
@@ -86,30 +84,37 @@ impl Message {
     }
 }
 
-fn verify_fluent_message(msg_span: Span, message: &str, variant: &VariantInfo<'_>) {
+fn verify_fluent_message(msg_span: Span, message_str: &str, variant: Option<&VariantInfo<'_>>) {
     // Parse the fluent message
     const GENERATED_MSG_ID: &str = "generated_msg";
-    let resource = FluentResource::try_new(format!("{GENERATED_MSG_ID} = {message}\n")).unwrap();
+    let resource =
+        FluentResource::try_new(format!("{GENERATED_MSG_ID} = {message_str}\n")).unwrap();
     assert_eq!(resource.entries().count(), 1);
     let Some(fluent_syntax::ast::Entry::Message(message)) = resource.get_entry(0) else {
         panic!("Did not parse into a message")
     };
 
     // Check if all variables are used
-    let fields: Vec<String> = variant
-        .bindings()
-        .iter()
-        .flat_map(|b| b.ast().ident.as_ref())
-        .map(|id| id.to_string())
-        .collect();
-    for variable in variable_references(&message) {
-        if !fields.iter().any(|f| f == variable) {
-            span_err(msg_span.unwrap(), format!("Variable `{variable}` not found in diagnostic "))
+    if let Some(variant) = variant {
+        let fields: Vec<String> = variant
+            .bindings()
+            .iter()
+            .flat_map(|b| b.ast().ident.as_ref())
+            .map(|id| id.to_string())
+            .collect();
+        for variable in variable_references(&message) {
+            if !fields.iter().any(|f| f == variable) {
+                span_err(
+                    msg_span.unwrap(),
+                    format!("Variable `{variable}` not found in diagnostic "),
+                )
                 .help(format!("Available fields: {:?}", fields.join(", ")))
                 .emit();
+            }
         }
-        // assert!(, );
     }
+
+    verify_message_style(msg_span, message_str);
 }
 
 fn variable_references<'a>(msg: &fluent_syntax::ast::Message<&'a str>) -> Vec<&'a str> {
@@ -136,3 +141,40 @@ fn variable_references<'a>(msg: &fluent_syntax::ast::Message<&'a str>) -> Vec<&'
     }
     refs
 }
+
+const ALLOWED_CAPITALIZED_WORDS: &[&str] = &[
+    // tidy-alphabetical-start
+    "ABI",
+    "ABIs",
+    "ADT",
+    "C-variadic",
+    "CGU-reuse",
+    "Cargo",
+    "Ferris",
+    "GCC",
+    "MIR",
+    "NaNs",
+    "OK",
+    "VS",
+    // tidy-alphabetical-end
+];
+
+/// See: https://rustc-dev-guide.rust-lang.org/diagnostics.html#diagnostic-output-style-guide
+fn verify_message_style(msg_span: Span, message: &str) {
+    // Verify that message starts with lowercase char
+    let Some(first_word) = message.split_whitespace().next() else {
+        span_err(msg_span.unwrap(), "message must not be empty").emit();
+        return;
+    };
+    let first_char = first_word.chars().next().expect("Word is not empty");
+    if first_char.is_uppercase() && !ALLOWED_CAPITALIZED_WORDS.contains(&first_word) {
+        span_err(msg_span.unwrap(), "message `{value}` starts with an uppercase letter. Fix it or add it to `ALLOWED_CAPITALIZED_WORDS`").emit();
+        return;
+    }
+
+    // Verify that message does not end in `.`
+    if message.ends_with(".") && !message.ends_with("...") {
+        span_err(msg_span.unwrap(), "message `{value}` ends with a period").emit();
+        return;
+    }
+}

compiler/rustc_middle/src/ty/util.rs

@@ -10,11 +10,11 @@ use rustc_data_structures::stable_hasher::{HashStable, StableHasher};
 use rustc_data_structures::stack::ensure_sufficient_stack;
 use rustc_errors::ErrorGuaranteed;
 use rustc_hashes::Hash128;
-use rustc_hir as hir;
 use rustc_hir::attrs::AttributeKind;
 use rustc_hir::def::{CtorOf, DefKind, Res};
 use rustc_hir::def_id::{CrateNum, DefId, LocalDefId};
 use rustc_hir::limit::Limit;
+use rustc_hir::{self as hir, find_attr};
 use rustc_index::bit_set::GrowableBitSet;
 use rustc_macros::{HashStable, TyDecodable, TyEncodable, extension};
 use rustc_span::sym;
@@ -1679,7 +1679,9 @@ pub fn is_doc_notable_trait(tcx: TyCtxt<'_>, def_id: DefId) -> bool {
 /// the compiler to make some assumptions about its shape; if the user doesn't use a feature gate, they may
 /// cause an ICE that we otherwise may want to prevent.
 pub fn intrinsic_raw(tcx: TyCtxt<'_>, def_id: LocalDefId) -> Option<ty::IntrinsicDef> {
-    if tcx.features().intrinsics() && tcx.has_attr(def_id, sym::rustc_intrinsic) {
+    if tcx.features().intrinsics()
+        && find_attr!(tcx.get_all_attrs(def_id), AttributeKind::RustcIntrinsic)
+    {
         let must_be_overridden = match tcx.hir_node_by_def_id(def_id) {
             hir::Node::Item(hir::Item { kind: hir::ItemKind::Fn { has_body, .. }, .. }) => {
                 !has_body
@@ -1689,7 +1691,10 @@ pub fn intrinsic_raw(tcx: TyCtxt<'_>, def_id: LocalDefId) -> Option<ty::Intrinsi
         Some(ty::IntrinsicDef {
             name: tcx.item_name(def_id),
             must_be_overridden,
-            const_stable: tcx.has_attr(def_id, sym::rustc_intrinsic_const_stable_indirect),
+            const_stable: find_attr!(
+                tcx.get_all_attrs(def_id),
+                AttributeKind::RustcIntrinsicConstStableIndirect
+            ),
         })
     } else {
         None

compiler/rustc_mir_build/src/errors.rs

@@ -849,7 +849,7 @@ pub(crate) struct LowerRangeBoundMustBeLessThanOrEqualToUpper {
     #[label("lower bound larger than upper bound")]
     pub(crate) span: Span,
     #[note(
-        "When matching against a range, the compiler verifies that the range is non-empty. Range patterns include both end-points, so this is equivalent to requiring the start of the range to be less than or equal to the end of the range."
+        "when matching against a range, the compiler verifies that the range is non-empty. Range patterns include both end-points, so this is equivalent to requiring the start of the range to be less than or equal to the end of the range"
     )]
     pub(crate) teach: bool,
 }

compiler/rustc_mir_transform/src/check_inline.rs

@@ -1,8 +1,9 @@
 //! Check that a body annotated with `#[rustc_force_inline]` will not fail to inline based on its
 //! definition alone (irrespective of any specific caller).
 
-use rustc_hir::attrs::InlineAttr;
+use rustc_hir::attrs::{AttributeKind, InlineAttr};
 use rustc_hir::def_id::DefId;
+use rustc_hir::find_attr;
 use rustc_middle::middle::codegen_fn_attrs::CodegenFnAttrFlags;
 use rustc_middle::mir::{Body, TerminatorKind};
 use rustc_middle::ty;
@@ -62,7 +63,7 @@ pub(super) fn is_inline_valid_on_fn<'tcx>(
     // but at this stage we don't know whether codegen knows the intrinsic,
     // so just conservatively don't inline it. This also ensures that we do not
     // accidentally inline the body of an intrinsic that *must* be overridden.
-    if tcx.has_attr(def_id, sym::rustc_intrinsic) {
+    if find_attr!(tcx.get_all_attrs(def_id), AttributeKind::RustcIntrinsic) {
         return Err("callee is an intrinsic");
     }
 

compiler/rustc_mir_transform/src/cross_crate_inline.rs

@@ -1,6 +1,7 @@
-use rustc_hir::attrs::InlineAttr;
+use rustc_hir::attrs::{AttributeKind, InlineAttr};
 use rustc_hir::def::DefKind;
 use rustc_hir::def_id::LocalDefId;
+use rustc_hir::find_attr;
 use rustc_middle::bug;
 use rustc_middle::mir::visit::Visitor;
 use rustc_middle::mir::*;
@@ -43,7 +44,7 @@ fn cross_crate_inlinable(tcx: TyCtxt<'_>, def_id: LocalDefId) -> bool {
         return true;
     }
 
-    if tcx.has_attr(def_id, sym::rustc_intrinsic) {
+    if find_attr!(tcx.get_all_attrs(def_id), AttributeKind::RustcIntrinsic) {
         // Intrinsic fallback bodies are always cross-crate inlineable.
         // To ensure that the MIR inliner doesn't cluelessly try to inline fallback
         // bodies even when the backend would implement something better, we stop
@@ -157,7 +158,7 @@ impl<'tcx> Visitor<'tcx> for CostChecker<'_, 'tcx> {
                 // But intrinsics don't have a body that gets assigned to a CGU, so they are
                 // ignored.
                 if let Some((fn_def_id, _)) = func.const_fn_def()
-                    && self.tcx.has_attr(fn_def_id, sym::rustc_intrinsic)
+                    && find_attr!(tcx.get_all_attrs(fn_def_id), AttributeKind::RustcIntrinsic)
                 {
                     return;
                 }

compiler/rustc_passes/src/check_attr.rs

@@ -312,6 +312,8 @@ impl<'tcx> CheckAttrVisitor<'tcx> {
                     | AttributeKind::RustcHasIncoherentInherentImpls
                     | AttributeKind::RustcHiddenTypeOfOpaques
                     | AttributeKind::RustcIfThisChanged(..)
+                    | AttributeKind::RustcIntrinsic
+                    | AttributeKind::RustcIntrinsicConstStableIndirect
                     | AttributeKind::RustcLayout(..)
                     | AttributeKind::RustcLayoutScalarValidRangeEnd(..)
                     | AttributeKind::RustcLayoutScalarValidRangeStart(..)
@@ -383,9 +385,7 @@ impl<'tcx> CheckAttrVisitor<'tcx> {
                             | sym::rustc_no_mir_inline
                             | sym::rustc_insignificant_dtor
                             | sym::rustc_nonnull_optimization_guaranteed
-                            | sym::rustc_intrinsic
                             | sym::rustc_inherit_overflow_checks
-                            | sym::rustc_intrinsic_const_stable_indirect
                             | sym::rustc_trivial_field_reads
                             | sym::rustc_on_unimplemented
                             | sym::rustc_do_not_const_check