Struct Decl 

pub struct Decl {
    pub name: Option<Symbol>,
    pub ty: TypeId,
    pub kind: DeclKind,
    pub linkage: Linkage,
    pub duration: StorageDuration,
    pub state: Definition,
    pub alignment: Option<u32>,
    pub constant: bool,
    pub init: Option<InitList>,
    pub params: DeclList,
    pub body: Option<StmtId>,
}

An object or a function, as it was declared.

Fields

name: Option<Symbol>

The name, absent for a compound literal and for a parameter that was not given one.

ty: TypeId

The type, after the adjustments a declaration performs: an array parameter has already become a pointer, and a function parameter a function pointer.

kind: DeclKind

Whether it is an object or a function.

linkage: Linkage

Whether the name is shared with other translation units, and how.

duration: StorageDuration

How long the object lives.

state: Definition

How much of a definition this declaration is.

alignment: Option<u32>

The alignment alignas asked for, absent when the type’s own alignment stands.

constant: bool

Whether constexpr was written, which makes the object a named constant.

C23 6.6p8 puts a named constant of an integer type among the things an integer constant expression may be built out of, and a member of one of a structure or union type with it. That is the whole reason the keyword exists and it is why this is a fact about the declaration rather than something a reader could work out: a const object with a constant initializer is not one of them, so const int n = 1; int a[n]; is a variable length array and the same two lines with constexpr are an array of one.

init: Option<InitList>

The initializer, flattened, absent when there was none. An empty list is = {}, which C23 added and which zero-initializes, and is not the same as no initializer at all.

params: DeclList

The parameters of a function definition, in order, and empty for everything else.

A parameter is an object with automatic storage like any other, and the body refers to one the same way it refers to a local. What is different is that nothing in the body declares it, so without this there is no way to ask which objects a definition takes and in what order, which is the first question the walk to the IR has: the entry block’s parameters are these, in this order.

A declaration that is not a definition has none of these even when it was written with a prototype, because int f(int a); declares no object called a. The types are in the function type, which is where a call reads them.

body: Option<StmtId>

The body of a function definition.

Trait Implementations

impl Clone for Decl

fn clone(&self) -> Decl

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Decl

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

Formats the value using the given formatter.

impl Eq for Decl

impl PartialEq for Decl

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

Equality operator ==.

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

Inequality operator !=.

impl StructuralPartialEq for Decl