Struct rustpython_compiler_core::CodeObject

pub struct CodeObject<C: Constant = ConstantData> {

    pub instructions: Box<[Instruction]>,
    pub locations: Box<[Location]>,
    pub flags: CodeFlags,
    pub posonlyarg_count: usize,
    pub arg_count: usize,
    pub kwonlyarg_count: usize,
    pub source_path: C::Name,
    pub first_line_number: usize,
    pub max_stackdepth: u32,
    pub obj_name: C::Name,
    pub cell2arg: Option<Box<[isize]>>,
    pub constants: Box<[C]>,
    pub names: Box<[C::Name]>,
    pub varnames: Box<[C::Name]>,
    pub cellvars: Box<[C::Name]>,
    pub freevars: Box<[C::Name]>,
}

Primary container of a single code object. Each python function has a codeobject. Also a module has a codeobject.

Fields

instructions: Box<[Instruction]>

locations: Box<[Location]>

flags: CodeFlags

posonlyarg_count: usize

arg_count: usize

kwonlyarg_count: usize

source_path: C::Name

first_line_number: usize

max_stackdepth: u32

obj_name: C::Name

cell2arg: Option<Box<[isize]>>

constants: Box<[C]>

names: Box<[C::Name]>

varnames: Box<[C::Name]>

cellvars: Box<[C::Name]>

freevars: Box<[C::Name]>

Implementations

impl<C: Constant> CodeObject<C>

pub fn arg_names(&self) -> Arguments<'_, C::Name>

Get all arguments of the code object like inspect.getargs

pub fn label_targets(&self) -> BTreeSet<Label>

Return the labels targeted by the instructions of this CodeObject

pub fn display_expand_codeobjects(&self) -> impl Display + '_

Recursively display this CodeObject

pub fn map_bag<Bag: ConstantBag>(self, bag: Bag) -> CodeObject<Bag::Constant>

Map this CodeObject to one that holds a Bag::Constant

pub fn map_clone_bag<Bag: ConstantBag>(
    &self,
    bag: &Bag
) -> CodeObject<Bag::Constant>

Same as map_bag but clones self

impl CodeObject<ConstantData>

pub fn from_bytes(data: &[u8]) -> Result<Self, CodeDeserializeError>

Load a code object from bytes

pub fn to_bytes(&self) -> Vec<u8>

Serialize this bytecode to bytes.

Trait Implementations

impl<C: Clone + Constant> Clone for CodeObject<C>where
    C::Name: Clone,

fn clone(&self) -> CodeObject<C>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<C: Constant> Debug for CodeObject<C>

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

Formats the value using the given formatter.

impl<'de, C> Deserialize<'de> for CodeObject<C>where
    C::Name: Deserialize<'de> + Deserialize<'de>,
    C: Deserialize<'de> + Constant,

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

Deserialize this value from the given Serde deserializer.

impl<C: Constant> Display for CodeObject<C>

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

Formats the value using the given formatter.

impl<C> Serialize for CodeObject<C>where
    C::Name: Serialize + Serialize,
    C: Serialize + Constant,

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

Serialize this value into the given Serde serializer.