Struct OpToAsmOpId 

pub struct OpToAsmOpId { /* private fields */ }

CSR storage mapping (NodeId, OpIdx) -> AsmOpId.

Unlike OpToDecoratorIds, each operation has at most one AssemblyOp. We store only the operations that have an AssemblyOp, using sparse storage.

This structure provides efficient lookup of AssemblyOps by node and operation index, which is needed for error context reporting and debugging tools.

Implementations

impl OpToAsmOpId

pub fn new() -> OpToAsmOpId

Creates a new empty OpToAsmOpId.

pub fn with_capacity( nodes_capacity: usize, operations_capacity: usize, ) -> OpToAsmOpId

Creates an OpToAsmOpId with the specified capacity.

pub fn is_empty(&self) -> bool

Returns true if this storage contains no nodes.

pub fn num_nodes(&self) -> usize

Returns the number of nodes in this storage.

pub fn num_operations(&self) -> usize

Returns the total number of (op_idx, asm_op_id) entries across all nodes.

Note: This is the number of operations that have an AssemblyOp, not the total number of operations.

pub fn add_asm_ops_for_node( &mut self, node_id: MastNodeId, num_operations: usize, asm_ops: Vec<(usize, AsmOpId)>, ) -> Result<(), AsmOpIndexError>

Registers AssemblyOps for a node’s operations.

asm_ops is a list of (op_idx, asm_op_id) pairs. The op_idx values must be strictly increasing. Operations not listed will have no AsmOpId (sparse storage).

Nodes must be added in sequential order starting from 0. If a node is skipped, empty placeholder nodes are automatically created.

Arguments

• node_id - The node to register operations for. Must be >= current node count.
• num_operations - Total number of operations in this node (used for bounds checking).
• asm_ops - List of (operation_index, AsmOpId) pairs, sorted by operation_index.

Errors

Returns an error if:

• node_id is less than the current node count (already added)
• Operation indices are not strictly increasing
• An operation index exceeds num_operations

pub fn asm_op_id_for_operation( &self, node_id: MastNodeId, op_idx: usize, ) -> Option<AsmOpId>

Returns the AsmOpId for a specific operation within a node, if any.

If the operation doesn’t have a direct AssemblyOp, this performs a backward search to find the most recent AssemblyOp (needed for multi-cycle instructions like assertz where only the first operation has an AssemblyOp).

Arguments

• node_id - The node to query.
• op_idx - The operation index within the node.

Returns

• Some(asm_op_id) if the operation has an associated AssemblyOp (direct or via backward search)
• None if the node doesn’t exist or no AssemblyOp is found

pub fn first_asm_op_for_node(&self, node_id: MastNodeId) -> Option<AsmOpId>

Returns the first AsmOpId for a node, if any operations have one.

This is useful for getting context about a node when no specific operation index is available.

pub fn remap_nodes( &self, remapping: &BTreeMap<MastNodeId, MastNodeId>, ) -> OpToAsmOpId

Creates a new OpToAsmOpId with remapped node IDs.

This is used when nodes are removed from a MastForest and the remaining nodes are renumbered. The remapping maps old node IDs to new node IDs.

Nodes that are not in the remapping are considered removed and their asm_op data is discarded.

Trait Implementations

impl Clone for OpToAsmOpId

fn clone(&self) -> OpToAsmOpId

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for OpToAsmOpId

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

Formats the value using the given formatter.

impl Default for OpToAsmOpId

fn default() -> OpToAsmOpId

Returns the “default value” for a type.

impl<'de> Deserialize<'de> for OpToAsmOpId

fn deserialize<__D>( __deserializer: __D, ) -> Result<OpToAsmOpId, <__D as Deserializer<'de>>::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl PartialEq for OpToAsmOpId

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

Tests for self and other values to be equal, and is used by ==.

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

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Serialize for OpToAsmOpId

fn serialize<__S>( &self, __serializer: __S, ) -> Result<<__S as Serializer>::Ok, <__S as Serializer>::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl Eq for OpToAsmOpId

impl StructuralPartialEq for OpToAsmOpId