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,
    },
    RustcIntrinsic,
    RustcTestEntrypointMarker,
    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

RustcIntrinsic

Represents #[rustc_intrinsic]

RustcTestEntrypointMarker

Represents #[rustc_test_entrypoint_marker]

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 AstVisitable for AttributeKind

fn drive<V: VisitAst>(&self, v: &mut V) -> ControlFlow<V::Break>

Recursively visit this type with the provided visitor. This calls the visitor’s visit_$any method if it exists, otherwise visit_inner.

fn drive_mut<V: VisitAstMut>(&mut self, v: &mut V) -> ControlFlow<V::Break>

Recursively visit this type with the provided visitor. This calls the visitor’s visit_$any method if it exists, otherwise visit_inner.

fn drive_two<V: ZipAst>(&self, other: &Self, v: &mut V) -> ControlFlow<V::Break>

Recursively visit this type with the provided visitor. This calls the visitor’s visit_$any method if it exists, otherwise visit_inner.

fn name(&self) -> &'static str

The name of the type, used for debug logging.

fn dyn_visit<T: AstVisitable>(&self, f: impl FnMut(&T))

where Self: Sized,

Visit all occurrences of that type inside self, in pre-order traversal.

fn dyn_visit_mut<T: AstVisitable>(&mut self, f: impl FnMut(&mut T))

where Self: Sized,

Visit all occurrences of that type inside self, in pre-order traversal.

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 Display for AttributeKind

Print a built-in attribute the way it is written in the source.

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

Formats the value using the given formatter.

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, 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, 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<'s, V> DriveTwo<'s, V> for AttributeKind

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

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

Call v.visit() on the immediate contents of self and other, if they correspond. If the values don’t match up, this returns Break(Default::default()).

impl Eq for AttributeKind

impl PartialEq for AttributeKind

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

Equality operator ==.

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

Inequality operator !=.

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 StructuralPartialEq for AttributeKind