line: i32,

end_line: i32,

col: i32,

end_col: i32,

pub name: String, // u_name (obj_name)

pub qualname: Option<String>, // u_qualname

pub consts: IndexSet<ConstantData>, // u_consts

pub names: IndexSet<String>, // u_names

pub varnames: IndexSet<String>, // u_varnames

pub cellvars: IndexSet<String>, // u_cellvars

pub freevars: IndexSet<String>, // u_freevars

pub fast_hidden: IndexMap<String, bool>, // u_fast_hidden

pub argcount: u32, // u_argcount

pub posonlyargcount: u32, // u_posonlyargcount

pub kwonlyargcount: u32, // u_kwonlyargcount

pub firstlineno: OneIndexed, // u_firstlineno

pub const NULL: Self = Self::new(u32::MAX);

/// Creates a new instance of [`BlockIdx`] from a [`u32`].

#[must_use]

pub const fn new(value: u32) -> Self {

Self(value)

}

/// Returns the inner value as a [`usize`].

#[must_use]

pub const fn idx(self) -> usize {

self.0 as usize

}

type Output = Block;

fn index(&self, idx: BlockIdx) -> &Block {

&self[idx.idx()]

}

fn index_mut(&mut self, idx: BlockIdx) -> &mut Block {

&mut self[idx.idx()]

}

pub instr: AnyInstruction,

pub arg: OpArg,

pub target: BlockIdx,

pub location: SourceLocation,

pub end_location: SourceLocation,

pub except_handler: Option<ExceptHandlerInfo>,

/// Override line number for linetable (e.g., line 0 for module RESUME)

pub lineno_override: Option<i32>,

/// Number of CACHE code units emitted after this instruction

pub cache_entries: u32,

/// Block to jump to when exception occurs

pub handler_block: BlockIdx,

/// Stack depth at handler entry

pub stack_depth: u32,

/// Whether to push lasti before exception

pub preserve_lasti: bool,

info.instr = Instruction::Nop.into();

info.arg = OpArg::new(0);

info.target = BlockIdx::NULL;

info.cache_entries = 0;

pub instructions: Vec<InstructionInfo>,

pub next: BlockIdx,

// Post-codegen analysis fields (set by label_exception_targets)

/// Whether this block is an exception handler target (b_except_handler)

pub except_handler: bool,

/// Whether to preserve lasti for this handler block (b_preserve_lasti)

pub preserve_lasti: bool,

/// Stack depth at block entry, set by stack depth analysis

pub start_depth: Option<u32>,

/// Whether this block is only reachable via exception table (b_cold)

pub cold: bool,

fn default() -> Self {

Self {

instructions: Vec::new(),

next: BlockIdx::NULL,

except_handler: false,

preserve_lasti: false,

start_depth: None,

cold: false,

}

}

pub flags: CodeFlags,

pub source_path: String,

pub private: Option<String>, // For private name mangling, mostly for class

pub blocks: Vec<Block>,

pub current_block: BlockIdx,

pub metadata: CodeUnitMetadata,

// For class scopes: attributes accessed via self.X

pub static_attributes: Option<IndexSet<String>>,

// True if compiling an inlined comprehension

pub in_inlined_comp: bool,

// Block stack for tracking nested control structures

pub fblock: Vec<crate::compile::FBlockInfo>,

// Reference to the symbol table for this scope

pub symbol_table_index: usize,

// PEP 649: Track nesting depth inside conditional blocks (if/for/while/etc.)

// u_in_conditional_block

pub in_conditional_block: u32,

// PEP 649: Next index for conditional annotation tracking

// u_next_conditional_annotation_index

pub next_conditional_annotation_index: u32,

pub fn finalize_code(

mut self,

opts: &crate::compile::CompileOpts,

) -> crate::InternalResult<CodeObject> {

// Constant folding passes

self.fold_binop_constants();

self.remove_nops();

self.fold_unary_negative();

self.fold_binop_constants(); // re-run after unary folding: -1 + 2 → 1

self.remove_nops(); // remove NOPs so tuple/list/set see contiguous LOADs

self.fold_tuple_constants();

self.fold_list_constants();

self.fold_set_constants();

self.remove_nops(); // remove NOPs from collection folding

self.fold_const_iterable_for_iter();

self.convert_to_load_small_int();

self.remove_unused_consts();

self.remove_nops();

// DCE always runs (removes dead code after terminal instructions)

self.dce();

// BUILD_TUPLE n + UNPACK_SEQUENCE n → NOP + SWAP (n=2,3) or NOP+NOP (n=1)

self.optimize_build_tuple_unpack();

// Dead store elimination for duplicate STORE_FAST targets

// (apply_static_swaps in CPython's flowgraph.c)

self.eliminate_dead_stores();

// apply_static_swaps: reorder stores to eliminate SWAPs

self.apply_static_swaps();

// Peephole optimizer creates superinstructions matching CPython

self.peephole_optimize();

// Phase 1: _PyCfg_OptimizeCodeUnit (flowgraph.c)

// Split blocks so each block has at most one branch as its last instruction

split_blocks_at_jumps(&mut self.blocks);

mark_except_handlers(&mut self.blocks);

label_exception_targets(&mut self.blocks);

// optimize_cfg: jump threading (before push_cold_blocks_to_end)

jump_threading(&mut self.blocks);

self.eliminate_unreachable_blocks();

self.remove_nops();

// TODO: insert_superinstructions disabled pending StoreFastLoadFast VM fix

push_cold_blocks_to_end(&mut self.blocks);

// Phase 2: _PyCfg_OptimizedCfgToInstructionSequence (flowgraph.c)

normalize_jumps(&mut self.blocks);

reorder_conditional_exit_and_jump_blocks(&mut self.blocks);

reorder_conditional_jump_and_exit_blocks(&mut self.blocks);

reorder_jump_over_exception_cleanup_blocks(&mut self.blocks);

inline_small_or_no_lineno_blocks(&mut self.blocks);

self.dce(); // re-run within-block DCE after normalize_jumps creates new instructions

self.eliminate_unreachable_blocks();

resolve_line_numbers(&mut self.blocks);

duplicate_end_returns(&mut self.blocks);

self.dce(); // truncate after terminal in blocks that got return duplicated

self.eliminate_unreachable_blocks(); // remove now-unreachable last block

remove_redundant_nops_and_jumps(&mut self.blocks);

// Some jump-only blocks only appear after late CFG cleanup. Thread them

// once more so loop backedges stay direct instead of becoming

// JUMP_FORWARD -> JUMP_BACKWARD chains.

jump_threading_unconditional(&mut self.blocks);

reorder_conditional_exit_and_jump_blocks(&mut self.blocks);

reorder_conditional_jump_and_exit_blocks(&mut self.blocks);

reorder_jump_over_exception_cleanup_blocks(&mut self.blocks);

self.eliminate_unreachable_blocks();

remove_redundant_nops_and_jumps(&mut self.blocks);

self.add_checks_for_loads_of_uninitialized_variables();

// optimize_load_fast: after normalize_jumps

self.optimize_load_fast_borrow();

self.optimize_load_global_push_null();

let max_stackdepth = self.max_stackdepth()?;

let Self {

flags,

source_path,

private: _, // private is only used during compilation

mut blocks,

current_block: _,

metadata,

static_attributes: _,

in_inlined_comp: _,

fblock: _,

symbol_table_index: _,

in_conditional_block: _,

next_conditional_annotation_index: _,

} = self;

let CodeUnitMetadata {

name: obj_name,

qualname,

consts: constants,

names: name_cache,

varnames: varname_cache,

cellvars: cellvar_cache,

freevars: freevar_cache,

fast_hidden,

argcount: arg_count,

posonlyargcount: posonlyarg_count,

kwonlyargcount: kwonlyarg_count,

firstlineno: first_line_number,

} = metadata;

let mut instructions = Vec::new();

let mut locations = Vec::new();

let mut linetable_locations: Vec<LineTableLocation> = Vec::new();

// Build cellfixedoffsets for cell-local merging

let cellfixedoffsets =

build_cellfixedoffsets(&varname_cache, &cellvar_cache, &freevar_cache);

// Convert pseudo ops (LoadClosure uses cellfixedoffsets) and fixup DEREF opargs

convert_pseudo_ops(&mut blocks, &cellfixedoffsets);

fixup_deref_opargs(&mut blocks, &cellfixedoffsets);

// Remove redundant NOPs, keeping line-marker NOPs only when

// they are needed to preserve tracing.

let mut block_order = Vec::new();

let mut current = BlockIdx(0);

while current != BlockIdx::NULL {

block_order.push(current);

current = blocks[current.idx()].next;

}

for block_idx in block_order {

let bi = block_idx.idx();

let mut src_instructions = core::mem::take(&mut blocks[bi].instructions);

let mut kept = Vec::with_capacity(src_instructions.len());

let mut prev_lineno = -1i32;

for src in 0..src_instructions.len() {

let instr = src_instructions[src];

let lineno = instr

.lineno_override

.unwrap_or_else(|| instr.location.line.get() as i32);

let mut remove = false;

if matches!(instr.instr.real(), Some(Instruction::Nop)) {

// Remove location-less NOPs.

if lineno < 0 || prev_lineno == lineno {

remove = true;

}

// Remove if the next instruction has same line or no line.

else if src < src_instructions.len() - 1 {

let next_lineno =

src_instructions[src + 1]

.lineno_override

.unwrap_or_else(|| {

src_instructions[src + 1].location.line.get() as i32

});

if next_lineno == lineno {

remove = true;

} else if next_lineno < 0 {

src_instructions[src + 1].lineno_override = Some(lineno);

remove = true;

}

}

// Last instruction in block: compare with first real location

// in the next non-empty block.

else {

let mut next = blocks[bi].next;

while next != BlockIdx::NULL && blocks[next.idx()].instructions.is_empty() {

next = blocks[next.idx()].next;

}

if next != BlockIdx::NULL {

let mut next_lineno = None;

for next_instr in &blocks[next.idx()].instructions {

let line = next_instr

.lineno_override

.unwrap_or_else(|| next_instr.location.line.get() as i32);

if matches!(next_instr.instr.real(), Some(Instruction::Nop))

&& line < 0

{

continue;

}

next_lineno = Some(line);

break;

}

if next_lineno.is_some_and(|line| line == lineno) {

remove = true;

}

}

}

}

if !remove {

kept.push(instr);

prev_lineno = lineno;

}

}

blocks[bi].instructions = kept;

}

// Final DCE: truncate instructions after terminal ops in linearized blocks.

// This catches dead code created by normalize_jumps after the initial DCE.

for block in blocks.iter_mut() {

if let Some(pos) = block

.instructions

.iter()

.position(|ins| ins.instr.is_scope_exit() || ins.instr.is_unconditional_jump())

{

block.instructions.truncate(pos + 1);

}

}

// Pre-compute cache_entries for real (non-pseudo) instructions

for block in blocks.iter_mut() {

for instr in &mut block.instructions {

if let AnyInstruction::Real(op) = instr.instr {

instr.cache_entries = op.cache_entries() as u32;

}

}

}

let mut block_to_offset = vec![Label::from_u32(0); blocks.len()];

// block_to_index: maps block idx to instruction index (for exception table)

// This is the index into the final instructions array, including EXTENDED_ARG and CACHE

let mut block_to_index = vec![0u32; blocks.len()];

// The offset (in code units) of END_SEND from SEND in the yield-from sequence.

const END_SEND_OFFSET: u32 = 5;

loop {

let mut num_instructions = 0;

for (idx, block) in iter_blocks(&blocks) {

block_to_offset[idx.idx()] = Label::from_u32(num_instructions as u32);

// block_to_index uses the same value as block_to_offset but as u32

// because lasti in frame.rs is the index into instructions array

// and instructions array index == byte offset (each instruction is 1 CodeUnit)

block_to_index[idx.idx()] = num_instructions as u32;

for instr in &block.instructions {

num_instructions += instr.arg.instr_size() + instr.cache_entries as usize;

}

}

instructions.reserve_exact(num_instructions);

locations.reserve_exact(num_instructions);

let mut recompile = false;

let mut next_block = BlockIdx(0);

while next_block != BlockIdx::NULL {

let block = &mut blocks[next_block];

// Track current instruction offset for jump direction resolution

let mut current_offset = block_to_offset[next_block.idx()].as_u32();

for info in &mut block.instructions {

let class="pl-kos">.target;

let mut op = info.instr.expect_real();

let old_arg_size = info.arg.instr_size();

let old_cache_entries = info.cache_entries;

// Keep offsets fixed within this pass: changes in jump

// arg/cache sizes only take effect in the next iteration.

let offset_after = current_offset + old_arg_size as u32 + old_cache_entries;

if target != BlockIdx::NULL {

let target_offset = block_to_offset[target.idx()].as_u32();

// Direction must be based on concrete instruction offsets.

// Empty blocks can share offsets, so block-order-based resolution

// may classify some jumps incorrectly.

op = match op.into() {

Opcode::JumpForward if target_offset <= current_offset => {

Opcode::JumpBackward.into()

}

Opcode::JumpBackward if target_offset > current_offset => {

Opcode::JumpForward.into()

}

Opcode::JumpBackwardNoInterrupt if target_offset > current_offset => {

Opcode::JumpForward.into()

}

_ => op,

};

info.instr = op.into();

let updated_cache = op.cache_entries() as u32;

recompile |= updated_cache != old_cache_entries;

info.cache_entries = updated_cache;

let new_arg = if matches!(op, Instruction::EndAsyncFor) {

let arg = offset_after

.checked_sub(target_offset + END_SEND_OFFSET)

.expect("END_ASYNC_FOR target must be before instruction");

OpArg::new(arg)

} else if matches!(

op.into(),

Opcode::JumpBackward | Opcode::JumpBackwardNoInterrupt

) {

let arg = offset_after

.checked_sub(target_offset)

.expect("backward jump target must be before instruction");

OpArg::new(arg)

} else {

let arg = target_offset

.checked_sub(offset_after)

.expect("forward jump target must be after instruction");

OpArg::new(arg)

};

recompile |= new_arg.instr_size() != old_arg_size;

info.arg = new_arg;

}

let cache_count = info.cache_entries as usize;

let (extras, lo_arg) = info.arg.split();

let loc_pair = (info.location, info.end_location);

locations.extend(core::iter::repeat_n(

loc_pair,

info.arg.instr_size() + cache_count,

));

// Collect linetable locations with lineno_override support

let lt_loc = LineTableLocation {

line: info

.lineno_override

.unwrap_or_else(|| info.location.line.get() as i32),

end_line: info.end_location.line.get() as i32,

col: info.location.character_offset.to_zero_indexed() as i32,

end_col: info.end_location.character_offset.to_zero_indexed() as i32,

};

linetable_locations.extend(core::iter::repeat_n(lt_loc, info.arg.instr_size()));

// CACHE entries inherit parent instruction's location

if cache_count > 0 {

linetable_locations.extend(core::iter::repeat_n(lt_loc, cache_count));

}

instructions.extend(

extras

.map(|byte| CodeUnit::new(Instruction::ExtendedArg, byte))

.chain([CodeUnit { op, arg: lo_arg }]),

);

// Emit CACHE code units after the instruction (all zeroed)

if cache_count > 0 {

instructions.extend(core::iter::repeat_n(

CodeUnit::new(Instruction::Cache, 0.into()),

cache_count,

));

}

current_offset = offset_after;

}

next_block = block.next;

}

if !recompile {

break;

}

instructions.clear();

locations.clear();

linetable_locations.clear();

}

// Generate linetable from linetable_locations (supports line 0 for RESUME)

let linetable = generate_linetable(

&linetable_locations,

first_line_number.get() as i32,

opts.debug_ranges,

);

// Generate exception table before moving source_path

let exceptiontable = generate_exception_table(&blocks, &block_to_index);

// Build localspluskinds with cell-local merging

let nlocals = varname_cache.len();

let ncells = cellvar_cache.len();

let nfrees = freevar_cache.len();

let numdropped = cellvar_cache

.iter()

.filter(|cv| varname_cache.contains(cv.as_str()))

.count();

let nlocalsplus = nlocals + ncells - numdropped + nfrees;

let mut localspluskinds = vec![0u8; nlocalsplus];

// Mark locals

for kind in localspluskinds.iter_mut().take(nlocals) {

*kind = CO_FAST_LOCAL;

}

// Mark cells (merged and non-merged)

for (i, cellvar) in cellvar_cache.iter().enumerate() {

let idx = cellfixedoffsets[i] as usize;

if varname_cache.contains(cellvar.as_str()) {

localspluskinds[idx] |= CO_FAST_CELL; // merged: LOCAL | CELL

} else {

localspluskinds[idx] = CO_FAST_CELL;

}

}

// Mark frees

for i in 0..nfrees {

let idx = cellfixedoffsets[ncells + i] as usize;

localspluskinds[idx] = CO_FAST_FREE;

}

// Apply CO_FAST_HIDDEN for inlined comprehension variables

for (name, &hidden) in &fast_hidden {

if hidden && let Some(idx) = varname_cache.get_index_of(name.as_str()) {

localspluskinds[idx] |= CO_FAST_HIDDEN;

}

}

Ok(CodeObject {

flags,

posonlyarg_count,

arg_count,

kwonlyarg_count,

source_path,

first_line_number: Some(first_line_number),

obj_name: obj_name.clone(),

qualname: qualname.unwrap_or(obj_name),

max_stackdepth,

instructions: CodeUnits::from(instructions),

locations: locations.into_boxed_slice(),

constants: constants.into_iter().collect(),

names: name_cache.into_iter().collect(),

varnames: varname_cache.into_iter().collect(),

cellvars: cellvar_cache.into_iter().collect(),

freevars: freevar_cache.into_iter().collect(),

localspluskinds: localspluskinds.into_boxed_slice(),

linetable,

exceptiontable,

})

}

fn dce(&mut self) {

// Truncate instructions after terminal instructions within each block

for block in &mut self.blocks {

let mut last_instr = None;

for (i, ins) in block.instructions.iter().enumerate() {

if ins.instr.is_scope_exit() || ins.instr.is_unconditional_jump() {

last_instr = Some(i);

break;

}

}

if let Some(i) = last_instr {

block.instructions.truncate(i + 1);

}

}

}

/// Clear blocks that are unreachable (not entry, not a jump target,

/// and only reachable via fall-through from a terminal block).

fn eliminate_unreachable_blocks(&mut self) {

let mut reachable = vec![false; self.blocks.len()];

reachable[0] = true;

// Fixpoint: only mark targets of already-reachable blocks

let mut changed = true;

while changed {

changed = false;

for i in 0..self.blocks.len() {

if !reachable[i] {

continue;

}

// Mark jump targets and exception handlers

for ins in &self.blocks[i].instructions {

if ins.target != BlockIdx::NULL && !reachable[ins.target.idx()] {

reachable[ins.target.idx()] = true;

changed = true;

}

if let Some(eh) = &ins.except_handler

&& !reachable[eh.handler_block.idx()]

{

reachable[eh.handler_block.idx()] = true;

changed = true;

}

}

// Mark fall-through

let next = self.blocks[i].next;

if next != BlockIdx::NULL

&& !reachable[next.idx()]

&& !self.blocks[i].instructions.last().is_some_and(|ins| {

ins.instr.is_scope_exit() || ins.instr.is_unconditional_jump()

})

{

reachable[next.idx()] = true;

changed = true;

}

}

}

for (i, block) in self.blocks.iter_mut().enumerate() {

if !reachable[i] {

block.instructions.clear();

}

}

}

/// Fold LOAD_CONST/LOAD_SMALL_INT + UNARY_NEGATIVE → LOAD_CONST (negative value)

fn fold_unary_negative(&mut self) {

for block in &mut self.blocks {

let mut i = 0;

while i + 1 < block.instructions.len() {

let next = &block.instructions[i + 1];

let Some(Instruction::UnaryNegative) = next.instr.real() else {

i += 1;

continue;

};

let curr = &block.instructions[i];

let value = match curr.instr.real() {

Some(Instruction::LoadConst { .. }) => {

let idx = u32::from(curr.arg) as usize;

match self.metadata.consts.get_index(idx) {

Some(ConstantData::Integer { value }) => {

Some(ConstantData::Integer { value: -value })

}

Some(ConstantData::Float { value }) => {

Some(ConstantData::Float { value: -value })

}

_ => None,

}

}

Some(Instruction::LoadSmallInt { .. }) => {

let v = u32::from(curr.arg) as i32;

Some(ConstantData::Integer {

value: BigInt::from(-v),

})

}

_ => None,

};

if let Some(neg_const) = value {

let (const_idx, _) = self.metadata.consts.insert_full(neg_const);

// Replace LOAD_CONST/LOAD_SMALL_INT with new LOAD_CONST

let load_location = block.instructions[i].location;

block.instructions[i].instr = Opcode::LoadConst.into();

block.instructions[i].arg = OpArg::new(const_idx as u32);

// Replace UNARY_NEGATIVE with NOP, inheriting the LOAD_CONST

// location so that remove_nops can clean it up

set_to_nop(&mut block.instructions[i + 1]);

block.instructions[i + 1].location = load_location;

block.instructions[i + 1].end_location = block.instructions[i].end_location;

// Skip the NOP, don't re-check

i += 2;

} else {

i += 1;

}

}

}

}

/// Constant folding: fold LOAD_CONST/LOAD_SMALL_INT + LOAD_CONST/LOAD_SMALL_INT + BINARY_OP

/// into a single LOAD_CONST when the result is computable at compile time.

/// = fold_binops_on_constants in CPython flowgraph.c

fn fold_binop_constants(&mut self) {

use oparg::BinaryOperator as BinOp;

for block in &mut self.blocks {

let mut i = 0;

while i + 2 < block.instructions.len() {

// Check pattern: LOAD_CONST/LOAD_SMALL_INT, LOAD_CONST/LOAD_SMALL_INT, BINARY_OP

let Some(Instruction::BinaryOp { .. }) = block.instructions[i + 2].instr.real()

else {

i += 1;

continue;

};

let op_raw = u32::from(block.instructions[i + 2].arg);

let Ok(op) = BinOp::try_from(op_raw) else {

i += 1;

continue;

};

let left = Self::get_const_value_from(&self.metadata, &block.instructions[i]);

let right = Self::get_const_value_from(&self.metadata, &block.instructions[i + 1]);

let (Some(left_val), Some(right_val)) = (left, right) else {

i += 1;

continue;

};

let result = Self::eval_binop(&left_val, &right_val, op);

if let Some(result_const) = result {

// Check result size limit (CPython limits to 4096 bytes)

if Self::const_too_big(&result_const) {

i += 1;

continue;

}

let (const_idx, _) = self.metadata.consts.insert_full(result_const);

// Replace first instruction with LOAD_CONST result

block.instructions[i].instr = Opcode::LoadConst.into();

block.instructions[i].arg = OpArg::new(const_idx as u32);

// NOP out the second and third instructions

let loc = block.instructions[i].location;

let end_loc = block.instructions[i].end_location;

set_to_nop(&mut block.instructions[i + 1]);

block.instructions[i + 1].location = loc;

block.instructions[i + 1].end_location = end_loc;

set_to_nop(&mut block.instructions[i + 2]);

block.instructions[i + 2].location = loc;

block.instructions[i + 2].end_location = end_loc;

// Don't advance - check if the result can be folded again

// (e.g., 2 ** 31 - 1)

i = i.saturating_sub(1); // re-check with previous instruction

} else {

i += 1;

}

}

}

}

fn get_const_value_from(

metadata: &CodeUnitMetadata,

info: &InstructionInfo,

) -> Option<ConstantData> {

match info.instr.real() {

Some(Instruction::LoadConst { .. }) => {

let idx = u32::from(info.arg) as usize;

metadata.consts.get_index(idx).cloned()

}

Some(Instruction::LoadSmallInt { .. }) => {

let v = u32::from(info.arg) as i32;

Some(ConstantData::Integer {

value: BigInt::from(v),

})

}

_ => None,

}

}

fn eval_binop(

left: &ConstantData,

right: &ConstantData,

op: oparg::BinaryOperator,

) -> Option<ConstantData> {

use oparg::BinaryOperator as BinOp;

match (left, right) {

(ConstantData::Integer { value: l }, ConstantData::Integer { value: r }) => {

let result = match op {

BinOp::Add => l + r,

BinOp::Subtract => l - r,

BinOp::Multiply => {

if !l.is_zero() && !r.is_zero() && l.bits() + r.bits() > MAX_INT_SIZE_BITS {

return None;

}

l * r

}

BinOp::FloorDivide => {

if r.is_zero() {

return None;

}

// Python floor division: round towards negative infinity

let (q, rem) = (l.clone() / r.clone(), l.clone() % r.clone());

if !rem.is_zero() && (rem < BigInt::from(0)) != (*r < BigInt::from(0)) {

q - 1

} else {

q

}

}

BinOp::Remainder => {

if r.is_zero() {

return None;

}

// Python modulo: result has same sign as divisor

let rem = l.clone() % r.clone();

if !rem.is_zero() && (rem < BigInt::from(0)) != (*r < BigInt::from(0)) {

rem + r

} else {

rem

}

}

BinOp::Power => {

let exp: u64 = r.try_into().ok()?;

let exp_usize = usize::try_from(exp).ok()?;

if !l.is_zero() && exp > 0 && l.bits() > MAX_INT_SIZE_BITS / exp {

return None;

}

num_traits::pow::pow(l.clone(), exp_usize)

}

BinOp::Lshift => {

let shift: u64 = r.try_into().ok()?;

let shift_usize = usize::try_from(shift).ok()?;

if shift > MAX_INT_SIZE_BITS

|| (!l.is_zero() && l.bits() > MAX_INT_SIZE_BITS - shift)

{

return None;

}

l << shift_usize

}

BinOp::Rshift => {

let shift: u32 = r.try_into().ok()?;

l >> (shift as usize)

}

BinOp::And => l & r,

BinOp::Or => l | r,

BinOp::Xor => l ^ r,

_ => return None,

};

Some(ConstantData::Integer { value: result })

}

(ConstantData::Float { value: l }, ConstantData::Float { value: r }) => {

let result = match op {