Method try_optimize_format_str

crates/codegen/src/compile.rs:10055–10113

Optimize `'format_str' % (args,)` into f-string bytecode. Returns true if optimization was applied, false to fall back to normal BINARY_OP %. Matches CPython's codegen.c `compiler_formatted_value` optimization.

(
        &mut self,
        format_str: &str,
        args: &[ast::Expr],
        range: ruff_text_size::TextRange,
    )

    /// Returns true if optimization was applied, false to fall back to normal BINARY_OP %.
    /// Matches CPython's codegen.c `compiler_formatted_value` optimization.
    fn try_optimize_format_str(
        &mut self,
        format_str: &str,
        args: &[ast::Expr],
        range: ruff_text_size::TextRange,
    ) -> CompileResult<bool> {
        // Parse format string into segments
        let Some(segments) = Self::parse_percent_format(format_str) else {
            return Ok(false);
        };

        // Verify arg count matches specifier count
        let spec_count = segments.iter().filter(|s| s.conversion.is_some()).count();
        if spec_count != args.len() {
            return Ok(false);
        }

        self.set_source_range(range);

        // Special case: no specifiers, just %% escaping → constant fold
        if spec_count == 0 {
            let folded: String = segments.iter().map(|s| s.literal.as_str()).collect();
            self.emit_load_const(ConstantData::Str {
                value: folded.into(),
            });
            return Ok(true);
        }

        // Emit f-string style bytecode
        let mut part_count: u32 = 0;
        let mut arg_idx = 0;

        for seg in &segments {
            if !seg.literal.is_empty() {
                self.emit_load_const(ConstantData::Str {
                    value: seg.literal.clone().into(),
                });
                part_count += 1;
            }
            if let Some(conv) = seg.conversion {
                self.compile_expression(&args[arg_idx])?;
                self.set_source_range(range);
                emit!(self, Instruction::ConvertValue { oparg: conv });
                emit!(self, Instruction::FormatSimple);
                part_count += 1;
                arg_idx += 1;
            }
        }

        if part_count == 0 {
            self.emit_load_const(ConstantData::Str {
                value: String::new().into(),
            });
        } else if part_count > 1 {
            emit!(self, Instruction::BuildString { count: part_count });
        }

        Ok(true)