wip

Author: JonathanBrouwer

compiler/rustc_attr_parsing/src/attributes/codegen_attrs.rs

@@ -435,7 +435,7 @@ impl<S: Stage> CombineAttributeParser<S> for TargetFeatureParser {
     const ALLOWED_TARGETS: AllowedTargets = AllowedTargets::AllowList(&[
         Allow(Target::Fn),
         Allow(Target::Method(MethodKind::Inherent)),
-        Allow(Target::Method(MethodKind::Trait {body: true})),
+        Allow(Target::Method(MethodKind::Trait { body: true })),
         Warn(Target::Statement),
         Warn(Target::Field),
         Warn(Target::Arm),

compiler/rustc_attr_parsing/src/attributes/deprecation.rs

@@ -58,7 +58,7 @@ impl<S: Stage> SingleAttributeParser<S> for DeprecationParser {
         Allow(Target::AssocTy),
         Allow(Target::AssocConst),
         Allow(Target::Variant),
-        Error(Target::WherePredicate)
+        Error(Target::WherePredicate),
     ]);
     const TEMPLATE: AttributeTemplate = template!(
         Word,

compiler/rustc_attr_parsing/src/attributes/lint_helpers.rs

@@ -34,7 +34,11 @@ pub(crate) struct PassByValueParser;
 impl<S: Stage> NoArgsAttributeParser<S> for PassByValueParser {
     const PATH: &[Symbol] = &[sym::rustc_pass_by_value];
     const ON_DUPLICATE: OnDuplicate<S> = OnDuplicate::Error;
-    const ALLOWED_TARGETS: AllowedTargets = AllowedTargets::AllowList(&[Allow(Target::Struct), Allow(Target::Enum), Allow(Target::TyAlias)]);
+    const ALLOWED_TARGETS: AllowedTargets = AllowedTargets::AllowList(&[
+        Allow(Target::Struct),
+        Allow(Target::Enum),
+        Allow(Target::TyAlias),
+    ]);
     const CREATE: fn(Span) -> AttributeKind = AttributeKind::PassByValue;
 }
 

compiler/rustc_attr_parsing/src/attributes/must_use.rs

@@ -5,7 +5,7 @@ use rustc_hir::{MethodKind, Target};
 use rustc_span::{Symbol, sym};
 
 use crate::attributes::{AttributeOrder, OnDuplicate, SingleAttributeParser};
-use crate::context::MaybeWarn::{Allow};
+use crate::context::MaybeWarn::Allow;
 use crate::context::{AcceptContext, AllowedTargets, Stage};
 use crate::parser::ArgParser;
 use crate::session_diagnostics;

compiler/rustc_attr_parsing/src/attributes/stability.rs

@@ -33,8 +33,8 @@ const ALLOWED_TARGETS: AllowedTargets = AllowedTargets::AllowList(&[
     Allow(Target::Enum),
     Allow(Target::Union),
     Allow(Target::Method(MethodKind::Inherent)),
-    Allow(Target::Method(MethodKind::Trait {body: false})),
-    Allow(Target::Method(MethodKind::Trait {body: true})),
+    Allow(Target::Method(MethodKind::Trait { body: false })),
+    Allow(Target::Method(MethodKind::Trait { body: true })),
     Allow(Target::Impl { of_trait: false }),
     Allow(Target::Impl { of_trait: true }),
     Allow(Target::MacroDef),

compiler/rustc_attr_parsing/src/context.rs

@@ -687,7 +687,7 @@ impl AllowedTargets {
 pub(crate) enum MaybeWarn {
     Allow(Target),
     Warn(Target),
-    Error(Target)
+    Error(Target),
 }
 
 /// Context created once, for example as part of the ast lowering
@@ -905,11 +905,16 @@ impl<'sess, S: Stage> AttributeParser<'sess, S> {
                                     emit_lint(AttributeLint {
                                         id: target_id,
                                         span: n.item.span(),
-                                        kind: AttributeLintKind::InvalidTarget { },
+                                        kind: AttributeLintKind::InvalidTarget {},
                                     });
                                 }
                                 AllowedResult::Error => {
-                                    self.dcx().struct_span_err(n.item.span(), "this attribute is not allowed on this target").emit();
+                                    self.dcx()
+                                        .struct_span_err(
+                                            n.item.span(),
+                                            "this attribute is not allowed on this target",
+                                        )
+                                        .emit();
                                 }
                             }
                         }

compiler/rustc_attr_parsing/src/lints.rs

@@ -34,11 +34,11 @@ pub fn emit_attribute_lint<L: LintEmitter>(lint: &AttributeLint<HirId>, lint_emi
             *first_span,
             session_diagnostics::EmptyAttributeList { attr_span: *first_span },
         ),
-        AttributeLintKind::InvalidTarget { } => lint_emitter.emit_node_span_lint(
+        AttributeLintKind::InvalidTarget {} => lint_emitter.emit_node_span_lint(
             rustc_session::lint::builtin::UNUSED_ATTRIBUTES,
             *id,
             *span,
-            session_diagnostics::InvalidTarget { },
-        )
+            session_diagnostics::InvalidTarget {},
+        ),
     }
 }

compiler/rustc_attr_parsing/src/session_diagnostics.rs

@@ -482,8 +482,7 @@ pub(crate) struct EmptyAttributeList {
 
 #[derive(LintDiagnostic)]
 #[diag(attr_parsing_invalid_target)]
-pub(crate) struct InvalidTarget {
-}
+pub(crate) struct InvalidTarget {}
 
 #[derive(Diagnostic)]
 #[diag(attr_parsing_invalid_alignment_value, code = E0589)]

compiler/rustc_hir/src/lints.rs

@@ -34,5 +34,5 @@ pub enum AttributeLintKind {
     UnusedDuplicate { this: Span, other: Span, warning: bool },
     IllFormedAttributeInput { suggestions: Vec<String> },
     EmptyAttribute { first_span: Span },
-    InvalidTarget { },
+    InvalidTarget {},
 }

compiler/rustc_hir/src/target.rs

@@ -6,8 +6,9 @@
 
 use std::fmt::{self, Display};
 
-use rustc_ast::{AssocItemKind, ForeignItemKind, ast};
 use rustc_ast::visit::AssocCtxt;
+use rustc_ast::{AssocItemKind, ForeignItemKind, ast};
+
 use crate::def::DefKind;
 use crate::{Item, ItemKind, TraitItem, TraitItemKind, hir};
 
@@ -231,10 +232,12 @@ impl Target {
             AssocItemKind::Const(_) => Target::AssocConst,
             AssocItemKind::Fn(f) => Target::Method(match assoc_ctxt {
                 AssocCtxt::Trait => MethodKind::Trait { body: f.body.is_some() },
-                AssocCtxt::Impl { of_trait } => if of_trait {
-                    MethodKind::Trait { body: true }
-                } else {
-                    MethodKind::Inherent
+                AssocCtxt::Impl { of_trait } => {
+                    if of_trait {
+                        MethodKind::Trait { body: true }
+                    } else {
+                        MethodKind::Inherent
+                    }
                 }
             }),
             AssocItemKind::Type(_) => Target::AssocTy,