wip

Author: JonathanBrouwer

compiler/rustc_attr_parsing/src/attributes/body.rs

@@ -1,15 +1,18 @@
 //! Attributes that can be found in function body.
 
+use rustc_hir::Target;
 use rustc_hir::attrs::AttributeKind;
 use rustc_span::{Symbol, sym};
 
 use super::{NoArgsAttributeParser, OnDuplicate};
-use crate::context::Stage;
+use crate::context::MaybeWarn::Allow;
+use crate::context::{AllowedTargets, Stage};
 
 pub(crate) struct CoroutineParser;
 
 impl<S: Stage> NoArgsAttributeParser<S> for CoroutineParser {
     const PATH: &[Symbol] = &[sym::coroutine];
     const ON_DUPLICATE: OnDuplicate<S> = OnDuplicate::Error;
+    const ALLOWED_TARGETS: AllowedTargets = AllowedTargets::AllowList(&[Allow(Target::Closure)]);
     const CREATE: fn(rustc_span::Span) -> AttributeKind = |span| AttributeKind::Coroutine(span);
 }

compiler/rustc_attr_parsing/src/attributes/test_attrs.rs

@@ -54,6 +54,8 @@ impl<S: Stage> SingleAttributeParser<S> for ShouldPanicParser {
     const PATH: &[Symbol] = &[sym::should_panic];
     const ATTRIBUTE_ORDER: AttributeOrder = AttributeOrder::KeepOutermost;
     const ON_DUPLICATE: OnDuplicate<S> = OnDuplicate::WarnButFutureError;
+    const ALLOWED_TARGETS: AllowedTargets =
+        AllowedTargets::AllowListWarnRest(&[Allow(Target::Fn), Error(Target::WherePredicate)]);
     const TEMPLATE: AttributeTemplate =
         template!(Word, List: r#"expected = "reason""#, NameValueStr: "reason");
 

compiler/rustc_attr_parsing/src/context.rs

@@ -921,7 +921,8 @@ impl<'sess, S: Stage> AttributeParser<'sess, S> {
                                 match accept.allowed_targets.is_allowed(target) {
                                     AllowedResult::Allowed => {}
                                     AllowedResult::Warn => {
-                                        let allowed_targets = accept.allowed_targets.allowed_targets();
+                                        let allowed_targets =
+                                            accept.allowed_targets.allowed_targets();
                                         emit_lint(AttributeLint {
                                             id: target_id,
                                             span: attr.span,
@@ -941,13 +942,21 @@ impl<'sess, S: Stage> AttributeParser<'sess, S> {
                                         });
                                     }
                                     AllowedResult::Error => {
-                                        let allowed_targets = accept.allowed_targets.allowed_targets();
+                                        let allowed_targets =
+                                            accept.allowed_targets.allowed_targets();
                                         self.dcx().emit_err(InvalidTarget {
                                             span: attr.span,
                                             name: parts[0],
                                             target: target.plural_name(),
-                                            only: if allowed_targets.len() == 1 { "only " } else { "" },
-                                            applied: allowed_targets_applied(allowed_targets, target),
+                                            only: if allowed_targets.len() == 1 {
+                                                "only "
+                                            } else {
+                                                ""
+                                            },
+                                            applied: allowed_targets_applied(
+                                                allowed_targets,
+                                                target,
+                                            ),
                                         });
                                     }
                                 }

compiler/rustc_passes/messages.ftl

@@ -70,10 +70,6 @@ passes_const_stable_not_stable =
     attribute `#[rustc_const_stable]` can only be applied to functions that are declared `#[stable]`
     .label = attribute specified here
 
-passes_coroutine_on_non_closure =
-    attribute should be applied to closures
-    .label = not a closure
-
 passes_dead_codes =
     { $multiple ->
       *[true] multiple {$descr}s are
@@ -462,9 +458,6 @@ passes_non_exported_macro_invalid_attrs =
 passes_object_lifetime_err =
     {$repr}
 
-passes_only_has_effect_on =
-    `#[{$attr_name}]` only has an effect on {$target_name}
-
 passes_outer_crate_level_attr =
     crate-level attribute should be an inner attribute: add an exclamation mark: `#![foo]`
 

compiler/rustc_passes/src/check_attr.rs

@@ -10,7 +10,7 @@ use std::collections::hash_map::Entry;
 use std::slice;
 
 use rustc_abi::{Align, ExternAbi, Size};
-use rustc_ast::{AttrStyle, LitKind, MetaItemInner, MetaItemKind, ast, join_path_syms};
+use rustc_ast::{AttrStyle, LitKind, MetaItemInner, MetaItemKind, ast};
 use rustc_attr_parsing::{AttributeParser, Late};
 use rustc_data_structures::fx::FxHashMap;
 use rustc_errors::{Applicability, DiagCtxtHandle, IntoDiagArg, MultiSpan, StashKey};
@@ -245,8 +245,8 @@ impl<'tcx> CheckAttrVisitor<'tcx> {
                     | AttributeKind::PassByValue (..)
                     | AttributeKind::StdInternalSymbol (..)
                     | AttributeKind::Coverage (..)
-                    | AttributeKind::ShouldPanic
-                    | AttributeKind::Coroutine, //TODO
+                    | AttributeKind::ShouldPanic { .. }
+                    | AttributeKind::Coroutine(..),
                 ) => { /* do nothing  */ }
 
                 Attribute::Unparsed(attr_item) => {
@@ -513,28 +513,6 @@ impl<'tcx> CheckAttrVisitor<'tcx> {
         }
     }
 
-    /// FIXME: Remove when all attributes are ported to the new parser
-    fn check_generic_attr_unparsed(
-        &self,
-        hir_id: HirId,
-        attr: &Attribute,
-        target: Target,
-        allowed_target: Target,
-    ) {
-        if target != allowed_target {
-            let attr_name = join_path_syms(attr.path());
-            self.tcx.emit_node_span_lint(
-                UNUSED_ATTRIBUTES,
-                hir_id,
-                attr.span(),
-                errors::OnlyHasEffectOn {
-                    attr_name,
-                    target_name: allowed_target.plural_name().to_string(),
-                },
-            );
-        }
-    }
-
     /// Checks if `#[naked]` is applied to a function definition.
     fn check_naked(&self, hir_id: HirId, target: Target) {
         match target {
@@ -2002,15 +1980,6 @@ impl<'tcx> CheckAttrVisitor<'tcx> {
         }
     }
 
-    fn check_coroutine(&self, attr_span: Span, target: Target) {
-        match target {
-            Target::Closure => return,
-            _ => {
-                self.dcx().emit_err(errors::CoroutineOnNonClosure { span: attr_span });
-            }
-        }
-    }
-
     fn check_type_const(&self, hir_id: HirId, attr_span: Span, target: Target) {
         let tcx = self.tcx;
         if target == Target::AssocConst

compiler/rustc_passes/src/errors.rs

@@ -504,13 +504,6 @@ pub(crate) struct RustcForceInlineCoro {
     pub span: Span,
 }
 
-#[derive(Diagnostic)]
-#[diag(passes_coroutine_on_non_closure)]
-pub(crate) struct CoroutineOnNonClosure {
-    #[primary_span]
-    pub span: Span,
-}
-
 #[derive(Diagnostic)]
 #[diag(passes_linkage)]
 pub(crate) struct Linkage {
@@ -1022,13 +1015,6 @@ pub(crate) struct UselessAssignment<'a> {
     pub ty: Ty<'a>,
 }
 
-#[derive(LintDiagnostic)]
-#[diag(passes_only_has_effect_on)]
-pub(crate) struct OnlyHasEffectOn {
-    pub attr_name: String,
-    pub target_name: String,
-}
-
 #[derive(LintDiagnostic)]
 #[diag(passes_inline_ignored_for_exported)]
 #[help]