Rollup of 14 pull requests

compiler/rustc_ast_lowering/src/item.rs

@@ -155,7 +155,10 @@ impl<'hir> LoweringContext<'_, 'hir> {
         hir::attrs::EiiImpl {
             span: self.lower_span(*span),
             inner_span: self.lower_span(*inner_span),
-            impl_marked_unsafe: self.lower_safety(*impl_safety, hir::Safety::Safe).is_unsafe(),
+            impl_unsafe_span: match *impl_safety {
+                Safety::Unsafe(span) => Some(self.lower_span(span)),
+                Safety::Safe(_) | Safety::Default => None,
+            },
             is_default: *is_default,
             resolution,
         }

compiler/rustc_attr_parsing/src/attributes/codegen_attrs.rs

@@ -305,7 +305,7 @@ impl AttributeParser for NakedParser {
                 if other_attr.word_is(sym::target_feature) {
                     if !cx.features().naked_functions_target_feature() {
                         feature_err(
-                            &cx.sess(),
+                            cx.sess(),
                             sym::naked_functions_target_feature,
                             other_attr.span(),
                             "`#[target_feature(/* ... */)]` is currently unstable on `#[naked]` functions",
@@ -396,7 +396,7 @@ impl AttributeParser for UsedParser {
                         Some(sym::compiler) => {
                             if !cx.features().used_with_arg() {
                                 feature_err(
-                                    &cx.sess(),
+                                    cx.sess(),
                                     sym::used_with_arg,
                                     cx.attr_span,
                                     "`#[used(compiler)]` is currently unstable",
@@ -408,7 +408,7 @@ impl AttributeParser for UsedParser {
                         Some(sym::linker) => {
                             if !cx.features().used_with_arg() {
                                 feature_err(
-                                    &cx.sess(),
+                                    cx.sess(),
                                     sym::used_with_arg,
                                     cx.attr_span,
                                     "`#[used(linker)]` is currently unstable",
@@ -503,7 +503,7 @@ fn parse_tf_attribute(
         let Some(value_str) = cx.expect_string_literal(value) else {
             return features;
         };
-        for feature in value_str.as_str().split(",") {
+        for feature in value_str.as_str().split(',') {
             features.push((Symbol::intern(feature), item.span()));
         }
     }
@@ -602,7 +602,7 @@ impl SingleAttributeParser for InstrumentFnParser {
     const STABILITY: AttributeStability = unstable!(instrument_fn);
 
     fn convert(cx: &mut AcceptContext<'_, '_>, args: &ArgParser) -> Option<AttributeKind> {
-        let instrument = match args {
+        match args {
             ArgParser::NameValue(nv) => match nv.value_as_str() {
                 Some(sym::on) => Some(AttributeKind::InstrumentFn(InstrumentFnAttr::On)),
                 Some(sym::off) => Some(AttributeKind::InstrumentFn(InstrumentFnAttr::Off)),
@@ -621,8 +621,7 @@ impl SingleAttributeParser for InstrumentFnParser {
                 cx.adcx().expected_specific_argument_strings(span, &[sym::on, sym::off]);
                 None
             }
-        };
-        instrument
+        }
     }
 }
 
@@ -673,14 +672,7 @@ impl SingleAttributeParser for SanitizeParser {
                 let is_on = match value.value_as_str() {
                     Some(sym::on) => true,
                     Some(sym::off) => false,
-                    Some(_) => {
-                        cx.adcx().expected_specific_argument_strings(
-                            value.value_span,
-                            &[sym::on, sym::off],
-                        );
-                        return;
-                    }
-                    None => {
+                    _ => {
                         cx.adcx().expected_specific_argument_strings(
                             value.value_span,
                             &[sym::on, sym::off],
@@ -737,7 +729,6 @@ impl SingleAttributeParser for SanitizeParser {
                             sym::realtime,
                         ],
                     );
-                    continue;
                 }
             }
         }
@@ -809,9 +800,7 @@ impl SingleAttributeParser for PatchableFunctionEntryParser {
         }
 
         for item in meta_item_list.mixed() {
-            let Some((ident, value)) = cx.expect_name_value(item, item.span(), None) else {
-                return None;
-            };
+            let (ident, value) = cx.expect_name_value(item, item.span(), None)?;
 
             let attrib_to_write = match ident.name {
                 sym::prefix_nops => {

compiler/rustc_attr_parsing/src/attributes/deprecation.rs

@@ -24,7 +24,7 @@ fn get(
     if let Some(value_str) = v.value_as_ident() {
         Some(value_str)
     } else {
-        cx.adcx().expected_string_literal(v.value_span, Some(&v.value_as_lit()));
+        cx.adcx().expected_string_literal(v.value_span, Some(v.value_as_lit()));
         None
     }
 }

compiler/rustc_attr_parsing/src/attributes/diagnostic/mod.rs

@@ -49,7 +49,7 @@ pub(crate) enum Mode {
 }
 
 impl Mode {
-    fn as_str(&self) -> &'static str {
+    fn as_str(self) -> &'static str {
         match self {
             Self::RustcOnUnimplemented => "rustc_on_unimplemented",
             Self::DiagnosticOnUnimplemented => "diagnostic::on_unimplemented",
@@ -61,7 +61,7 @@ impl Mode {
         }
     }
 
-    fn expected_options(&self) -> &'static str {
+    fn expected_options(self) -> &'static str {
         const DEFAULT: &str =
             "at least one of the `message`, `note` and `label` options are expected";
         const DIAGNOSTIC_ON_TYPE_ERROR_EXPECTED_OPTIONS: &str =
@@ -70,33 +70,33 @@ impl Mode {
             Self::RustcOnUnimplemented => {
                 "see <https://rustc-dev-guide.rust-lang.org/diagnostics.html#rustc_on_unimplemented>"
             }
-            Self::DiagnosticOnUnimplemented => DEFAULT,
-            Self::DiagnosticOnConst => DEFAULT,
-            Self::DiagnosticOnMove => DEFAULT,
-            Self::DiagnosticOnUnknown => DEFAULT,
-            Self::DiagnosticOnUnmatchedArgs => DEFAULT,
+            Self::DiagnosticOnUnimplemented
+            | Self::DiagnosticOnConst
+            | Self::DiagnosticOnMove
+            | Self::DiagnosticOnUnknown
+            | Self::DiagnosticOnUnmatchedArgs => DEFAULT,
             Self::DiagnosticOnTypeError => DIAGNOSTIC_ON_TYPE_ERROR_EXPECTED_OPTIONS,
         }
     }
 
-    fn allowed_options(&self) -> &'static str {
+    fn allowed_options(self) -> &'static str {
         const DEFAULT: &str = "only `message`, `note` and `label` are allowed as options";
         const DIAGNOSTIC_ON_TYPE_ERROR_ALLOWED_OPTIONS: &str =
             "only `note` is allowed as option for `diagnostic::on_type_error`";
         match self {
             Self::RustcOnUnimplemented => {
                 "see <https://rustc-dev-guide.rust-lang.org/diagnostics.html#rustc_on_unimplemented>"
             }
-            Self::DiagnosticOnUnimplemented => DEFAULT,
-            Self::DiagnosticOnConst => DEFAULT,
-            Self::DiagnosticOnMove => DEFAULT,
-            Self::DiagnosticOnUnknown => DEFAULT,
-            Self::DiagnosticOnUnmatchedArgs => DEFAULT,
+            Self::DiagnosticOnUnimplemented
+            | Self::DiagnosticOnConst
+            | Self::DiagnosticOnMove
+            | Self::DiagnosticOnUnknown
+            | Self::DiagnosticOnUnmatchedArgs => DEFAULT,
             Self::DiagnosticOnTypeError => DIAGNOSTIC_ON_TYPE_ERROR_ALLOWED_OPTIONS,
         }
     }
 
-    fn allowed_format_arguments(&self) -> &'static str {
+    fn allowed_format_arguments(self) -> &'static str {
         match self {
             Self::RustcOnUnimplemented => {
                 "see <https://rustc-dev-guide.rust-lang.org/diagnostics.html#rustc_on_unimplemented> for allowed format arguments"
@@ -356,12 +356,11 @@ fn parse_directive_items<'p>(
                 if is_root {
                     let items = or_malformed!(item.args().as_list()?);
                     let mut iter = items.mixed();
-                    let filter: &MetaItemOrLitParser = match iter.next() {
-                        Some(c) => c,
-                        None => {
-                            cx.emit_err(InvalidOnClause::Empty { span });
-                            continue;
-                        }
+                    let filter = if let Some(c) = iter.next() {
+                        c
+                    } else {
+                        cx.emit_err(InvalidOnClause::Empty { span });
+                        continue;
                     };
 
                     let filter = parse_filter(filter);

compiler/rustc_attr_parsing/src/attributes/diagnostic/on_unmatched_args.rs

@@ -17,6 +17,8 @@ impl AttributeParser for OnUnmatchedArgsParser {
         AttributeStability::Stable, // Unstable, stability checked manually in the parser
         |this, cx, args| {
             if !cx.features().diagnostic_on_unmatched_args() {
+                // `UnknownDiagnosticAttribute` is emitted in rustc_resolve/macros.rs
+                args.ignore_args();
                 return;
             }
 

compiler/rustc_attr_parsing/src/attributes/diagnostic/opaque.rs

@@ -45,7 +45,7 @@ impl AttributeParser for OpaqueParser {
         AllowedTargets::AllowListWarnRest(&[Allow(Target::MacroDef)]);
 
     fn finalize(self, _cx: &FinalizeContext<'_, '_>) -> Option<AttributeKind> {
-        if let Some(_) = self.attr_span { Some(AttributeKind::Opaque) } else { None }
+        if self.attr_span.is_some() { Some(AttributeKind::Opaque) } else { None }
     }
 }
 

compiler/rustc_attr_parsing/src/attributes/inline.rs

@@ -50,13 +50,13 @@ impl SingleAttributeParser for InlineParser {
                     }
                     _ => {
                         cx.adcx().expected_specific_argument(l.span(), &[sym::always, sym::never]);
-                        return None;
+                        None
                     }
                 }
             }
             ArgParser::NameValue(_) => {
                 cx.adcx().warn_ill_formed_attribute_input(ILL_FORMED_ATTRIBUTE_INPUT);
-                return None;
+                None
             }
         }
     }

compiler/rustc_attr_parsing/src/attributes/link_attrs.rs

@@ -144,13 +144,13 @@ impl CombineAttributeParser for LinkParser {
         let mut verbatim = None;
         if let Some((modifiers, span)) = modifiers {
             for modifier in modifiers.as_str().split(',') {
-                let (modifier, value): (Symbol, bool) = match modifier.strip_prefix(&['+', '-']) {
-                    Some(m) => (Symbol::intern(m), modifier.starts_with('+')),
-                    None => {
+                let (modifier, value): (Symbol, bool) =
+                    if let Some(m) = modifier.strip_prefix(['+', '-']) {
+                        (Symbol::intern(m), modifier.starts_with('+'))
+                    } else {
                         cx.emit_err(InvalidLinkModifier { span });
                         continue;
-                    }
-                };
+                    };
 
                 macro report_unstable_modifier($feature: ident) {
                     if !features.$feature() {
@@ -196,9 +196,14 @@ impl CombineAttributeParser for LinkParser {
                         cx.emit_err(WholeArchiveNeedsStatic { span });
                     }
 
-                    (sym::as_dash_needed, Some(NativeLibKind::Dylib { as_needed }))
-                    | (sym::as_dash_needed, Some(NativeLibKind::Framework { as_needed }))
-                    | (sym::as_dash_needed, Some(NativeLibKind::RawDylib { as_needed })) => {
+                    (
+                        sym::as_dash_needed,
+                        Some(
+                            NativeLibKind::Dylib { as_needed }
+                            | NativeLibKind::Framework { as_needed }
+                            | NativeLibKind::RawDylib { as_needed },
+                        ),
+                    ) => {
                         report_unstable_modifier!(native_link_modifiers_as_needed);
                         assign_modifier(as_needed)
                     }
@@ -642,14 +647,13 @@ pub(crate) struct LinkageParser;
 impl SingleAttributeParser for LinkageParser {
     const PATH: &[Symbol] = &[sym::linkage];
     const ALLOWED_TARGETS: AllowedTargets<'_> = AllowedTargets::AllowList(&[
-        Allow(Target::Fn),
+        Allow(Target::Fn), // const fn denied in check_attr
         Allow(Target::Method(MethodKind::Inherent)),
         Allow(Target::Method(MethodKind::Trait { body: true })),
         Allow(Target::Method(MethodKind::TraitImpl)),
         Allow(Target::Static),
-        Allow(Target::ForeignStatic),
+        Allow(Target::ForeignStatic), // extern static mut denied in check_attr
         Allow(Target::ForeignFn),
-        Warn(Target::Method(MethodKind::Trait { body: false })), // Not inherited
     ]);
     const TEMPLATE: AttributeTemplate = template!(NameValueStr: [
         "available_externally",
@@ -667,9 +671,7 @@ impl SingleAttributeParser for LinkageParser {
     fn convert(cx: &mut AcceptContext<'_, '_>, args: &ArgParser) -> Option<AttributeKind> {
         let name_value = cx.expect_name_value(args, cx.attr_span, Some(sym::linkage))?;
 
-        let Some(value) = cx.expect_string_literal(name_value) else {
-            return None;
-        };
+        let value = cx.expect_string_literal(name_value)?;
 
         // Use the names from src/llvm/docs/LangRef.rst here. Most types are only
         // applicable to variable declarations and may not really make sense for

compiler/rustc_attr_parsing/src/attributes/macro_attrs.rs

@@ -149,12 +149,12 @@ impl SingleAttributeParser for MacroExportParser {
                     cx.adcx().warn_ill_formed_attribute_input(INVALID_MACRO_EXPORT_ARGUMENTS);
                     return None;
                 };
-                match l.meta_item_no_args().and_then(|i| i.path().word_sym()) {
-                    Some(sym::local_inner_macros) => true,
-                    _ => {
-                        cx.adcx().warn_ill_formed_attribute_input(INVALID_MACRO_EXPORT_ARGUMENTS);
-                        return None;
-                    }
+                if l.meta_item_no_args().is_some_and(|m| m.path().word_is(sym::local_inner_macros))
+                {
+                    true
+                } else {
+                    cx.adcx().warn_ill_formed_attribute_input(INVALID_MACRO_EXPORT_ARGUMENTS);
+                    return None;
                 }
             }
             ArgParser::NameValue(nv) => {

compiler/rustc_attr_parsing/src/attributes/mod.rs

@@ -247,7 +247,7 @@ impl OnDuplicate {
                     this: unused,
                     other: used,
                     name: Symbol::intern(
-                        &P::PATH.into_iter().map(|i| i.to_string()).collect::<Vec<_>>().join(".."),
+                        &P::PATH.iter().map(|i| i.to_string()).collect::<Vec<_>>().join(".."),
                     ),
                 });
             }

compiler/rustc_attr_parsing/src/attributes/repr.rs

@@ -59,7 +59,7 @@ impl CombineAttributeParser for ReprParser {
                 cx.adcx().expected_identifier(param.span());
                 continue;
             };
-            reprs.extend(parse_repr(cx, &item).map(|r| (r, param.span())));
+            reprs.extend(parse_repr(cx, item).map(|r| (r, param.span())));
         }
         reprs
     }
@@ -144,7 +144,7 @@ fn parse_repr(cx: &mut AcceptContext<'_, '_>, param: &MetaItemParser) -> Option<
         Some(sym::simd) => {
             if cx.features.is_some_and(|feats| !feats.repr_simd()) {
                 feature_err(
-                    &cx.sess(),
+                    cx.sess(),
                     sym::repr_simd,
                     param.span(),
                     "SIMD types are experimental and possibly buggy",

compiler/rustc_attr_parsing/src/attributes/stability.rs

@@ -309,10 +309,10 @@ pub(crate) fn parse_stability(
         let word = param.path().word();
         match word.map(|i| i.name) {
             Some(sym::feature) => {
-                insert_value_into_option_or_error(cx, &param, &mut feature, word.unwrap())?
+                insert_value_into_option_or_error(cx, param, &mut feature, word.unwrap())?
             }
             Some(sym::since) => {
-                insert_value_into_option_or_error(cx, &param, &mut since, word.unwrap())?
+                insert_value_into_option_or_error(cx, param, &mut since, word.unwrap())?
             }
             _ => {
                 cx.adcx().expected_specific_argument(param_span, &[sym::feature, sym::since]);
@@ -376,13 +376,13 @@ pub(crate) fn parse_unstability(
         let word = param.path().word();
         match word.map(|i| i.name) {
             Some(sym::feature) => {
-                insert_value_into_option_or_error(cx, &param, &mut feature, word.unwrap())?
+                insert_value_into_option_or_error(cx, param, &mut feature, word.unwrap())?
             }
             Some(sym::reason) => {
-                insert_value_into_option_or_error(cx, &param, &mut reason, word.unwrap())?
+                insert_value_into_option_or_error(cx, param, &mut reason, word.unwrap())?
             }
             Some(sym::issue) => {
-                insert_value_into_option_or_error(cx, &param, &mut issue, word.unwrap())?;
+                insert_value_into_option_or_error(cx, param, &mut issue, word.unwrap())?;
 
                 // These unwraps are safe because `insert_value_into_option_or_error` ensures the meta item
                 // is a name/value pair string literal.
@@ -406,10 +406,10 @@ pub(crate) fn parse_unstability(
                 };
             }
             Some(sym::implied_by) => {
-                insert_value_into_option_or_error(cx, &param, &mut implied_by, word.unwrap())?
+                insert_value_into_option_or_error(cx, param, &mut implied_by, word.unwrap())?
             }
             Some(sym::old_name) => {
-                insert_value_into_option_or_error(cx, &param, &mut old_name, word.unwrap())?
+                insert_value_into_option_or_error(cx, param, &mut old_name, word.unwrap())?
             }
             _ => {
                 cx.adcx().expected_specific_argument(
@@ -493,10 +493,10 @@ impl CombineAttributeParser for UnstableRemovedParser {
                 return None;
             };
             match word.name {
-                sym::feature => insert_value_into_option_or_error(cx, &param, &mut feature, word)?,
-                sym::since => insert_value_into_option_or_error(cx, &param, &mut since, word)?,
-                sym::reason => insert_value_into_option_or_error(cx, &param, &mut reason, word)?,
-                sym::link => insert_value_into_option_or_error(cx, &param, &mut link, word)?,
+                sym::feature => insert_value_into_option_or_error(cx, param, &mut feature, word)?,
+                sym::since => insert_value_into_option_or_error(cx, param, &mut since, word)?,
+                sym::reason => insert_value_into_option_or_error(cx, param, &mut reason, word)?,
+                sym::link => insert_value_into_option_or_error(cx, param, &mut link, word)?,
                 _ => {
                     cx.adcx().expected_specific_argument(
                         param.span(),