stash

Author: Bryntet

compiler/rustc_attr_parsing/src/attributes/lint.rs

@@ -24,12 +24,12 @@ impl<S: Stage> AttributeParser<S> for AllowParser {
             "https://doc.rust-lang.org/reference/attributes/diagnostics.html#lint-check-attributes"
         ),
         |this, cx, args| {
-            validate_lint_attr(cx, args, &mut this.lint_ids, &mut this.errored, &mut this.reason);
+            validate_lint_attr(cx, args, &mut this.lint_ids, &mut this.errored, &mut this.reason, sym::allow);
         },
     )];
 
     fn finalize(self, _cx: &FinalizeContext<'_, '_, S>) -> Option<AttributeKind> {
-        if !self.lint_ids.is_empty() && !self.errored {
+        if !self.errored {
             Some(AttributeKind::Allow { lint_ids: self.lint_ids, reason: self.reason })
         } else {
             None
@@ -52,12 +52,12 @@ impl<S: Stage> AttributeParser<S> for DenyParser {
             "https://doc.rust-lang.org/reference/attributes/diagnostics.html#lint-check-attributes"
         ),
         |this, cx, args| {
-            validate_lint_attr(cx, args, &mut this.lint_ids, &mut this.errored, &mut this.reason);
+            validate_lint_attr(cx, args, &mut this.lint_ids, &mut this.errored, &mut this.reason, sym::deny);
         },
     )];
 
     fn finalize(self, _cx: &FinalizeContext<'_, '_, S>) -> Option<AttributeKind> {
-        if !self.lint_ids.is_empty() && !self.errored {
+        if !self.errored {
             Some(AttributeKind::Deny { lint_ids: self.lint_ids, reason: self.reason })
         } else {
             None
@@ -74,20 +74,21 @@ fn validate_lint_attr<S: Stage>(
     lint_ids: &mut ThinVec<(Symbol, Span)>,
     errored: &mut bool,
     reason: &mut Option<Symbol>,
+    attr_name: Symbol,
 ) {
 
     let Some(list) = args.list().map(MetaItemListParser::mixed) else {
         cx.expected_list(cx.inner_span, args);
         return;
     };
-
     let mut list = list.peekable();
 
+    let mut skip_empty_check = false;
     while let Some(item) = list.next() {
         let Some(meta_item) = item.meta_item() else {
             cx.expected_string_literal(item.span(), item.lit());
             *errored = true;
-            return;
+            continue;
         };
         if let Some(args) = meta_item.word_is(sym::reason) {
             let ArgParser::NameValue(nv) = args else {
@@ -96,7 +97,7 @@ fn validate_lint_attr<S: Stage>(
                 continue;
             };
             if list.peek().is_some() {
-                // TODO: proper error
+                cx.expected_nv_as_last_argument(nv.args_span(), attr_name, sym::reason);
                 *errored = true;
                 continue;
             }
@@ -126,9 +127,16 @@ fn validate_lint_attr<S: Stage>(
 
             if let Some(ids) = check_lint(cx, &name, tool_name, tool_span, meta_item.span()) {
                 lint_ids.extend(ids);
+            } else {
+                // Since external tool lints aren't directly checked by rustc, we don't store these ids 
+                // inside the parsed attr, but this still means that something *does* exist in it, so we shouldn't warn
+                skip_empty_check = true;
             }
         }
     }
+    if !skip_empty_check && lint_ids.is_empty() {
+        cx.warn_empty_attribute(cx.attr_span);
+    }
 }
 
 fn check_lint<S: Stage>(
@@ -148,7 +156,6 @@ fn check_lint<S: Stage>(
                 lint_ids.push((Symbol::intern(&id.to_string()), meta_item_span));
             }
         }
-        // TODO fix tools
         CheckLintNameResult::Tool(ids, new_lint_name) => {
             let _name = match new_lint_name {
                 None => {

compiler/rustc_attr_parsing/src/context.rs

@@ -629,6 +629,10 @@ impl<'f, 'sess: 'f, S: Stage> AcceptContext<'f, 'sess, S> {
         )
     }
 
+    pub(crate) fn expected_nv_as_last_argument(&self, span: Span,attr_name: Symbol, name_value_key: Symbol) -> ErrorGuaranteed {
+        self.emit_parse_error(span, AttributeParseErrorReason::ExpectedNameValueAsLastArgument {span,attr_name, name_value_key})
+    }
+
     pub(crate) fn warn_empty_attribute(&mut self, span: Span) {
         let attr_path = self.attr_path.clone().to_string();
         let valid_without_list = self.template.word;

compiler/rustc_attr_parsing/src/session_diagnostics.rs

@@ -570,6 +570,11 @@ pub(crate) enum AttributeParseErrorReason<'a> {
         list: bool,
     },
     ExpectedIdentifier,
+    ExpectedNameValueAsLastArgument {
+        span: Span,
+        attr_name: Symbol,
+        name_value_key: Symbol,
+    },
 }
 
 /// A description of a thing that can be parsed using an attribute parser.
@@ -750,6 +755,9 @@ impl<'a, G: EmissionGuarantee> Diagnostic<'a, G> for AttributeParseError<'_> {
             AttributeParseErrorReason::ExpectedIdentifier => {
                 diag.span_label(self.span, "expected a valid identifier here");
             }
+            AttributeParseErrorReason::ExpectedNameValueAsLastArgument { span, attr_name, name_value_key } => {
+                diag.span_label(span, format!("the name value key `{name_value_key}` must come last in `#[{attr_name}]`"));
+            }
         }
 
         if let Some(link) = self.template.docs {