Enum AttributeKind 

pub enum AttributeKind {
    AutomaticallyDerived,
    Cold,
    Deprecated {
        deprecation: Deprecation,
        span: Span,
    },
    Fundamental,
    Ignore {
        span: Span,
        reason: Option<Ustr>,
    },
    Inline(InlineAttr, Span),
    MayDangle(Span),
    Naked(Span),
    NoLink,
    NoMangle(Span),
    NonExhaustive(Span),
    Optimize(OptimizeAttr, Span),
    RustcAlign {
        align: u64,
        span: Span,
    },
    RustcDiagnosticItem(Ustr),
    RustcIntrinsic,
    ShouldPanic {
        reason: Option<Ustr>,
    },
    TargetFeature {
        features: Vec<(Ustr, Span)>,
        attr_span: Span,
        was_forced: bool,
    },
    TrackCaller(Span),
}

Represents parsed built-in inert attributes.

Overview

These attributes are markers that guide the compilation process and are never expanded into other code. They persist throughout the compilation phases, from AST to HIR and beyond.

Attribute Processing

While attributes are initially parsed by rustc_parse into [ast::Attribute], they still contain raw token streams because different attributes have different internal structures. This enum represents the final, fully parsed form of these attributes, where each variant contains all the information and structure relevant for the specific attribute.

Some attributes can be applied multiple times to the same item, and they are “collapsed” into a single semantic attribute. For example:

#[repr(C)]
#[repr(packed)]
struct S { }

This is equivalent to #[repr(C, packed)] and results in a single [AttributeKind::Repr] containing both C and packed annotations. This collapsing happens during parsing and is reflected in the data structures defined in this enum.

Usage

These parsed attributes are used throughout the compiler to:

• Control code generation (e.g., #[repr])
• Mark API stability (#[stable], #[unstable])
• Provide documentation (#[doc])
• Guide compiler behavior (e.g., #[allow_internal_unstable])

Note on Attribute Organization

Some attributes like InlineAttr, OptimizeAttr, and InstructionSetAttr are defined separately from this enum because they are used in specific compiler phases (like code generation) and don’t need to persist throughout the entire compilation process. They are typically processed and converted into their final form earlier in the compilation pipeline.

For example:

• InlineAttr is used during code generation to control function inlining
• OptimizeAttr is used to control optimization levels
• InstructionSetAttr is used for target-specific code generation

These attributes are handled by their respective compiler passes in the rustc_codegen_ssa crate and don’t need to be preserved in the same way as the attributes in this enum.

For more details on attribute parsing, see the rustc_attr_parsing crate.

Variants

AutomaticallyDerived

Represents #[automatically_derived]

Cold

Represents #[cold].

Deprecated

Represents #[deprecated].

Fields

deprecation: Deprecation

span: Span

Fundamental

Represents #[fundamental].

Ignore

Represents #[ignore]

Fields

span: Span

reason: Option<Ustr>

ignore can optionally have a reason: #[ignore = "reason this is ignored"]

Inline(InlineAttr, Span)

Represents #[inline] and #[rustc_force_inline].

MayDangle(Span)

Represents #[may_dangle].

Naked(Span)

Represents #[naked]

NoLink

Represents #[no_link]

NoMangle(Span)

Represents #[no_mangle]

NonExhaustive(Span)

Represents #[non_exhaustive]

Optimize(OptimizeAttr, Span)

Represents #[optimize(size|speed)]

RustcAlign

Represents #[align(N)].

Fields

align: u64

span: Span

RustcDiagnosticItem(Ustr)

Represents #[rustc_diagnostic_item]

RustcIntrinsic

Represents #[rustc_intrinsic]

ShouldPanic

Represents #[should_panic]

Fields

reason: Option<Ustr>

TargetFeature

Represents #[target_feature(enable = "...")] and #[unsafe(force_target_feature(enable = "...")].

Fields

features: Vec<(Ustr, Span)>

attr_span: Span

was_forced: bool

TrackCaller(Span)

Represents #[track_caller]

Trait Implementations

impl Clone for AttributeKind

fn clone(&self) -> AttributeKind

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for AttributeKind

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for AttributeKind

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl<'s, V> Drive<'s, V> for AttributeKind

where V: Visitor + Visit<'s, Deprecation> + Visit<'s, Span> + Visit<'s, Option<Ustr>> + Visit<'s, InlineAttr> + Visit<'s, OptimizeAttr> + Visit<'s, u64> + Visit<'s, Ustr> + Visit<'s, Vec<(Ustr, Span)>> + Visit<'s, bool>,

fn drive_inner(&'s self, visitor: &mut V) -> ControlFlow<V::Break>

Call v.visit() on the immediate contents of self.

impl<'s, V> DriveMut<'s, V> for AttributeKind

where V: Visitor + VisitMut<'s, Deprecation> + VisitMut<'s, Span> + VisitMut<'s, Option<Ustr>> + VisitMut<'s, InlineAttr> + VisitMut<'s, OptimizeAttr> + VisitMut<'s, u64> + VisitMut<'s, Ustr> + VisitMut<'s, Vec<(Ustr, Span)>> + VisitMut<'s, bool>,

fn drive_inner_mut(&'s mut self, visitor: &mut V) -> ControlFlow<V::Break>

Call v.visit() on the immediate contents of self.

impl PartialEq for AttributeKind

fn eq(&self, other: &AttributeKind) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Serialize for AttributeKind

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl Eq for AttributeKind

impl StructuralPartialEq for AttributeKind