Struct BoilerplateCounts 

pub struct BoilerplateCounts {
    pub control: usize,
    pub calls: usize,
    pub macros: usize,
    pub statements: usize,
    pub work: usize,
    pub branches: usize,
    pub declarations: usize,
    pub returns: usize,
}

What a unit’s body contains, counted over its whole subtree.

Calls are counted apart from statements because the IR models a call as an expression: f(); is one call node, not a statement wrapping one.

Fields

control: usize

Branches, loops, multi-way conditionals and error handling.

calls: usize

Call expressions that are not themselves an argument to a call.

Nesting is what separates delegation from work. f(g(x), h(y)) is one delegation whose arguments happen to be computed by call: counting three calls there would say a wrapper does three things, when what it does is call f. Sibling calls are counted apart, because two calls in a row are two things done.

macros: usize

Macro invocations that are not themselves an argument to a call.

Counted the way calls are, and for the same reason. f(tri!(g(x))) is one delegation whose argument happens to be spelled with a macro; counting the macro would say the body does something besides call f, when handing the argument over is all it does. A macro standing on its own is still counted: nothing here can see what it expands to, so a statement that is one is a statement whose contents are unknown.

statements: usize

Statements other than macro invocations and control flow.

work: usize

Statements that do more than name a value or hand one back.

A return around a delegation is punctuation. So is a local declared to receive what the delegation writes: a callee that answers through a pointer leaves its caller no other way to spell the call. An assignment or a bare expression statement is work.

Nothing here can see what an initialiser computes — the IR models a declaration as one node whether it names a place or fills it with arithmetic. That is why declarations are punctuation only beside a delegation, never on their own.

branches: usize

Two-way conditionals, counted apart from the rest of the control flow.

One of them is a guard. Several are a decision table, which is something a reader can act on: two copies of one table differing in their constants is exactly the duplication worth reporting.

declarations: usize

Local declarations, counted apart so a body can be required to have none. See work for why an initialiser cannot be inspected.

returns: usize

return statements.

Trait Implementations

impl Clone for BoilerplateCounts

fn clone(&self) -> BoilerplateCounts

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Copy for BoilerplateCounts

impl Debug for BoilerplateCounts

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

Formats the value using the given formatter.

impl Default for BoilerplateCounts

fn default() -> BoilerplateCounts

Returns the “default value” for a type.

impl Eq for BoilerplateCounts

impl PartialEq for BoilerplateCounts

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

Equality operator ==.

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

Inequality operator !=.

impl StructuralPartialEq for BoilerplateCounts