Enum AttributeKind

pub enum AttributeKind {
    Align {
        align: Align,
        span: Span,
    },
    AllowConstFnUnstable(ThinVec<Symbol>),
    AllowInternalUnstable(ThinVec<(Symbol, Span)>),
    AsPtr(Span),
    BodyStability {
        stability: DefaultBodyStability,
        span: Span,
    },
    Cold(Span),
    Confusables {
        symbols: ThinVec<Symbol>,
        first_span: Span,
    },
    ConstContinue(Span),
    ConstStability {
        stability: PartialConstStability,
        span: Span,
    },
    ConstStabilityIndirect,
    Deprecation {
        deprecation: Deprecation,
        span: Span,
    },
    DocComment {
        style: AttrStyle,
        kind: CommentKind,
        span: Span,
        comment: Symbol,
    },
    Inline(InlineAttr, Span),
    LoopMatch(Span),
    MacroTransparency(Transparency),
    MayDangle(Span),
    MustUse {
        span: Span,
        reason: Option<Symbol>,
    },
    Naked(Span),
    NoMangle(Span),
    Optimize(OptimizeAttr, Span),
    PubTransparent(Span),
    Repr(ThinVec<(ReprAttr, Span)>),
    SkipDuringMethodDispatch {
        array: bool,
        boxed_slice: bool,
        span: Span,
    },
    Stability {
        stability: Stability,
        span: Span,
    },
    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 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

Align

Represents #[align(N)].

Fields

align: Align

span: Span

AllowConstFnUnstable(ThinVec<Symbol>)

Represents #[rustc_allow_const_fn_unstable].

AllowInternalUnstable(ThinVec<(Symbol, Span)>)

Represents #[allow_internal_unstable].

AsPtr(Span)

Represents #[rustc_as_ptr] (used by the dangling_pointers_from_temporaries lint).

BodyStability

Represents #[rustc_default_body_unstable].

Fields

stability: DefaultBodyStability

span: Span

Span of the #[rustc_default_body_unstable(...)] attribute

Cold(Span)

Represents #[cold].

Confusables

Represents #[rustc_confusables].

Fields

symbols: ThinVec<Symbol>

first_span: Span

ConstContinue(Span)

Represents #[const_continue].

ConstStability

Represents #[rustc_const_stable] and #[rustc_const_unstable].

Fields

stability: PartialConstStability

span: Span

Span of the #[rustc_const_stable(...)] or #[rustc_const_unstable(...)] attribute

ConstStabilityIndirect

Represents #[rustc_const_stable_indirect].

Deprecation

Represents #[deprecated].

Fields

deprecation: Deprecation

span: Span

DocComment

Represents #[doc].

Fields

style: AttrStyle

kind: CommentKind

span: Span

comment: Symbol

Inline(InlineAttr, Span)

Represents #[inline] and #[rustc_force_inline].

LoopMatch(Span)

Represents #[loop_match].

MacroTransparency(Transparency)

Represents #[rustc_macro_transparency].

MayDangle(Span)

Represents #[may_dangle].

MustUse

Represents #[must_use].

Fields

span: Span

reason: Option<Symbol>

must_use can optionally have a reason: #[must_use = "reason this must be used"]

Naked(Span)

Represents #[naked]

NoMangle(Span)

Represents #[no_mangle]

Optimize(OptimizeAttr, Span)

Represents #[optimize(size|speed)]

PubTransparent(Span)

Represents #[rustc_pub_transparent] (used by the repr_transparent_external_private_fields lint).

Repr(ThinVec<(ReprAttr, Span)>)

Represents #[repr].

SkipDuringMethodDispatch

Represents #[rustc_skip_during_method_dispatch].

Fields

array: bool

boxed_slice: bool

span: Span

Stability

Represents #[stable], #[unstable] and #[rustc_allowed_through_unstable_modules].

Fields

stability: Stability

span: Span

Span of the attribute.

TrackCaller(Span)

Represents #[track_caller]

Implementations

impl AttributeKind

pub fn encode_cross_crate(&self) -> EncodeCrossCrate

Trait Implementations

impl Clone for AttributeKind

fn clone(&self) -> AttributeKind

Returns a duplicate of the value.

const 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<__D: SpanDecoder> Decodable<__D> for AttributeKind

fn decode(__decoder: &mut __D) -> Self

impl<__E: SpanEncoder> Encodable<__E> for AttributeKind

fn encode(&self, __encoder: &mut __E)

impl<__CTX> HashStable<__CTX> for AttributeKind

where __CTX: HashStableContext,

fn hash_stable(&self, __hcx: &mut __CTX, __hasher: &mut StableHasher)

impl PrintAttribute for AttributeKind

fn should_render(&self) -> bool

Whether or not this will render as something meaningful, or if it’s skipped (which will force the containing struct to also skip printing a comma and the field name).

fn print_attribute(&self, __p: &mut Printer)

Layout

Note: Most layout information is completely unstable and may even differ between compilations. The only exception is types with certain repr(...) attributes. Please see the Rust Reference's “Type Layout” chapter for details on type layout guarantees.

Size: 40 bytes

Size for each variant:

• Align: 11 bytes
• AllowConstFnUnstable: 15 bytes
• AllowInternalUnstable: 15 bytes
• AsPtr: 11 bytes
• BodyStability: 35 bytes
• Cold: 11 bytes
• Confusables: 23 bytes
• ConstContinue: 11 bytes
• ConstStability: 39 bytes
• ConstStabilityIndirect: 0 bytes
• Deprecation: 27 bytes
• DocComment: 15 bytes
• Inline: 23 bytes
• LoopMatch: 11 bytes
• MacroTransparency: 1 byte
• MayDangle: 11 bytes
• MustUse: 15 bytes
• Naked: 11 bytes
• NoMangle: 11 bytes
• Optimize: 11 bytes
• PubTransparent: 11 bytes
• Repr: 15 bytes
• SkipDuringMethodDispatch: 11 bytes
• Stability: 35 bytes
• TrackCaller: 11 bytes