self.emit_resume_for_scope(CompilerScope::Module, 1);

emit!(self, PseudoInstruction::AnnotationsPlaceholder);

let (doc, statements) = split_doc_with_range(&body.body, self.opts);

let module_start_loc = self.module_start_location(&body.body);

// Handle annotation bookkeeping before the docstring assignment, as

// codegen_body() does after _PyCodegen_Module() inserts the prefix set.

}

ast::Stmt::AugAssign(ast::StmtAugAssign {

target, op, value, ..

}) => self.compile_augassign(target, *op, value)?,

ast::Stmt::AnnAssign(ast::StmtAnnAssign {

target,

annotation,

self.set_qualname();

// Handle docstring - store in co_consts[0] if present

let (doc_info, body) = split_doc_with_range(body, self.opts);

let doc_str = doc_info.as_ref().map(|(doc, _)| doc);

if let Some(doc) = &doc_str {

// Docstring present: store in co_consts[0] and set HAS_DOCSTRING flag

self.code_stack.last_mut().unwrap().private = Some(name.to_owned());

// 2. Set up class namespace

let (doc_str, body) = split_doc_with_range(body, self.opts);

let class_body_prefix_range = self.source_line_start_range(firstlineno);

self.set_source_range(class_body_prefix_range);

}

/// [CPython `compiler_addcompare`](https://github.com/python/cpython/blob/627894459a84be3488a1789919679c997056a03c/Python/compile.c#L2880-L2924)

fn compile_addcompare(&mut self, op: ast::CmpOp) {

match op {

ast::CmpOp::Eq => emit!(

self,

if mid_comparators.is_empty() {

self.compile_expression(last_comparator)?;

self.set_source_range(compare_range);

self.compile_addcompare(*last_op);

return Ok(());

}

emit!(self, Instruction::Swap { i: 2 });

emit!(self, Instruction::Copy { i: 2 });

self.compile_addcompare(*op);

// if comparison result is false, we break with this value; if true, try the next one.

emit!(self, Instruction::Copy { i: 1 });

self.compile_expression(last_comparator)?;

self.set_source_range(compare_range);

self.compile_addcompare(*last_op);

let end = self.new_block();

emit!(self, PseudoInstruction::JumpNoInterrupt { delta: end });

self.compile_expression(left)?;

self.compile_expression(last_comparator)?;

self.set_source_range(compare_range);

self.compile_addcompare(*last_op);

self.emit_pop_jump_by_condition(condition, target_block);

return Ok(());

}

self.set_source_range(compare_range);

emit!(self, Instruction::Swap { i: 2 });

emit!(self, Instruction::Copy { i: 2 });

self.compile_addcompare(*op);

emit!(self, Instruction::ToBool);

emit!(self, Instruction::PopJumpIfFalse { delta: cleanup });

}

self.compile_expression(last_comparator)?;

self.set_source_range(compare_range);

self.compile_addcompare(*last_op);

emit!(self, Instruction::ToBool);

self.emit_pop_jump_by_condition(condition, target_block);

let end = self.new_block();

fn compile_augassign(

&mut self,

target: &ast::Expr,

op: ast::Operator,

value: &ast::Expr,

) -> CompileResult<()> {

let stmt_range = self.current_source_range;

Ok(())

}

fn compile_op(&mut self, op: ast::Operator, inplace: bool) {

let bin_op = match op {

ast::Operator::Add => BinaryOperator::Add,

ast::Operator::Sub => BinaryOperator::Subtract,

/// Compile a boolean operation as an expression.

/// This means, that the last value remains on the stack.

fn compile_bool_op(&mut self, op: ast::BoolOp, values: &[ast::Expr]) -> CompileResult<()> {

let boolop_range = self.current_source_range;

let after_block = self.new_block();

let (last_value, prefix_values) = values.split_last().unwrap();

/// Emit CPython-style pseudo conditional jump for short-circuit evaluation.

/// flowgraph.c lowers it to `COPY 1; TO_BOOL; POP_JUMP_IF_*`.

fn emit_short_circuit_test(&mut self, op: ast::BoolOp, target: BlockIdx) {

match op {

ast::BoolOp::And => {

emit!(self, PseudoInstruction::JumpIfFalse { delta: target });

func, arguments, ..

}) => self.compile_call(func, arguments)?,

ast::Expr::BoolOp(ast::ExprBoolOp { op, values, .. }) => {

self.compile_bool_op(*op, values)?

}

ast::Expr::BinOp(ast::ExprBinOp {

left, op, right, ..

// Restore full expression range before emitting the operation

self.set_source_range(range);

self.compile_op(*op, false);

}

ast::Expr::Subscript(ast::ExprSubscript {

value, slice, ctx, ..

expanded_str

}

fn split_doc_with_range(

body: &[ast::Stmt],

opts: CompileOpts,

) -> (Option<(String, TextRange)>, &[ast::Stmt]) {

if let Some((ast::Stmt::Expr(expr), body_rest)) = body.split_first() {

let doc_comment = match &*expr.value {

ast::Expr::StringLiteral(value) => Some((&value.value, expr.value.range())),

}

#[cfg(test)]

fn split_doc(body: &[ast::Stmt], opts: CompileOpts) -> (Option<String>, &[ast::Stmt]) {

let (doc, body) = split_doc_with_range(body, opts);

(doc.map(|(doc, _)| doc), body)

}

in_async_scope: is_async,

};

compiler.set_qualname();

let (_doc_str, body) = split_doc(body, compiler.opts);

let start_label = compiler.use_cpython_function_start_label();

let is_gen = is_async || compiler.current_symbol_table().is_generator;

let stop_iteration_block = if is_gen {

const VISITED: i32 = -1;

fn is_swappable(instr: AnyInstruction) -> bool {

matches!(

instr.into(),

AnyOpcode::Real(Opcode::StoreFast | Opcode::PopTop)

| AnyOpcode::Pseudo(PseudoOpcode::StoreFastMaybeNull)

)

if i >= block.instruction_used {

return None;

}

let info = &block.instructions[i];

let info_lineno = instruction_lineno(info);

if lineno >= 0 && info_lineno != lineno {

return None;

}

if matches!(info.instr, AnyInstruction::Real(Instruction::Nop)) {

continue;

}

if is_swappable(info.instr) {

return Some(i);

}

return None;

}

fn is_conditional_jump_opcode(instr: AnyInstruction) -> bool {

matches!(

instr.real().map(Into::into),

Some(

let Some(last_ins) = basicblock_last_instr(&blocks[idx]).copied() else {

return Ok(());

};

if !is_conditional_jump_opcode(last_ins.instr) {

return Ok(());

}

debug_assert!(!last_ins.instr.is_assembler());

}

impl From<FormatGrouping> for char {

fn from(fg: FormatGrouping) -> Self {

match fg {

FormatGrouping::Comma => ',',

FormatGrouping::Underscore => '_',

}

}

impl From<&FormatGrouping> for char {

fn from(fg: &FormatGrouping) -> Self {

Self::from(*fg)

}

pub enum FormatType {

String,

return Err(FormatSpecError::DecimalDigitsTooMany);

}

let (grouping_option, text) = FormatGrouping::parse(text);

if let Some(grouping) = grouping_option {

Self::validate_separator(grouping, text)?;

}

let (precision, text) = parse_precision(text)?;

})

}

fn validate_separator(grouping: FormatGrouping, text: &Wtf8) -> Result<(), FormatSpecError> {

let mut chars = text.code_points().peekable();

let grouping_char = char::from(grouping);

match chars.peek().and_then(|cp| CodePoint::to_char(*cp)) {

Some(c) if c == ',' || c == '_' => {

if c == grouping_char {

Err(FormatSpecError::UnspecifiedFormat(c, c))

} else {

Err(FormatSpecError::ExclusiveFormat(',', '_'))

}

#[inline]

pub(super) fn as_raw_fd(self) -> Raw {

self.fd

}

}

inner: BorrowedInner<'fd>,

impl PartialEq for Borrowed<'_> {

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

self.as_raw() == other.as_raw()

}

impl Eq for Borrowed<'_> {}

impl fmt::Debug for Borrowed<'_> {

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

}

impl Borrowed<'_> {

/// Create a `crt_fd::Borrowed` from a raw file descriptor.

///

/// # Safety

(time_out, nsec_out as _)

}

fn file_time_to_time_t_nsec(in_ptr: FILETIME) -> (libc::time_t, libc::c_int) {

let in_val: i64 = unsafe { core::mem::transmute_copy(&in_ptr) };

let nsec_out = (in_val % 10_000_000) * 100; // FILETIME is in units of 100 nsec.

let time_out = (in_val / 10_000_000) - SECS_BETWEEN_EPOCHS;

(time_out, nsec_out as _)

)

} else {

(

file_time_to_time_t_nsec(info.ftCreationTime),

(0, 0),

file_time_to_time_t_nsec(info.ftLastWriteTime),

file_time_to_time_t_nsec(info.ftLastAccessTime),

)

};

let st_nlink = info.nNumberOfLinks as i32;