GeezerVison

Walkthrough

A new CodeUnits wrapper type consolidates bytecode instruction storage, replacing direct Box<[CodeUnit]> usage across the compiler and VM. The public parse_instructions_from_bytes function is removed and parsing logic is centralized into CodeUnits conversion implementations.

Changes

Sequence Diagram

sequenceDiagram
    autonumber
    participant Old as Old Flow
    participant New as New Flow
    
    rect rgba(200, 220, 240, 0.3)
        Note over Old,New: Instruction Deserialization
        Old->>Old: parse_instructions_from_bytes()
        Old->>Old: Iterate chunks (2 bytes)
        Old->>Old: Instruction::try_from() per chunk
        Old->>Old: Collect to Box<[CodeUnit]>
        Old-->>Old: Return Result<Box<[CodeUnit]>>
    end
    
    rect rgba(220, 240, 200, 0.3)
        Note over New: (New Flow)
        New->>New: CodeUnits::try_from(&[u8])
        New->>New: Parse all bytes at once
        New-->>New: Return Result<CodeUnits>
    end
    
    rect rgba(240, 230, 200, 0.3)
        Note over Old,New: Usage
        Old->>Old: CodeObject { instructions: Box<[...]> }
        New->>New: CodeObject { instructions: CodeUnits(...) }
    end

Estimated code review effort

🎯 3 (Moderate) | ⏱️ ~25 minutes

• Areas requiring attention:
  • compiler/core/src/bytecode.rs: New CodeUnits type and its trait implementations (especially TryFrom<&[u8]> logic for byte parsing)
  • compiler/core/src/marshal.rs: Verification that instruction deserialization behavior is preserved with the new CodeUnits::try_from approach
  • Cross-module consistency: Ensure all call sites correctly use the new CodeUnits API and handle errors appropriately

Possibly related PRs

• code object linetable #6150: Modifies CodeObject representation and related serialization/deserialization paths in tandem with bytecode structure changes.
• Fix PyCode constructor/replace #6193: Refactors bytecode parsing and CodeUnit/CodeObject construction, replacing previous parsing helpers with new centralized conversion logic.

Poem

🐰 A wrapper hops onto the bytecode stack,
CodeUnits bundles instructions back-to-back,
Where parsing once scattered, now unified stands,
The bytecode flows smoothly through compiler's hands. ✨

Pre-merge checks and finishing touches

Learnt from: CR
Repo: RustPython/RustPython PR: 0
File: .github/copilot-instructions.md:0-0
Timestamp: 2025-09-11T05:06:59.971Z
Learning: Applies to {vm,stdlib}/**/*.rs : Use RustPython macros (`pyclass`, `pymodule`, `pyfunction`, etc.) when implementing Python functionality in Rust

Learnt from: youknowone
Repo: RustPython/RustPython PR: 6110
File: vm/src/frame.rs:1311-1316
Timestamp: 2025-08-26T05:20:54.540Z
Learning: In the RustPython codebase, only certain builtin types should be marked with the SEQUENCE flag for pattern matching. List and tuple are sequences, but bytes, bytearray, and range are not considered sequences in this context, even though they may implement sequence-like protocols.

Thanks for using CodeRabbit! It's free for OSS, and your support helps us grow. If you like it, consider giving us a shout-out.

_{Comment @coderabbitai help to get the list of available commands and usage tips.}

👍