fix: before parser was preventing check_target, but now tht I used a closure it considers other checks also

Author: tahadostifam

compiler/rustc_attr_parsing/src/attributes/inline.rs

@@ -59,6 +59,25 @@ impl AttributeParser for InlineParser {
                     }
                 };
 
+                cx.check_target(
+                    &attr_args,
+                    &AllowedTargets::AllowList(&[
+                        Allow(Target::Fn),
+                        Allow(Target::Method(MethodKind::Inherent)),
+                        Allow(Target::Method(MethodKind::Trait { body: true })),
+                        Allow(Target::Method(MethodKind::TraitImpl)),
+                        Allow(Target::Closure),
+                        Allow(Target::Delegation { mac: false }),
+                        Warn(Target::Method(MethodKind::Trait { body: false })),
+                        Warn(Target::ForeignFn),
+                        Warn(Target::Field),
+                        Warn(Target::MacroDef),
+                        Warn(Target::Arm),
+                        Warn(Target::AssocConst),
+                        Warn(Target::MacroCall),
+                    ]),
+                );
+
                 let parse_attr = |cx: &mut AcceptContext<'_, '_>| match args {
                     ArgParser::NoArgs => Some(InlineAttr::Hint),
 
@@ -69,19 +88,17 @@ impl AttributeParser for InlineParser {
                         };
 
                         if let Err(args_span) = item.args().as_no_args() {
-                            cx.adcx()
-                                .expected_specific_argument(args_span, &[sym::always, sym::never]);
+                            cx.adcx().expected_no_args(args_span);
                             return None;
                         }
 
                         match item.path().word_sym() {
                             Some(sym::always) => Some(InlineAttr::Always),
                             Some(sym::never) => Some(InlineAttr::Never),
                             _ => {
-                                cx.adcx().expected_specific_argument(
-                                    item.span(),
-                                    &[sym::always, sym::never],
-                                );
+                                let span = item.args().span().unwrap();
+                                cx.adcx()
+                                    .expected_specific_argument(span, &[sym::always, sym::never]);
                                 return None;
                             }
                         }
@@ -93,25 +110,6 @@ impl AttributeParser for InlineParser {
                     }
                 };
 
-                cx.check_target(
-                    &attr_args,
-                    &AllowedTargets::AllowList(&[
-                        Allow(Target::Fn),
-                        Allow(Target::Method(MethodKind::Inherent)),
-                        Allow(Target::Method(MethodKind::Trait { body: true })),
-                        Allow(Target::Method(MethodKind::TraitImpl)),
-                        Allow(Target::Closure),
-                        Allow(Target::Delegation { mac: false }),
-                        Warn(Target::Method(MethodKind::Trait { body: false })),
-                        Warn(Target::ForeignFn),
-                        Warn(Target::Field),
-                        Warn(Target::MacroDef),
-                        Warn(Target::Arm),
-                        Warn(Target::AssocConst),
-                        Warn(Target::MacroCall),
-                    ]),
-                );
-
                 if let Some(prev) = &group.inline {
                     cx.warn_unused_duplicate(prev.span, span);
                     return;