Rollup of 28 pull requests

compiler/rustc_ast/src/ast.rs

@@ -220,7 +220,7 @@ pub struct PathSegment {
     /// `None` means that no parameter list is supplied (`Path`),
     /// `Some` means that parameter list is supplied (`Path<X, Y>`)
     /// but it can be empty (`Path<>`).
-    /// `P` is used as a size optimization for the common case with no parameters.
+    /// `Box` is used as a size optimization for the common case with no parameters.
     pub args: Option<Box<GenericArgs>>,
 }
 
@@ -557,9 +557,10 @@ pub struct Crate {
     pub is_placeholder: bool,
 }
 
-/// A semantic representation of a meta item. A meta item is a slightly
-/// restricted form of an attribute -- it can only contain expressions in
-/// certain leaf positions, rather than arbitrary token streams -- that is used
+/// A semantic representation of a meta item.
+///
+/// A meta item is a slightly restricted form of an attribute -- it can only contain
+/// expressions in certain leaf positions, rather than arbitrary token streams -- that is used
 /// for most built-in attributes.
 ///
 /// E.g., `#[test]`, `#[derive(..)]`, `#[rustfmt::skip]` or `#[feature = "foo"]`.
@@ -806,6 +807,7 @@ impl ByRef {
 }
 
 /// The mode of a binding (`mut`, `ref mut`, etc).
+///
 /// Used for both the explicit binding annotations given in the HIR for a binding
 /// and the final binding mode that we infer after type inference/match ergonomics.
 /// `.0` is the by-reference mode (`ref`, `ref mut`, or by value),
@@ -1184,7 +1186,9 @@ impl UnOp {
     }
 }
 
-/// A statement. No `attrs` or `tokens` fields because each `StmtKind` variant
+/// A statement.
+///
+/// No `attrs` or `tokens` fields because each `StmtKind` variant
 /// contains an AST node with those fields. (Except for `StmtKind::Empty`,
 /// which never has attrs or tokens)
 #[derive(Clone, Encodable, Decodable, Debug)]
@@ -1375,6 +1379,8 @@ pub enum UnsafeSource {
     UserProvided,
 }
 
+/// An anonymous constant.
+///
 /// A constant (expression) that's not an item or associated item,
 /// but needs its own `DefId` for type-checking, const-eval, etc.
 /// These are usually found nested inside types (e.g., array lengths)
@@ -1962,8 +1968,9 @@ pub enum UnsafeBinderCastKind {
     Unwrap,
 }
 
-/// The explicit `Self` type in a "qualified path". The actual
-/// path, including the trait and the associated item, is stored
+/// The explicit `Self` type in a "qualified path".
+///
+/// The actual path, including the trait and the associated item, is stored
 /// separately. `position` represents the index of the associated
 /// item qualified with this `Self` type.
 ///
@@ -3503,6 +3510,8 @@ pub struct AttrItem {
     pub span: Span,
 }
 
+/// A synthetic attribute.
+///
 /// Synthetic attributes are inserted by the compiler. They cannot be written in source code, and
 /// so cannot be pretty-printed by the AST pretty printer (because its output should be valid Rust
 /// code). They receive special treatment because they must not affect observable language
@@ -3525,7 +3534,7 @@ pub enum SyntheticAttr {
     /// evaluated true or not (or even failed to parse). The `pred` and `attrs` are not recorded
     /// because they are not needed.
     ///
-    /// The attribute is used by some clippy lints.
+    /// The attribute is used by rustdoc to display `doc_cfg` information and by some clippy lints.
     CfgAttrTrace(CfgEntry),
 }
 

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/cfg.rs

@@ -27,8 +27,7 @@ use crate::session_diagnostics::{
     ParsedDescription,
 };
 use crate::{
-    AttrSuggestionStyle, AttributeParser, AttributeTemplate, check_cfg, parse_version,
-    session_diagnostics, template,
+    AttributeParser, AttributeTemplate, check_cfg, parse_version, session_diagnostics, template,
 };
 
 pub const CFG_TEMPLATE: AttributeTemplate = template!(
@@ -329,12 +328,12 @@ pub fn parse_cfg_attr(
                 Ok(r) => return Some(r),
                 Err(e) => {
                     let suggestions = CFG_ATTR_TEMPLATE.suggestions(
-                        AttrSuggestionStyle::Attribute(cfg_attr.style),
+                        ParsedDescription::Attribute,
                         cfg_attr.get_normal_item().unsafety,
                         sym::cfg_attr,
                     );
                     e.with_span_suggestions(
-                        cfg_attr.span,
+                        cfg_attr.get_normal_item().span,
                         "must be of the form",
                         suggestions,
                         Applicability::HasPlaceholders,
@@ -358,15 +357,14 @@ pub fn parse_cfg_attr(
 
             sess.dcx().emit_err(AttributeParseError {
                 span,
-                attr_span: cfg_attr.span,
                 inner_span: cfg_attr.get_normal_item().span,
                 template: CFG_ATTR_TEMPLATE,
                 path: AttrPath::from_ast(&cfg_attr.get_normal_item().path, identity),
                 description: ParsedDescription::Attribute,
                 reason,
                 suggestions: session_diagnostics::AttributeParseErrorSuggestions::CreatedByTemplate(
                     CFG_ATTR_TEMPLATE.suggestions(
-                        AttrSuggestionStyle::Attribute(cfg_attr.style),
+                        ParsedDescription::Attribute,
                         cfg_attr.get_normal_item().unsafety,
                         sym::cfg_attr,
                     ),

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/doc.rs

@@ -728,7 +728,7 @@ impl DocParser {
         match args {
             ArgParser::NoArgs => {
                 let suggestions = cx.adcx().suggestions();
-                let span = cx.attr_span;
+                let span = cx.inner_span;
                 cx.emit_lint(
                     rustc_session::lint::builtin::INVALID_DOC_ATTRIBUTES,
                     IllFormedAttributeInput::new(&suggestions, None, 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
             }
         }
     }