Struct DexCtx 

pub struct DexCtx<'a> {
    pub pool: &'a DexPool,
    pub class: &'a PoolClass,
}

Front-end context handed to the core’s structurer and printer.

Fields

pool: &'a DexPool

class: &'a PoolClass

Implementations

impl<'a> DexCtx<'a>

pub fn new(pool: &'a DexPool, class: &'a PoolClass) -> Self

Trait Implementations

impl<'a> Ctx for DexCtx<'a>

fn class_name(&self) -> &str

Internal name of the class currently being emitted (e.g. java/util/ArrayList).

fn source_level(&self) -> u16

Source level gate for version-dependent rendering: the JVM front-end returns the class-file major version; a DEX front-end returns the equivalent language level it decided to target. 52 means “Java 8 features available” (lambdas, diamond, …).

fn find_outer(&self, internal: &str) -> Option<String>

The class that internal is nested in, when the container records the nesting (JVM InnerClasses/NestHost; DEX inner-class annotations). None for a top-level class — including literal-$ names that only look nested.

fn family(&self, root: &str) -> Family

Nested-class family of root, as far as the container records it.

fn nested_is_static(&self, internal: &str) -> bool

True when a nested class is static (Outer$Inner with ACC_STATIC), so it is not constructed with an enclosing instance.

fn class_has_this0(&self, internal: &str) -> bool

True when the class carries a synthetic this$0 field (an inner class with an enclosing instance parameter).

fn is_subtype_of(&self, sub: &JavaType, sup: &str) -> bool

True when sub is assignable to sup (both internal names).

fn is_interface(&self, internal: &str) -> bool

True when internal is an interface.

fn is_sealed(&self, _internal: &str) -> bool

True when internal is sealed (its permitted subclasses are recorded).

fn super_name(&self, internal: &str) -> Option<String>

Superclass of internal (internal name); None at Object/unknown.

fn has_class(&self, internal: &str) -> bool

True when the container holds this class at all (naming probes use it to test Outer$1Local-style candidates).

fn class_supers_args( &self, internal: &str, _args: &[GenericType], ) -> Vec<(String, Vec<GenericType>)>

Superclasses/interfaces of internal with the given type arguments applied: [(java/lang/Object, []), ...], most-derived first.

fn class_bases(&self, internal: &str) -> Option<(Vec<String>, Option<String>)>

Interfaces and superclass of internal (internal names, declaration order). None when the class is unknown to the front-end.

fn field_flags(&self, internal: &str, name: &str) -> Option<FieldAccessFlags>

Access flags of the field internal.name; None when absent.

fn method_flags( &self, internal: &str, name: &str, desc: &str, ) -> Option<MethodAccessFlags>

Access flags of the method internal.name(desc); None when absent.

fn declares_field(&self, internal: &str, name: &str) -> bool

True when internal declares any field named name.

fn declares_method_named(&self, internal: &str, name: &str) -> bool

True when internal declares a method named name (any descriptor).

fn is_generic_call(&self, _e: &Expr) -> bool

True when the call carries inferred type arguments that the source must spell out.

fn generic_call_formals( &self, _e: &Expr, ) -> Option<(Vec<GenericType>, Vec<String>)>

Instantiated formal parameter types of a generic call plus the callee’s own method type variables (for witness casts). None when the call has no inferred type arguments to spell out.

fn polymorphic_ret_cast( &self, _cls: &str, _name: &str, _desc: &MethodDescriptor, ) -> Option<JavaType>

The instantiated return type of a call whose methodref owner redeclares the method with a self-covariant return (Stream over BaseStream).

fn ctor_formals_by_arity( &self, internal: &str, arity: usize, ) -> Option<Vec<GenericType>>

Constructor parameter types of internal matching arity, for rendering new arguments against the right overload.

fn ctor_param_types( &self, internal: &str, skip: usize, n: usize, args: &[Expr], ) -> Option<Vec<JavaType>>

Parameter types of the <init> of internal matching skip + n descriptor args, with skip leading synthetic parameters removed. Used to print new arguments with boolean/char constant adjustment.

fn outer_param_via_super(&self, _internal: &str) -> bool

True when internal is an inner class whose constructor forwards its enclosing instance straight to super (javac 21+ drops this$0 in that case, but call sites still need the qualified-new form).

fn nested_method( &self, _l: &LambdaExpr, _outer_vt: &VarTable, ) -> Option<MethodBody>

Decompile the nested method a lambda site refers to — a lambda body, an anonymous-class method, or a local-class method — and run the front-end’s own idiom recovery on it.

fn local_class_internal(&self, simple: &str) -> Option<String>

Local-class name recorded for a $-style synthetic marker, when the container records one (Outer$1Local -> Local).

fn class_type_params(&self, internal: &str) -> Vec<TypeParam>

Generic type parameters declared by internal (from its class signature); empty when the container records none.

fn generic_call_mt_typevars(&self, e: &Expr) -> Vec<String>

Type variables of the method the call refers to (used to decide whether a formal still carries the callee’s own typevars).

fn sam_ret_cast(&self, g: &GenericType, sam_name: &str) -> Option<TypeRef>

Instantiated SAM return of a functional interface’s method, resolved against a cast’s type arguments ((Function<I,R>) lambda needs (R) value witnesses on the impl body’s returns).

fn class_declares_generics(&self, internal: &str) -> bool

True when internal declares class-level type parameters (so new internal<>(...) should carry a diamond).