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 retained: 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.

retained: bool

Whether an attribute asks for this to exist where nothing in the file refers to it.

used, retain, constructor, destructor and alias each say that something reaches the definition from where the compiler cannot see it, which is the only reason a program ever writes one of them. Nothing else in the tree says that, and a static function nothing refers to is not emitted, so this is how a program keeps one that has to be.

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