Struct Tast 

pub struct Tast { /* private fields */ }

One typed translation unit.

Implementations

impl Tast

pub fn new() -> Tast

An empty tree.

pub fn top_level(&self) -> &[DeclId]

The objects and functions of the translation unit, in the order they were declared.

pub fn add_top_level(&mut self, decl: DeclId)

Adds a declaration at file scope.

pub fn file_asms(&self) -> &[FileAsm]

The asm written at file scope, in the order they were written.

Beside Tast::top_level rather than in it, because one of these declares no object and no function and so is not a Decl. What it is instead is a contribution to the object file, which is a thing only the walk to the IR has anywhere to put.

pub fn add_file_asm(&mut self, asm: FileAsm)

Adds an asm written at file scope.

pub fn expr(&mut self, expr: Expr, span: Span) -> ExprId

Adds an expression, with the source it came from.

Panics

Panics if the arena would exceed four billion nodes, which is not a translation unit this compiler intends to accept.

pub fn stmt(&mut self, stmt: Stmt, span: Span) -> StmtId

Adds a statement, with the source it came from.

Panics

Panics if the arena would exceed four billion nodes.

pub fn decl(&mut self, decl: Decl, span: Span) -> DeclId

Adds a declaration, with the source it came from.

Panics

Panics if the arena would exceed four billion nodes.

pub fn set_decl(&mut self, id: DeclId, decl: Decl)

Replaces a declaration, which is what a definition of something already declared does.

Panics

Panics if id is not a declaration of this tree.

pub fn set_stmt(&mut self, id: StmtId, stmt: Stmt)

Replaces a statement, which is what a switch does to the cases in its body.

A case is checked before the table it is an entry of exists, since the table is a run and the run is not known until the whole body has been walked. So the statement is written with a placeholder entry and given its real one here.

Panics

Panics if id is not a statement of this tree.

pub fn expr_span(&self, id: ExprId) -> Span

The source an expression came from.

pub fn stmt_span(&self, id: StmtId) -> Span

The source a statement came from.

pub fn decl_span(&self, id: DeclId) -> Span

The source a declaration came from.

pub fn add_vla(&mut self, size: ExprId) -> VlaId

Records the size of one variable length array, and gives back its identity.

The type table keeps a VlaId and nothing else, because two variable length arrays written with the same element type are still distinct types and interning them together would say they are not. The expression itself lives here, since it is evaluated once where the declaration is reached and its value is what every sizeof of that type afterwards answers with.

Panics

Panics if the table would exceed four billion entries.

pub fn vla_size(&self, id: VlaId) -> ExprId

The size expression of one variable length array.

Panics

Panics if id is not one of this tree’s.

pub fn record_adjustment(&mut self, decl: DeclId, written: TypeId)

Records the type a parameter was written as, where adjusting it to a pointer dropped a length the program still has to evaluate.

int f(int a[i++]) declares a pointer, since C11 6.7.6.3p7 adjusts an array parameter to one, and the adjustment takes the type away and not the expression: the size is evaluated once on entry to the function, in the order the parameters were written, so i++ happens and the function sees the incremented value. Nothing needs the size for anything, because the parameter is a pointer, so what is kept here is the type it was written as and the walk over that type is what evaluates every length in it.

Only the outermost length is ever lost this way. int a[][n] adjusts to int (*)[n] and the n is still in the type the parameter has, which is why this is a handful of entries in the whole tree and not one per parameter.

pub fn adjusted_from(&self, decl: DeclId) -> Option<TypeId>

The type a parameter was written as, for the few that have one.

pub fn define_label(&mut self, id: LabelId, stmt: StmtId)

Records that a label names a statement, which is not known when the label is created because a goto may come first.

Panics

Panics if id is not a label of this tree.

pub fn counts(&self) -> Counts

How many expressions, statements and declarations the tree holds.

pub fn is_empty(&self) -> bool

Whether nothing has been checked into this tree.

impl Tast

pub fn add_const(&mut self, item: Const) -> ConstId

Adds a folded constant.

Panics

Panics if the table would exceed four billion entries.

impl Tast

pub fn add_string(&mut self, item: StringLiteral) -> StrId

Adds a string literal.

Panics

Panics if the table would exceed four billion entries.

impl Tast

pub fn add_label(&mut self, item: Label) -> LabelId

Adds a label, which is not defined until the statement it names has been seen.

Panics

Panics if the table would exceed four billion entries.

impl Tast

pub fn add_asm(&mut self, item: Asm) -> AsmId

Adds an assembly statement.

Panics

Panics if the table would exceed four billion entries.

impl Tast

pub fn add_expr_refs(&mut self, items: &[ExprId]) -> ExprList

Adds a run of expression references, which is what a call’s arguments are.

Panics

Panics if the table would exceed four billion entries.

impl Tast

pub fn add_stmt_refs(&mut self, items: &[StmtId]) -> StmtList

Adds a run of statement references, which is what a block is.

Panics

Panics if the table would exceed four billion entries.

impl Tast

pub fn add_decl_refs(&mut self, items: &[DeclId]) -> DeclList

Adds a run of declaration references, which is what a declaration statement is.

Panics

Panics if the table would exceed four billion entries.

impl Tast

pub fn add_str_refs(&mut self, items: &[StrId]) -> StrList

Adds a run of string literal references, which is what an asm clobber list is.

Panics

Panics if the table would exceed four billion entries.

impl Tast

pub fn add_label_refs(&mut self, items: &[LabelId]) -> LabelList

Adds a run of label references, which is what the labels of an asm goto are.

Panics

Panics if the table would exceed four billion entries.

impl Tast

pub fn add_asm_operands(&mut self, items: &[AsmOperand]) -> AsmOperandList

Adds the operands of one section of an asm statement.

Panics

Panics if the table would exceed four billion entries.

impl Tast

pub fn add_cases(&mut self, items: &[Case]) -> CaseList

Adds the cases of one switch, in the order a jump table wants them.

Panics

Panics if the table would exceed four billion entries.

impl Tast

pub fn add_init_entries(&mut self, items: &[InitEntry]) -> InitList

Adds the values one initializer stores.

Panics

Panics if the table would exceed four billion entries.

Trait Implementations

impl Debug for Tast

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

Formats the value using the given formatter.

impl Default for Tast

fn default() -> Tast

Returns the “default value” for a type.

impl Index<Idx<Asm>> for Tast

type Output = Asm

The returned type after indexing.

fn index(&self, id: AsmId) -> &Asm

Performs the indexing (container[index]) operation.

impl Index<Idx<Case>> for Tast

type Output = Case

The returned type after indexing.

fn index(&self, id: CaseId) -> &Case

Performs the indexing (container[index]) operation.

impl Index<Idx<Const>> for Tast

type Output = Const

The returned type after indexing.

fn index(&self, id: ConstId) -> &Const

Performs the indexing (container[index]) operation.

impl Index<Idx<Decl>> for Tast

type Output = Decl

The returned type after indexing.

fn index(&self, id: DeclId) -> &Decl

Performs the indexing (container[index]) operation.

impl Index<Idx<Expr>> for Tast

type Output = Expr

The returned type after indexing.

fn index(&self, id: ExprId) -> &Expr

Performs the indexing (container[index]) operation.

impl Index<Idx<Label>> for Tast

type Output = Label

The returned type after indexing.

fn index(&self, id: LabelId) -> &Label

Performs the indexing (container[index]) operation.

impl Index<Idx<Stmt>> for Tast

type Output = Stmt

The returned type after indexing.

fn index(&self, id: StmtId) -> &Stmt

Performs the indexing (container[index]) operation.

impl Index<Idx<StringLiteral>> for Tast

type Output = StringLiteral

The returned type after indexing.

fn index(&self, id: StrId) -> &StringLiteral

Performs the indexing (container[index]) operation.

impl Index<IdxRange<AsmOperand>> for Tast

type Output = [AsmOperand]

The returned type after indexing.

fn index(&self, list: AsmOperandList) -> &[AsmOperand]

Performs the indexing (container[index]) operation.

impl Index<IdxRange<Case>> for Tast

type Output = [Case]

The returned type after indexing.

fn index(&self, list: CaseList) -> &[Case]

Performs the indexing (container[index]) operation.

impl Index<IdxRange<DeclRef>> for Tast

type Output = [Idx<Decl>]

The returned type after indexing.

fn index(&self, list: DeclList) -> &[DeclId]

Performs the indexing (container[index]) operation.

impl Index<IdxRange<ExprRef>> for Tast

type Output = [Idx<Expr>]

The returned type after indexing.

fn index(&self, list: ExprList) -> &[ExprId]

Performs the indexing (container[index]) operation.

impl Index<IdxRange<InitEntry>> for Tast

type Output = [InitEntry]

The returned type after indexing.

fn index(&self, list: InitList) -> &[InitEntry]

Performs the indexing (container[index]) operation.

impl Index<IdxRange<LabelRef>> for Tast

type Output = [Idx<Label>]

The returned type after indexing.

fn index(&self, list: LabelList) -> &[LabelId]

Performs the indexing (container[index]) operation.

impl Index<IdxRange<StmtRef>> for Tast

type Output = [Idx<Stmt>]

The returned type after indexing.

fn index(&self, list: StmtList) -> &[StmtId]

Performs the indexing (container[index]) operation.

impl Index<IdxRange<StrRef>> for Tast

type Output = [Idx<StringLiteral>]

The returned type after indexing.

fn index(&self, list: StrList) -> &[StrId]

Performs the indexing (container[index]) operation.