pub const NULL: Self = Self::new(0);

#[must_use]

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

Self(value)

}

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

#[must_use]

pub const fn as_u8(self) -> u8 {

self.0

}

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

#[must_use]

pub const fn as_u32(self) -> u32 {

self.0 as u32

}

fn from(raw: u8) -> Self {

Self::new(raw)

}

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

self.0.fmt(f)

}

pub const NULL: Self = Self::new(0);

#[must_use]

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

Self(value)

}

/// Returns how many CodeUnits a instruction with this op_arg will be encoded as

#[inline]

pub const fn instr_size(self) -> usize {

(self.0 > 0xff) as usize + (self.0 > 0xff_ff) as usize + (self.0 > 0xff_ff_ff) as usize + 1

}

/// returns the arg split into any necessary ExtendedArg components (in big-endian order) and

/// the arg for the real opcode itself

#[inline(always)]

pub fn split(self) -> (impl ExactSizeIterator<Item = OpArgByte>, OpArgByte) {

let mut it = self

.0

.to_le_bytes()

.map(OpArgByte)

.into_iter()

.take(self.instr_size());

let lo = it.next().unwrap();

(it.rev(), lo)

}

fn from(raw: u32) -> Self {

Self::new(raw)

}

#[inline(always)]

pub const fn get(&mut self, ins: CodeUnit) -> (Instruction, OpArg) {

let arg = self.extend(ins.arg);

if !matches!(ins.op, Instruction::ExtendedArg) {

self.reset();

}

(ins.op, arg)

}

#[inline(always)]

pub const fn extend(&mut self, arg: OpArgByte) -> OpArg {

self.state = (self.state << 8) | arg.as_u32();

OpArg::new(self.state)

}

#[inline(always)]

pub const fn reset(&mut self) {

self.state = 0

}

(

$(#[$enum_meta:meta])*

$vis:vis enum $name:ident {

$(

$(#[$variant_meta:meta])*

$variant:ident = $value:tt

),* $(,)?

}

) => {

$(#[$enum_meta])*

$vis enum $name {

$(

$(#[$variant_meta])*

$variant, // Do assign value to variant.

)*

}

impl_oparg_enum!(

$vis enum $name {

$(

$variant = $value,

)*

}

);

};

(

$vis:vis enum $name:ident {

$(

$variant:ident = $value:tt

),* $(,)?

}

) => {

impl $name {

/// Returns the oparg as a [`u8`] value.

#[must_use]

$vis const fn as_u8(self) -> u8 {

match self {

$(

Self::$variant => impl_oparg_enum!(@discriminant $value),

)*

}

}

/// Returns the oparg as a [`u32`] value.

#[must_use]

$vis const fn as_u32(self) -> u32 {

self.as_u8() as u32

}

$vis const fn try_from_u8(value: u8) -> Result<Self, $crate::marshal::MarshalError> {

Ok(match value {

$(

impl_oparg_enum!(@discriminant $value) => Self::$variant,

)*

_ => return Err($crate::marshal::MarshalError::InvalidBytecode),

})

}

$vis const fn try_from_u32(value: u32) -> Result<Self, $crate::marshal::MarshalError> {

if value > (u8::MAX as u32) {

return Err($crate::marshal::MarshalError::InvalidBytecode);

}

// We already validated this is a lossles cast.

Self::try_from_u8(value as u8)

}

/// Iterate over the variants.

$vis fn iter() -> impl Iterator<Item = Self> {

[$(Self::$variant),*].iter().copied()

}

}

impl TryFrom<u8> for $name {

type Error = $crate::marshal::MarshalError;

fn try_from(value: u8) -> Result<Self, Self::Error> {

Self::try_from_u8(value)

}

}

impl TryFrom<u32> for $name {

type Error = $crate::marshal::MarshalError;

fn try_from(value: u32) -> Result<Self, Self::Error> {

Self::try_from_u32(value)

}

}

impl From<$name> for u8 {

fn from(value: $name) -> Self {

value.as_u8()

}

}

impl From<$name> for u32 {

fn from(value: $name) -> Self {

value.as_u32()

}

}

impl ::core::fmt::Display for $name {

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

match self {

$(

Self::$variant => impl_oparg_enum!(@display f, $value),

)*

}

}

}

impl OpArgType for $name {}

};

(@discriminant ($num:literal, $str:literal)) => { $num };

(@discriminant $num:literal) => { $num };

(@display $f:expr, ($num:literal, $str:literal)) => {

::core::fmt::Display::fmt($str, $f)

};

(@display $f:expr, $num:literal) => {

::core::fmt::Display::fmt(&$num, $f)

};

/// https://github.com/python/cpython/blob/v3.14.4/Include/internal/pycore_intrinsics.h#L9-L20

#[must_use]

pub const fn desc(&self) -> &str {

match self {

Self::Invalid => "INTRINSIC_1_INVALID",

Self::Print => "INTRINSIC_PRINT",

Self::ImportStar => "INTRINSIC_IMPORT_STAR",

Self::StopIterationError => "INTRINSIC_STOPITERATION_ERROR",

Self::AsyncGenWrap => "INTRINSIC_ASYNC_GEN_WRAP",

Self::UnaryPositive => "INTRINSIC_UNARY_POSITIVE",

Self::ListToTuple => "INTRINSIC_LIST_TO_TUPLE",

Self::TypeVar => "INTRINSIC_TYPEVAR",

Self::ParamSpec => "INTRINSIC_PARAMSPEC",

Self::TypeVarTuple => "INTRINSIC_TYPEVARTUPLE",

Self::SubscriptGeneric => "INTRINSIC_SUBSCRIPT_GENERIC",

Self::TypeAlias => "INTRINSIC_TYPEALIAS",

}

}

/// https://github.com/python/cpython/blob/v3.14.4/Include/internal/pycore_intrinsics.h#L26-L31

#[must_use]

pub const fn desc(&self) -> &str {

match self {

Self::Invalid => "INTRINSIC_2_INVALID",

Self::PrepReraiseStar => "INTRINSIC_PREP_RERAISE_STAR",

Self::TypeVarWithBound => "INTRINSIC_TYPEVAR_WITH_BOUND",

Self::TypeVarWithConstraint => "INTRINSIC_TYPEVAR_WITH_CONSTRAINTS",

Self::SetFunctionTypeParams => "INTRINSIC_SET_FUNCTION_TYPE_PARAMS",

Self::SetTypeparamDefault => "INTRINSIC_SET_TYPEPARAM_DEFAULT",

}

}

type Error = MarshalError;

/// Decode from CPython-compatible power-of-two value

fn try_from(value: u32) -> Result<Self, Self::Error> {

match value {

0x01 => Ok(Self::Defaults),

0x02 => Ok(Self::KwOnlyDefaults),

0x04 => Ok(Self::Annotations),

0x08 => Ok(Self::Closure),

0x10 => Ok(Self::Annotate),

0x20 => Ok(Self::TypeParams),

_ => Err(MarshalError::InvalidBytecode),

}

}

Less,

LessOrEqual,

Equal,

NotEqual,

Greater,

GreaterOrEqual,

type Error = MarshalError;

fn try_from(value: u8) -> Result<Self, Self::Error> {

Self::try_from(value as u32)

}

type Error = MarshalError;

/// Decode from `COMPARE_OP` arg: `(cmp_index << 5) | mask`.

fn try_from(value: u32) -> Result<Self, Self::Error> {

match value >> 5 {

0 => Ok(Self::Less),

1 => Ok(Self::LessOrEqual),

2 => Ok(Self::Equal),

3 => Ok(Self::NotEqual),

4 => Ok(Self::Greater),

5 => Ok(Self::GreaterOrEqual),

_ => Err(MarshalError::InvalidBytecode),

}

}

match value {

ComparisonOperator::Less => 2,

ComparisonOperator::LessOrEqual => (1 << 5) | 2 | 8,

ComparisonOperator::Equal => (2 << 5) | 8,

ComparisonOperator::NotEqual => (3 << 5) | 1 | 2 | 4,

ComparisonOperator::Greater => (4 << 5) | 4,

ComparisonOperator::GreaterOrEqual => (5 << 5) | 4 | 8,

}

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

let op = match self {

Self::Less => "<",

Self::LessOrEqual => "<=",

Self::Equal => "==",

Self::NotEqual => "!=",

Self::Greater => ">",

Self::GreaterOrEqual => ">=",

};

f.write_str(op)

}

/// Get the "inplace" version of the operator.

/// This has no effect if `self` is already an "inplace" operator.

///

/// # Example

/// ```rust

/// use rustpython_compiler_core::bytecode::BinaryOperator;

///

/// assert_eq!(BinaryOperator::Power.as_inplace(), BinaryOperator::InplacePower);

///

/// assert_eq!(BinaryOperator::InplaceSubtract.as_inplace(), BinaryOperator::InplaceSubtract);

/// ```

#[must_use]

pub const fn as_inplace(self) -> Self {

match self {

Self::Add => Self::InplaceAdd,

Self::And => Self::InplaceAnd,

Self::FloorDivide => Self::InplaceFloorDivide,

Self::Lshift => Self::InplaceLshift,

Self::MatrixMultiply => Self::InplaceMatrixMultiply,

Self::Multiply => Self::InplaceMultiply,

Self::Remainder => Self::InplaceRemainder,

Self::Or => Self::InplaceOr,

Self::Power => Self::InplacePower,

Self::Rshift => Self::InplaceRshift,

Self::Subtract => Self::InplaceSubtract,

Self::TrueDivide => Self::InplaceTrueDivide,

Self::Xor => Self::InplaceXor,

_ => self,

}

}

/// https://github.com/python/cpython/blob/v3.14.4/Include/opcode.h#L10-L36

#[must_use]

pub const fn desc(&self) -> &str {

match self {

Self::Add => "NB_ADD",

Self::And => "NB_AND",

Self::FloorDivide => "NB_FLOOR_DIVIDE",

Self::Lshift => "NB_LSHIFT",

Self::MatrixMultiply => "NB_MATRIX_MULTIPLY",

Self::Multiply => "NB_MULTIPLY",

Self::Remainder => "NB_REMAINDER",

Self::Or => "NB_OR",

Self::Power => "NB_POWER",

Self::Rshift => "NB_RSHIFT",

Self::Subtract => "NB_SUBTRACT",

Self::TrueDivide => "NB_TRUE_DIVIDE",

Self::Xor => "NB_XOR",

Self::InplaceAdd => "NB_INPLACE_ADD",

Self::InplaceAnd => "NB_INPLACE_AND",

Self::InplaceFloorDivide => "NB_INPLACE_FLOOR_DIVIDE",

Self::InplaceLshift => "NB_INPLACE_LSHIFT",

Self::InplaceMatrixMultiply => "NB_INPLACE_MATRIX_MULTIPLY",

Self::InplaceMultiply => "NB_INPLACE_MULTIPLY",

Self::InplaceRemainder => "NB_INPLACE_REMAINDER",

Self::InplaceOr => "NB_INPLACE_OR",

Self::InplacePower => "NB_INPLACE_POWER",

Self::InplaceRshift => "NB_INPLACE_RSHIFT",

Self::InplaceSubtract => "NB_INPLACE_SUBTRACT",

Self::InplaceTrueDivide => "NB_INPLACE_TRUE_DIVIDE",

Self::InplaceXor => "NB_INPLACE_XOR",

Self::Subscr => "NB_SUBSCR",

}

}

fn from(value: u32) -> Self {

let [before, after, ..] = value.to_le_bytes();

Self { before, after }

}

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

write!(f, "before: {}, after: {}", self.before, self.after)

}

(

$(#[$oparg_meta:meta])*

$vis:vis struct $name:ident(u32)

) => {

$(#[$oparg_meta])*

$vis struct $name(u32);

impl $name {

#[doc = concat!("Creates a new [`", stringify!($name), "`] instance.")]

#[must_use]

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

Self(value)

}

/// Returns the oparg as a [`u32`] value.

#[must_use]

pub const fn as_u32(self) -> u32 {

self.0

}

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

#[must_use]

pub const fn as_usize(self) -> usize {

self.0 as usize

}

}

impl From<u32> for $name {

fn from(value: u32) -> Self {

Self::from_u32(value)

}

}

impl From<$name> for u32 {

fn from(value: $name) -> Self {

value.as_u32()

}

}

impl From<$name> for usize {

fn from(value: $name) -> Self {

value.as_usize()

}

}

impl ::core::fmt::Display for $name {

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

self.0.fmt(f)

}

}

impl OpArgType for $name {}

}

/// [CPython `RESUME_OPARG_LOCATION_MASK`](https://github.com/python/cpython/blob/v3.14.3/Include/internal/pycore_opcode_utils.h#L84)

pub const LOCATION_MASK: u32 = 0x3;

/// [CPython `RESUME_OPARG_DEPTH1_MASK`](https://github.com/python/cpython/blob/v3.14.3/Include/internal/pycore_opcode_utils.h#L85)

pub const DEPTH1_MASK: u32 = 0x4;

#[must_use]

pub const fn new(location: ResumeLocation, is_exception_depth1: bool) -> Self {

let value = if is_exception_depth1 {

Self::DEPTH1_MASK

} else {

0

};

Self::from_u32(location.as_u32() | value)

}

/// Resume location is determined by [`Self::LOCATION_MASK`].

#[must_use]

pub fn location(&self) -> ResumeLocation {

// SAFETY: The mask should return a value that is in range.

unsafe { ResumeLocation::try_from(self.as_u32() & Self::LOCATION_MASK).unwrap_unchecked() }

}

/// True if the bit at [`Self::DEPTH1_MASK`] is on.

#[must_use]

pub const fn is_exception_depth1(&self) -> bool {

(self.as_u32() & Self::DEPTH1_MASK) != 0

}

/// At the start of a function, which is neither a generator, coroutine nor an async generator.

AtFuncStart,

/// After a `yield` expression.

AfterYield,

/// After a `yield from` expression.

AfterYieldFrom,

/// After an `await` expression.

AfterAwait,

fn from(location: ResumeLocation) -> Self {

Self::new(location, false)

}

type Error = MarshalError;

fn try_from(value: u32) -> Result<Self, Self::Error> {

Ok(match value {

0 => Self::AtFuncStart,

1 => Self::AfterYield,

2 => Self::AfterYieldFrom,

3 => Self::AfterAwait,

_ => return Err(Self::Error::InvalidBytecode),

})

}

#[must_use]

pub const fn as_u8(&self) -> u8 {

match self {

Self::AtFuncStart => 0,

Self::AfterYield => 1,

Self::AfterYieldFrom => 2,

Self::AfterAwait => 3,

}

}

#[must_use]

pub const fn as_u32(&self) -> u32 {

self.as_u8() as u32

}

#[must_use]