Struct FunctionTracer 

pub struct FunctionTracer<'a> {
    pub function: &'a Function,
    pub constants: &'a Arena<Constant>,
    pub overrides: &'a Arena<Override>,
    pub functions_pending: &'a mut HandleSet<Function>,
    pub functions_used: &'a mut HandleSet<Function>,
    pub types_used: &'a mut HandleSet<Type>,
    pub global_variables_used: &'a mut HandleSet<GlobalVariable>,
    pub constants_used: &'a mut HandleSet<Constant>,
    pub overrides_used: &'a mut HandleSet<Override>,
    pub global_expressions_used: &'a mut HandleSet<Expression>,
    pub expressions_used: HandleSet<Expression>,
}

Fields

function: &'a Function

constants: &'a Arena<Constant>

overrides: &'a Arena<Override>

functions_pending: &'a mut HandleSet<Function>

functions_used: &'a mut HandleSet<Function>

types_used: &'a mut HandleSet<Type>

global_variables_used: &'a mut HandleSet<GlobalVariable>

constants_used: &'a mut HandleSet<Constant>

overrides_used: &'a mut HandleSet<Override>

global_expressions_used: &'a mut HandleSet<Expression>

expressions_used: HandleSet<Expression>

Function-local expressions used.

Implementations

impl FunctionTracer<'_>

pub fn trace_call(&mut self, function: Handle<Function>)

pub fn trace(&mut self)

pub const fn as_expression(&mut self) -> ExpressionTracer<'_>

impl FunctionTracer<'_>

pub fn trace_block(&mut self, block: &[Statement])

pub fn trace_block_including_emits(&mut self, block: &[Statement])

Like Self::trace_block, but also mark every Emitted expression as used, whether or not anything needs its value.

Compaction only keeps values something actually needs, so trace_block ignores Emit statements. A consumer that has to account for every expression the generated code mentions, rather than every expression it needs, wants this instead: the MSL backend does no dead code elimination, so it writes out a definition for each expression it bakes whether or not anything reads it, and that definition refers to the expression’s operands.

fn trace_block_impl(&mut self, block: &[Statement], emits_are_used: bool)

fn trace_atomic_function(&mut self, fun: &AtomicFunction)

fn trace_ray_query_function(&mut self, fun: &RayQueryFunction)

Trait Implementations

impl From<FunctionTracer<'_>> for FunctionMap

fn from(used: FunctionTracer<'_>) -> Self

Converts to this type from the input type.