Enum Expr 

pub enum Expr {
    Const(ConstVal),
    Local {
        var: u32,
        ty: TypeRef,
    },
    This,
    New {
        cls: String,
        ty: TypeRef,
        args: Vec<Expr>,
        raw: bool,
    },
    NewArray {
        elem: TypeRef,
        dims: Vec<Expr>,
        trailing_dims: u8,
        init: Option<Vec<Expr>>,
    },
    NewMultiArray {
        ty: TypeRef,
        dims: Vec<Expr>,
    },
    Field {
        owner: Option<Box<Expr>>,
        cls: String,
        name: String,
        ty: TypeRef,
        is_static: bool,
    },
    Method {
        owner: Option<Box<Expr>>,
        cls: String,
        name: String,
        desc: MethodDescriptor,
        args: Vec<Expr>,
        is_static: bool,
        is_interface: bool,
        is_special: bool,
        is_super: bool,
        is_dynamic: bool,
        type_args: Vec<String>,
    },
    ArrayIndex {
        array: Box<Expr>,
        index: Box<Expr>,
    },
    Cast {
        ty: TypeRef,
        e: Box<Expr>,
    },
    InstanceOf {
        e: Box<Expr>,
        ty: TypeRef,
    },
    Un {
        op: UnOp,
        e: Box<Expr>,
    },
    Bin {
        op: BinOp,
        l: Box<Expr>,
        r: Box<Expr>,
        ty: Option<TypeRef>,
    },
    Cond {
        c: Box<Expr>,
        t: Box<Expr>,
        f: Box<Expr>,
    },
    Assign {
        target: Box<Expr>,
        op: AssignOp,
        value: Box<Expr>,
    },
    PreIncDec {
        e: Box<Expr>,
        delta: i64,
        wide: bool,
    },
    PostIncDec {
        e: Box<Expr>,
        delta: i64,
        wide: bool,
    },
    Lambda(Box<LambdaExpr>),
    StringConcat(Vec<ConcatPart>),
    Raw(String),
    RawT(String, TypeRef),
    Invokedynamic {
        name: String,
        desc: MethodDescriptor,
        args: Vec<Expr>,
        bsm_text: String,
        bsm_static_args: Vec<BsmArg>,
    },
    AnonNew {
        cls: String,
        base: TypeRef,
        args: Vec<Expr>,
        body: String,
    },
}

Variants

Const(ConstVal)

Local

Local variable by VarId, with its declared type (needed for category-1 vs category-2 stack operations like dup2/pop2).

Fields

var: u32

ty: TypeRef

This

New

new T(args) (constructor call folded with New when possible).

Fields

cls: String

ty: TypeRef

args: Vec<Expr>

raw: bool

true if this is a raw new whose <init> hasn’t been folded yet.

NewArray

Array creation: new int[n], new int[]{...}, new int[a][b][].

Fields

elem: TypeRef

dims: Vec<Expr>

dimension sizes for the created dimensions

trailing_dims: u8

trailing empty dimensions count (e.g. new int[3][] -> dims=[3], trailing=1)

init: Option<Vec<Expr>>

initializer for new T[]{...} form

NewMultiArray

Multi-dimensional array creation multianewarray.

Fields

ty: TypeRef

dims: Vec<Expr>

Field

Fields

owner: Option<Box<Expr>>

None = this (instance field of current class) or static import-style.

cls: String

Declaring class internal name.

name: String

ty: TypeRef

is_static: bool

Method

Fields

owner: Option<Box<Expr>>

cls: String

name: String

desc: MethodDescriptor

args: Vec<Expr>

is_static: bool

is_interface: bool

is_special: bool

invokespecial (super call / constructor / private).

is_super: bool

super.m(...) form.

is_dynamic: bool

invokedynamic without recognized pattern.

type_args: Vec<String>

Explicit type arguments (Cls.<E>m(...)) restored for generic calls in throw position, where inference would pick the bound.

ArrayIndex

Fields

array: Box<Expr>

index: Box<Expr>

Cast

Fields

ty: TypeRef

e: Box<Expr>

InstanceOf

Fields

e: Box<Expr>

ty: TypeRef

Un

Fields

op: UnOp

e: Box<Expr>

Bin

Fields

op: BinOp

l: Box<Expr>

r: Box<Expr>

ty: Option<TypeRef>

Type context for + disambiguation (string vs numeric).

Cond

Fields

c: Box<Expr>

t: Box<Expr>

f: Box<Expr>

Assign

Fields

target: Box<Expr>

op: AssignOp

value: Box<Expr>

PreIncDec

++x / --x (delta = +1 / -1)

Fields

e: Box<Expr>

delta: i64

wide: bool

PostIncDec

x++ / x--

Fields

e: Box<Expr>

delta: i64

wide: bool

Lambda(Box<LambdaExpr>)

StringConcat(Vec<ConcatPart>)

String concatenation via StringConcatFactory recipe.

Raw(String)

Pre-rendered source fragment (used for captured expressions that are substituted across method contexts).

RawT(String, TypeRef)

Pre-rendered capture text WITH the captured local’s declared type: comparisons inside local-class bodies need the operand’s generic type to drive witnesses (erased val$ field types cannot).

Invokedynamic

Unrecognized invokedynamic fallback.

Fields

name: String

desc: MethodDescriptor

args: Vec<Expr>

bsm_text: String

bsm_static_args: Vec<BsmArg>

Resolved static bootstrap arguments (for SwitchBootstraps typeSwitch restoration).

AnonNew

new Anon(args) { ...class body... } — anonymous class instantiation.

Fields

cls: String

The anonymous class itself.

base: TypeRef

Interface being implemented, or superclass (Object suppressed).

args: Vec<Expr>

body: String

Decompiled class body lines (already indented relative).

Implementations

impl Expr

pub fn type_ref(&self) -> TypeRef

Best-effort static type of this expression.

pub fn needs_parens(&self, outer_prec: u8, is_right: bool) -> bool

True if emitting this expression as a statement component needs parens at the given outer precedence context.

Trait Implementations

impl Clone for Expr

fn clone(&self) -> Expr

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Expr

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

Formats the value using the given formatter.

impl PartialEq for Expr

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

Equality operator ==.

fn ne(&self, other: &Rhs) -> bool

Inequality operator !=.

impl StructuralPartialEq for Expr