drop derive helpers during ast lowering

Author: scrabsha

compiler/rustc_attr_parsing/src/interface.rs

@@ -284,6 +284,9 @@ impl<'sess, S: Stage> AttributeParser<'sess, S> {
         mut emit_lint: impl FnMut(LintId, Span, AttributeLintKind),
     ) -> Vec<Attribute> {
         let mut attributes = Vec::new();
+        // Attributes that are still in the AST at this step but that we will not care about during
+        // the next steps.
+        let mut dropped_attributes = Vec::new();
         let mut attr_paths: Vec<RefPathParser<'_>> = Vec::new();
         let mut early_parsed_state = EarlyParsedState::default();
 
@@ -413,21 +416,6 @@ impl<'sess, S: Stage> AttributeParser<'sess, S> {
                             );
                         }
                     } else {
-                        // If we're here, we must be compiling a tool attribute... Or someone
-                        // forgot to parse their fancy new attribute. Let's warn them in any case.
-                        // If you are that person, and you really think your attribute should
-                        // remain unparsed, carefully read the documentation in this module and if
-                        // you still think so you can add an exception to this assertion.
-
-                        // FIXME(jdonszelmann): convert other attributes, and check with this that
-                        // we caught em all
-                        // const FIXME_TEMPORARY_ATTR_ALLOWLIST: &[Symbol] = &[sym::cfg];
-                        // assert!(
-                        //     self.tools.contains(&parts[0]) || true,
-                        //     // || FIXME_TEMPORARY_ATTR_ALLOWLIST.contains(&parts[0]),
-                        //     "attribute {path} wasn't parsed and isn't a know tool attribute",
-                        // );
-
                         let attr = AttrItem {
                             path: attr_path.clone(),
                             args: self
@@ -443,8 +431,19 @@ impl<'sess, S: Stage> AttributeParser<'sess, S> {
                             self.check_invalid_crate_level_attr_item(&attr);
                         }
 
-                        attributes.push(Attribute::Unparsed(Box::new(attr)));
-                    };
+                        let attr = Attribute::Unparsed(Box::new(attr));
+
+                        if self.tools.contains(&parts[0])
+                            // FIXME: this can be removed once #152369 has been merged.
+                            // https://github.com/rust-lang/rust/pull/152369
+                            || [sym::allow, sym::deny, sym::expect, sym::forbid, sym::warn]
+                                .contains(&parts[0])
+                        {
+                            attributes.push(attr);
+                        } else {
+                            dropped_attributes.push(attr);
+                        }
+                    }
                 }
             }
         }
@@ -460,7 +459,9 @@ impl<'sess, S: Stage> AttributeParser<'sess, S> {
         }
 
         if self.stage.should_emit() != ShouldEmit::Nothing && target == Target::WherePredicate {
-            self.check_invalid_where_predicate_attrs(&attributes);
+            self.check_invalid_where_predicate_attrs(
+                attributes.iter().chain(dropped_attributes.iter()),
+            );
         }
 
         attributes