All Classes

Class	Description
AALoadInstruction	Represents the AALOAD instruction (0x32).
AAStoreInstruction	Represents the AASTORE instruction (0x53).
AbstractBlockVisitor	Abstract visitor for processing SSA-form IR blocks and instructions.
AbstractBytecodeListener	Base listener that tracks the current method and a running instruction count for subclasses.
AbstractBytecodeVisitor	Base visitor over a method's decoded instructions whose per-instruction visit hooks are all no-ops.
AbstractClassVisitor	Abstract visitor for processing class file elements including methods, fields, constant pool items, and attributes.
AbstractInterceptor	No-op base implementation of InstructionInterceptor whose callbacks all continue execution.
AbstractIRVisitor<T>	Abstract visitor with default implementations returning null.
AbstractListener	No-op base implementation of every simulation listener callback.
AbstractMethodVisitor	Abstract visitor for processing method entries and their code attributes.
AbstractParser	An abstract parser for reading various data types from a byte array.
AbstractSourceVisitor<T>	Base SourceVisitor whose visit methods walk the whole tree and return AbstractSourceVisitor.defaultValue().
AbstractState	The simulated operand stack and local slots at one point of bytecode lifting.
AccessBuilder	Builder class for constructing access flag integers using method chaining.
AccessFlags	Class file constants: access flag bits, newarray primitive type codes, major version numbers and the load, store and return opcodes.
AccessMetrics	Immutable field and array access counts collected during simulation.
AccessMode	Whether an array or field access reads or writes.
Accessor	An immutable, fluent path of Steps that projects a value (or a sub-subject stream) from a subject - e.g.
AConstNullInstruction	Represents the ACONST_NULL instruction (0x01).
AlgebraicSimplification	Algebraic Simplification optimization transform.
AllocationListener	Simulation listener that counts object and array allocations by type, optionally recording each allocation site.
AllocationListener.AllocationSite	One recorded allocation: the instruction, the type key, whether it was an array, and the operand stack depth at the time.
AllocationMetrics	Immutable snapshot of the allocations counted during a simulation.
AllocationSite	The identity of one allocation in the program - class, owning method and instruction index - which bounds points-to analysis to one abstract object per NEW instruction.
AllScope	Search all methods/classes in the project.
ALoadInstruction	Represents the ALOAD instructions (0x19, 0x2A-0x2D).
ANewArrayInstruction	Represents the ANEWARRAY instruction (0xBD).
Annotation	A parsed annotation: its type descriptor index and element-value pairs.
AnnotationBuilder<P>	Fluent builder for a single annotation.
AnnotationDefaultAttribute	The AnnotationDefault attribute: the default value of an annotation element.
AnnotationExpr	A Java annotation use, in marker, single-value, or normal (named-values) form.
AnnotationFilter	Filter based on annotation presence.
AnnotationFilter.Builder	Builder for AnnotationFilter instances.
AnnotationValue	A single element-value pair inside an annotation use.
AppendFrame	Represents an AppendFrame in the StackMapTable attribute.
ArgumentType	Classification of how a call argument value is produced, with DYNAMIC covering any non-literal source.
ArgumentTypeAnalyzer	Static helpers for classifying invoke-instruction arguments by how they are produced.
ArgValueResolver	Resolves an argument of a call to its declared type, kind and (when a constant feeds the operand) literal value.
ArithmeticInstruction	Represents arithmetic instructions.
ArithmeticInstruction.ArithmeticType	The arithmetic operation kinds, each pairing a JVM opcode with its mnemonic.
ArithmeticShiftInstruction	Represents shift instructions (ISHL, LSHL, ISHR, LSHR, IUSHR, LUSHR).
ArithmeticShiftInstruction.ShiftType	The shift operation kinds, each pairing a JVM opcode with its mnemonic.
ArrayAccessExpr	An array access expression: array[index].
ArrayAccessHandler	Handler for array access expressions (array[index]).
ArrayAccessHandler.ArrayAccessType	The type of array access operation.
ArrayAccessInstruction	An array element load or store, distinguished by its AccessMode.
ArrayInitExpr	An array initializer expression: {elem1, elem2, ...}.
ArrayInitializerReconstructor	Folds the verbose array-build idiom javac emits for an array literal back into a literal:
ArrayInstance	A heap-allocated array with typed primitive or reference backing storage.
ArrayLengthInstruction	Represents the ARRAYLENGTH instruction (0xBE).
ArrayLoadHook	Configuration for array load instrumentation.
ArrayLoadHook.Builder	Fluent builder for ArrayLoadHook instances.
ArraySourceType	Represents an array type in the source AST.
ArrayStoreHook	Configuration for array store instrumentation.
ArrayStoreHook.Builder	Fluent builder for ArrayStoreHook instances.
ArrayType	Represents an array type.
AssignmentHandler	Handler for assignment expressions.
ASTEditor	Fluent editor that walks a method body, dispatching registered handlers to rewrite AST nodes.
ASTFactory	Static factory of AST nodes with sensible type defaults.
ASTFactory	Factory for building source AST expressions and statements programmatically.
ASTFactory.MethodCallBuilder	Builder for method call expressions.
ASTFactory.NewExprBuilder	Builder for new object expressions.
ASTLowerer	Facade that lowers a source-level AST method body into SSA IR ready for bytecode emission.
ASTMutations	Deep clone, replace and remove operations over AST nodes.
ASTNode	Base interface for all AST nodes in the source representation.
AStoreInstruction	Represents the ASTORE instruction and its variants (ASTORE, ASTORE_0-3) (0x4B-0x4E).
ASTPrinter	Debug visitor that renders an expression/statement AST as an indented tree, optionally with types.
ASTTransform	Interface for AST-level transformations that improve decompiled output quality.
ASTUtils	Visitor-backed helpers for traversing and querying AST nodes.
ASTValidator	Coordinator that runs structural, type, and null validation strategies over an AST tree.
ASTValidator.ValidationResult	Immutable outcome of a validation run, holding all reported issues.
ATHROWInstruction	Represents the ATHROW instruction (0xBF).
Attribute	Abstract base for class-file attributes, attached to a class or a member.
AttributeRegistry	Maps (SubjectKind, keyword) to a resolver - either a scalar AttributeRegistry.Attribute or a sub-subject AttributeRegistry.Selector.
AttributeRegistry.Attribute	Resolves a scalar value from a subject.
AttributeRegistry.Entry	A registered resolver: exactly one of scalar/stream is non-null.
AttributeRegistry.Selector	Expands a subject into a stream of sub-subjects (honoring the step's index/wildcard).
BALOADInstruction	Represents the BALOAD instruction (0x33).
BAStoreInstruction	Represents the BASTORE instruction (0x54).
BinaryExpr	A binary expression: left op right, including assignments and logical operators.
BinaryExprHandler	Handler for binary expressions (arithmetic, comparison, logical operations).
BinaryOp	Binary operation types.
BinaryOperator	Binary operators for expressions.
BinaryOpInstruction	A binary arithmetic, logical, or comparison operation on two operands.
BipushInstruction	Represents the BIPUSH instruction (0x10).
BitTrackingDCE	Bit-Tracking Dead Code Elimination (BDCE).
BlockMerging	Block merging optimization.
BlockNode	CPG node wrapping a basic block of SSA IR.
BlockStmt	A brace-delimited sequence of statements.
BoolFormula	A reaching-condition boolean formula carried as two representations kept in sync by BoolFormulaFactory.
BoolFormulaFactory	The reaching-condition boolean engine for one method's structuring pass.
BootstrapFamilies	Owner/name predicates for the JDK bootstrap-method families reachable from invokedynamic and constant-dynamic.
BootstrapMethod	Represents a bootstrap method entry in the BootstrapMethods attribute.
BootstrapMethodInfo	Represents bootstrap method information for invokedynamic and constant dynamic.
BootstrapMethodsAttribute	The BootstrapMethods attribute: bootstrap method entries for invokedynamic call sites.
Bootstraps	Single source of truth for resolving invokedynamic/condy bootstraps from a ClassFile's BootstrapMethods attribute.
Bootstraps.BootstrapRef	Immutable resolved view of a single bootstrap method.
BranchInstruction	A conditional branch comparing one or two operands and selecting a true or false target block.
Breakpoint	Breakpoint location keyed by class, method, and pc, with mutable enablement, condition, and hit tracking.
BreakpointManager	Thread-safe registry of breakpoints indexed by key and by owning method for fast location checks.
BreakStmt	A break statement with an optional target label.
Bytecode	High-level bytecode manipulation API.
BytecodeContext	Immutable configuration for a bytecode engine: execution mode, heap, resolution services, and execution limits.
BytecodeContext.Builder	Builder for BytecodeContext; a heap manager and class resolver are required.
BytecodeEmitter	Emits JVM bytecode from IR instructions.
BytecodeEngine	Interpreter that executes JVM bytecode over an explicit call stack, dispatching each instruction and modeling invocation, field, heap, and exception semantics.
BytecodeLifter	Lifts bytecode to SSA-form IR.
BytecodeListener	Callback interface for observing bytecode interpreter events, with no-op defaults for every hook.
BytecodeLowerer	The lowering pipeline from SSA-form IR back to JVM bytecode.
BytecodeResult	Immutable outcome of a bytecode execution: terminal status, return value or exception, and optional statistics.
BytecodeResult	Outcome of a bytecode execution: a return value on success, a thrown exception on failure, or an incomplete run.
BytecodeResult.Status	Terminal condition of an execution.
CallGraph	A queryable call graph over a set of classes.
CallGraphBuilder	Builder that constructs a CallGraph from a ClassPool by scanning all methods for invocations.
CallGraphNode	A call-graph node for a single method, tracking its incoming (caller) and outgoing (callee) call sites.
CallMetrics	An immutable tally of the method calls seen during a simulation.
CallSite	A specific location where one method invokes another, with the invoke type and bytecode offset.
CallSiteNode	CPG node wrapping an invoke instruction, exposing its resolved target signature.
CallStack	A bounded stack of interpreter frames with overflow and underflow checking.
CallStackState	Immutable call stack for inter-procedural simulation.
CallStackState.CallFrame	Represents a single frame on the call stack.
CALoadInstruction	Represents the CALOAD instruction (0x34).
CapableListener	Extended listener interface that declares which high-frequency event capabilities this listener requires.
CastExpr	A cast expression: (Type) expression.
CastHandler	Handler for cast expressions.
CAStoreInstruction	Represents the CASTORE instruction (0x55).
CatchClause	A catch clause of a try statement, supporting multi-catch via multiple exception types.
CheckCastInstruction	Represents the CHECKCAST instruction (0xC0).
ChopFrame	Represents a ChopFrame in the StackMapTable attribute.
ClassBuilder	Fluent builder that assembles a ClassFile from scratch - version, access, hierarchy, fields, methods, annotations, and bootstrap methods.
ClassConstant	Represents a class constant (Class object reference).
ClassDecl	A Java class declaration: name, modifiers, supertypes, and its member fields, methods, constructors, initializers, and inner types.
ClassDecompiler	Decompiler that turns a ClassFile into formatted Java source: the class declaration, fields, and recovered method bodies.
ClassDecompiler.Builder	Builder for ClassDecompiler with a fluent configuration API.
ClassExpr	A class literal expression: Type.class.
ClassFactory	Generator of bytecode-backed members on a structural ClassFile - constructors, initializers, accessors, field initial values, method bodies, and StackMapTable frames.
ClassFile	Represents a Java class file with full parsing and manipulation capabilities.
ClassFileUtil	Utility class for working with Java class files.
ClassFilter	An instrumentation filter that selects classes by exact name or glob pattern.
ClassHierarchy	Queryable inheritance graph of the classes in a ClassPool.
ClassHierarchyBuilder	Builds a ClassHierarchy from a ClassPool.
ClassMapping	Represents a class rename mapping.
ClassNameUtil	Conversions between internal, source, simple and package class names.
ClassNode	A class in the hierarchy graph together with its supertypes and subtypes.
ClassPool	A pool of parsed ClassFile objects, stored and retrieved by internal name.
ClassRefItem	Represents a CONSTANT_Class entry in the constant pool.
ClassRenamer	Applies class renames pool-wide, rewriting class refs, member owners, descriptors, generic signatures, and InnerClasses entries so no reference to an old name survives.
ClassResolver	Resolver of classes, methods, and fields against a class pool and its hierarchy, with memoized lookups.
ClassScope	Scope limited to classes matching a pattern or exact name.
ClassTransform	Interface for class-level transformation passes.
CodeAttribute	The Code attribute: a method's bytecode, stack/local sizes, exception table, and nested attributes.
CodeBuilder	A fluent assembler for a method body that records instructions as sized ops and resolves named labels to branch offsets when the body is built or assembled.
CodePrinter	Bytecode disassembler for converting raw bytecode into human-readable format.
CodePropertyGraph	Unified code property graph over a class pool, combining AST, CFG, dependence, and call edges in one node/edge store with an index and a fluent query entry point.
CodeWriter	A class for analyzing and modifying the bytecode of a MethodEntry.
CodeWriter.ClonedRange	A cloned instruction range.
CollectionHandlers	Native handlers for java.util.Arrays, the collection intrinsics, and java.lang.reflect.Array.
CommonSubexpressionElimination	Common Subexpression Elimination (CSE) optimization transform.
CommonTypes	Internal names, descriptors and method names for the JDK types the toolchain refers to most.
CompareInstruction	Represents the compare instructions (LCMP, FCMPL, FCMPG, DCMPL, DCMPG).
CompareInstruction.CompareType	The compare operation kinds, each pairing a JVM opcode with its mnemonic.
CompareOp	Comparison operations for branches.
ComparisonChainToSwitch	Folds a dispatch written as a nested chain of constant equality guards back into a switch:
CompilationUnit	A Java source file: package declaration, imports, and top-level type declarations.
CompositeBytecodeListener	Listener that fans every event out to an ordered list of delegate listeners.
CompositeListener	Simulation listener that forwards every callback to its children in order, so several listeners can be registered as one.
ConcreteLocals	Fixed-size local variable table of concrete values, with wide values occupying two slots.
ConcreteStack	Fixed-capacity operand stack of concrete values with the JVM dup and swap shuffle operations.
ConcreteValue	An immutable tagged JVM value, storing primitives as raw bits and references as a heap instance.
ConcurrencyHandlers	Native handlers for the java.util.concurrent.atomic intrinsics, reporting compare-and-swap support as available.
Condition	The boolean expression tree of a query's WHERE clause - the only place booleans live.
Condition.And
Condition.Comparison	accessor OP operand - the single generic leaf.
Condition.Count	count(<stream> [where (body)]) OP n - cardinality of a (optionally filtered) stream.
Condition.Group
Condition.Not
Condition.Or
Condition.Quant	Existence/universality of a sub-condition over a sub-subject stream.
Condition.Quantifier	has|any|all|none <stream> where (body).
Condition.Sequence	SEQUENCE [ e1, e2, .. ] - an ordered, unanchored regex over the method's instruction stream.
Condition.Sequence.Element	One pattern element: a matcher evaluated against an instruction, repeated [min,max] times.
Condition.True	Constant truth, used as an identity element when simplifying/splitting trees.
Condition.Visitor<R>
ConditionalBranchInstruction	Represents the conditional branch instructions.
ConditionalBranchInstruction.BranchType	The conditional branch kinds, each pairing a JVM opcode with its mnemonic.
ConditionalConstantPropagation	Conditional Constant Propagation (CCP) optimization transform.
ConditionEvaluator	Interprets a Condition against a Subject.
ConditionParser	Recursive-descent parser for the composable WHERE expression language.
Constant	Base class for all constant values.
ConstantDynamic	Represents a CONSTANT_Dynamic entry structure in the constant pool.
ConstantDynamicInfo	A CONSTANT_Dynamic constant pool entry awaiting bootstrap-method resolution.
ConstantDynamicItem	Represents a CONSTANT_Dynamic entry in the constant pool (tag 17/0x11).
ConstantFolding	Folds constant expressions at compile time.
ConstantInstruction	An instruction producing a constant value.
ConstantValueAttribute	The ConstantValue attribute: the constant-pool index of a field's constant initial value.
ConstPool	Represents the Constant Pool of a Java class file.
ConstPoolRemapper	Symbolically re-resolves constant-pool entries from a source ClassFile's pool into a target ClassFile's pool, returning the target index for any source index.
ConstructorAnalyzer	Analyzes constructor bytecode to extract field assignments.
ConstructorDecl	A Java constructor declaration: modifiers, parameters, throws clause, and body.
ContinueStmt	A continue statement with an optional target label.
ControlFlowContext	Shared context for control flow recovery operations.
ControlFlowContext.FieldKey	Represents a field by its owner class and field name.
ControlFlowContext.JumpKind	Which loop boundary an edge crosses.
ControlFlowContext.LoopFrame	An enclosing loop: its header (label anchor), continue-target (latch/increment) and exit block.
ControlFlowContext.LoopJump	A break/continue jump.
ControlFlowContext.StructuredRegion	Represents a structured control flow region.
ControlFlowContext.SwitchFrame	An enclosing switch.
ControlFlowContext.SwitchJump	A jump within a switch: leaving it at its merge, or falling through to a sibling caseHeader.
ControlFlowContext.SwitchJumpKind	How an edge leaves a switch case - out at the merge, or on to the next case.
ControlFlowListener	A simulation listener that counts control flow instructions, block visits and block-to-block transitions, resetting its tallies at each simulation start.
ControlFlowListener.BlockTransition	Represents a transition between two blocks.
ControlFlowReducibility	Transforms irreducible control flow into reducible form using node splitting.
ControlFlowSimplifier	Simplifies control flow in AST to reduce nesting depth and improve readability.
ControlFlowVerifier	Verification pass over a method's control-flow graph: reachability and path termination.
ConversionInstruction	Represents the type conversion instructions (I2F, I2D, L2I, L2F, L2D, F2I, F2L, F2D, D2I, D2L, D2F).
ConversionInstruction.ConversionType	The widening conversion kinds, each pairing a JVM opcode with its mnemonic.
CopyInfo	A phi copy's created SSA value and the block it was inserted in, used for register coalescing.
CopyInstruction	A value copy, inserted mainly during phi elimination.
CopyPropagation	Propagates copies to eliminate redundant copy instructions.
CoreHandlers	Native handlers for the java.lang core: Object identity and equality, Throwable construction and stack traces, and Class reflection stubs.
CorrelatedValuePropagation	Correlated Value Propagation (CVP).
CPGBuilder	Builder that lifts every method in a class pool to SSA IR and assembles a CodePropertyGraph with optional call-graph, PDG, and SDG edge layers.
CPGDOTExporter	Renders a code property graph as Graphviz DOT, with a filter selecting which edge types appear.
CPGEdge	Directed, typed edge between two CPG nodes; identity is (source id, target id, type).
CPGEdgeType	Kinds of edges a CPG can contain, spanning AST, CFG, data-flow, dependence, call, interprocedural, and taint layers.
CPGIndex	Secondary lookup structure over CPG nodes, keyed by node type, method signature, call target, instruction class, and property key/value pairs.
CPGNode	Base class for CPG nodes: an id, a node type, a property map, and the incident edges; identity is the id alone.
CPGNodeType	Kinds of nodes a CPG can contain, spanning IR, AST, PDG, and SDG layers.
CPGPrinter	A text renderer for a code property graph, emitting nodes grouped by method or by node type with detail controlled by a GraphPrinterConfig.
CPGQuery	Fluent, stream-backed traversal over a CPG.
DALoadInstruction	Represents the DALOAD instruction (0x31).
DAStoreInstruction	Represents the DASTORE instruction (0x52).
DataFlowEdge	An edge in the data flow graph connecting two nodes.
DataFlowEdgeType	Types of edges in a data flow graph.
DataFlowGraph	A data flow graph for a single method.
DataFlowNode	A node in the data flow graph standing for a value or operation, with mutable taint state.
DataFlowNode.Builder	Mutable accumulator for the immutable fields of a DataFlowNode.
DataFlowNodeType	Types of nodes in a data flow graph.
DConstInstruction	Represents the JVM DCONST_0 and DCONST_1 instructions.
DeadCodeElimination	Removes dead code (definitions with no uses).
DeadMethodElimination	Dead method elimination optimization.
DeadStoreEliminator	Eliminates dead stores where a variable's initial value is never read.
DeadVariableEliminator	Removes unused variable declarations from the AST.
DebugEventListener	Observer of debug session lifecycle, breakpoint, step, and exception events; every callback defaults to a no-op.
DebugSession	Interactive stepping debugger over a BytecodeEngine, driving breakpoints, step modes, and state snapshots for listeners.
DebugSessionState	Lifecycle state of a debug session: not yet started, executing, suspended at a breakpoint, or finished.
DebugState	Immutable snapshot of an interpreter's position, call stack and frame contents at one moment.
DebugState.Builder	Mutable accumulator for the fields of a DebugState.
DebugState.Status	Lifecycle state of the interpreted run.
DeclarationHoister	Moves variable declarations closer to their first use.
DecompilerConfig	Configuration for the ClassDecompiler: source emission settings, the additional transform pipeline, and the name recovery strategy.
DecompilerConfig.Builder	Builder for DecompilerConfig.
DecompileResult	Decompiled source plus per-method bytecode-offset provenance.
DecompileResult.MemberSpan	The 1-based first/last line of a member's full text in the decompiled source - annotations and signature through the closing brace.
DecompileResult.MethodSpan	A DecompileResult.MemberSpan for a method or constructor.
DefaultAttributes	Registers the static (bytecode-level) query vocabulary.
DefUseChains	Def-use chains mapping each SSA value to its defining instruction and its uses.
DelegatingHandler	Invocation handler that routes every call through a user-supplied callback, converting thrown Java exceptions into guest heap exceptions.
DelegatingHandler.InvocationCallback	Callback that performs a delegated method invocation and returns its concrete result.
Dependency	A directed dependency edge from one class to another, tagged with its kind.
DependencyAnalyzer	Analyzes class dependencies by scanning constant pools.
DependencyNode	A dependency-graph node for a single class, tracking its incoming and outgoing dependency edges.
DependencyType	Types of dependencies between classes.
DeprecatedAttribute	The Deprecated attribute: a zero-length marker that the element is deprecated.
DescriptorParser	Static helpers for reading and building JVM field and method descriptors.
DescriptorParser.ParseResult	One parsed type together with the number of descriptor characters it spans.
DescriptorRemapper	Remaps class references within method and field descriptors.
DescriptorUtil	Utility class for JVM descriptor parsing and manipulation.
DescriptorUtil.DescriptorCategory	Descriptor categories for JVM types.
DisassemblyOptions	Immutable flag set selecting which enrichments CodePrinter adds to a method disassembly, built from DisassemblyOptions.terse() or DisassemblyOptions.verbose() and refined with the with* copies.
DispatchContext	Runtime services the opcode dispatcher relies on: constant resolution, heap checks, and pending-operation handoff to the interpreter.
DispatchResult	Outcome of dispatching a single instruction, directing the interpreter's next action.
DLoadInstruction	Represents the JVM DLOAD instruction.
DNegInstruction	Represents the JVM DNEG instruction.
DominatorTree	Dominator tree and dominance frontiers for a method's CFG.
DOTExporter<T>	Base for graph-to-DOT exporters, supplying the shared node, edge, cluster and label-escaping emitters driven by a DOTExporterConfig.
DOTExporterConfig	Immutable rendering settings for a DOTExporter - layout, fonts, label truncation and the default node and edge styles.
DOTExporterConfig.Builder	Mutable accumulator for the exporter settings.
DOTExporterConfig.EdgeStyle	Colour, line style and arrow head applied to a DOT edge.
DOTExporterConfig.EdgeStyle.Builder	Mutable accumulator for an edge style.
DOTExporterConfig.NodeStyle	Shape and colour attributes applied to a DOT node.
DOTExporterConfig.NodeStyle.Builder	Mutable accumulator for a node style.
DoubleConstant	Represents a double constant.
DoubleItem	A CONSTANT_Double entry in the constant pool.
DoWhileStmt	A do-while loop with an optional label; the body executes before the condition is tested.
DStoreInstruction	Represents the JVM DSTORE instruction.
DupInstruction	Represents the JVM DUP instruction and its variants.
DupInstruction.DupType	The stack-duplication variants (DUP through DUP2_X2), each pairing a JVM opcode with its mnemonic.
DuplicateBlockMerging	Merges duplicate blocks created by node splitting while preserving reducibility.
DuringScope	Scope limited to events during execution of specific methods.
DynamicConstant	Represents a dynamic constant loaded via ldc (condy).
DynamicConstantExpr	A dynamic constant (condy, Java 11+) whose bootstrap method was not a recognized pattern, preserving the bootstrap information for display.
EdgeType	Types of edges in the control flow graph.
EditorContext	Traversal context handed to AST editor handlers.
ElementValue	An annotation element value: a tag character and its tag-dependent payload.
ElementValuePair	An annotation element-value pair: the element name and its value.
EnclosingMethodAttribute	The EnclosingMethod attribute: the class and method enclosing a local or anonymous class.
EnumConst	An enum constant used as an annotation value: its type and constant name indices.
EnumConstantDecl	A single enum constant, with optional constructor arguments and an optional class body of fields and methods.
EnumConstants	Resolves an enum's constants by ordinal and by name.
EnumDecl	A Java enum declaration: constants plus ordinary members (fields, methods, constructors, inner types).
EnumSwitchMapRegistry	Process-wide store of recovered javac $SwitchMap$ tables, keyed by holder class and enum so two classes switching on the same enum keep separate numberings.
ErrorCollector	Sink for verification errors and warnings, with fail-fast and collect-all (capped) implementations.
ErrorCollector.CollectAllCollector
ErrorCollector.FailFastCollector
EscapeAnalyzer	Escape classifier for simulation heap allocation sites, driven by the heap's escape marks and reachability from them.
EscapeAnalyzer.EscapeState	How far an allocation escapes its allocating method.
EvalContext	Per-subject evaluation scope with lazy, cached views of a method so repeated accessors (every arg(n), instructions, line) share one decode/analysis.
EvidenceCollector	Accumulates the bytecode locations that satisfied a query, so results stay navigable.
EvidenceCollector.Hit	A single matched location.
ExceptionHandler	One exception-table entry: a protected try region and the block handling its catch type.
ExceptionHook	Configuration for exception interception.
ExceptionHook.Builder	Fluent builder for ExceptionHook instances.
ExceptionsAttribute	The Exceptions attribute: constant-pool indices of a method's declared thrown exceptions.
ExceptionTableEntry	Represents an entry in the exception table of a Code attribute.
ExceptionTableVerifier	Verification pass over a method's exception table: range validity, handler targets, and overlaps.
Execution	A path-exploring abstract interpreter over one method's bytecode that builds operand-stack/local def-use (InsnContext/StackCtx/VarCtx) without an abstract value domain.
ExecutionException	Runtime failure during bytecode execution, carrying the frame, pc, and opcode where it occurred.
ExecutionMode	Strategy for handling method invocations: RECURSIVE executes callees in-engine, DELEGATED stubs them with default values.
Exports	Represents an exports entry in the Module attribute.
Expression	Sealed interface representing all expression types in the source AST.
ExpressionEditor	Expression-only view over ASTEditor.
ExpressionEditor.FieldAccessReplacer	Functional interface for field access replacement.
ExpressionEditor.MethodCallReplacer	Functional interface for method call replacement.
ExpressionEditor.NewExprReplacer	Functional interface for new expression replacement.
ExpressionHandler	Base interface for handling expressions during AST editing.
ExpressionLowerer	Lowers AST Expression nodes to IR instructions.
ExpressionRecoverer	Converts SSA IR instructions to source Expression trees.
ExprMatcher	Composable predicate over expressions, used to select edit targets in the AST.
ExprStmt	An expression used as a statement, such as a call, assignment, or increment.
FALoadInstruction	Represents the JVM FALOAD instruction.
FAStoreInstruction	Represents the JVM FASTORE instruction (0x51).
FConstInstruction	Represents the JVM FCONST_0, FCONST_1, and FCONST_2 instructions.
FeatureVector	A hashable feature set extracted from a method at one fingerprint level.
FieldAccessExpr	A field access expression: obj.field or Type.staticField.
FieldAccessHandler	Handler for field access expressions.
FieldAccessInstruction	A static or instance field load or store, distinguished by its AccessMode.
FieldAccessListener	Simulation listener that counts field and array reads and writes, both in total and per field.
FieldAccessListener.AccessStats	Read and write counts for one field.
FieldAccessListener.FieldReference	Represents a field reference.
FieldBuilder	Fluent builder for a single field of a class under construction, returning to its ClassBuilder from FieldBuilder.end().
FieldDecl	A Java field declaration: name, type, modifiers, annotations, and optional initializer.
FieldEntry	A field entry of a class file, parsed from bytes or built for dynamic creation.
FieldFilter	Filter by field name and/or type pattern.
FieldInfo	A resolved field reference: owner class, name, descriptor, and static flag.
FieldKey	Identifies a specific field for field-sensitive tracking.
FieldMapping	Represents a field rename mapping.
FieldReadHook	Configuration for field read instrumentation.
FieldReadHook.Builder	Fluent builder for FieldReadHook instances.
FieldRef	The index pair of a CONSTANT_Fieldref entry - owning class and name-and-type.
FieldReference	Identifies a specific field by owner class, name, and descriptor.
FieldRefItem	A CONSTANT_Fieldref constant pool entry.
FieldRenamer	Applies field mappings across the class pool, rewriting declarations, access sites, field method handles and bootstrap method arguments.
FieldWriteHook	Configuration for field write instrumentation.
FieldWriteHook.Builder	Builder for FieldWriteHook, defaulting to enabled, priority 100, no values passed, and both static and instance writes instrumented.
FileIOHandlers	Native handlers for the java.io file classes, standing in for real file descriptors with inert stubs that report empty or failed I/O.
FindQuery	FIND query - returns matching entities with evidence.
FingerprintBuilder	Extractor that computes a MethodFingerprint from a method's descriptor and raw bytecode.
FingerprintComparator	Scorer that compares two method fingerprints into a weighted similarity score with a confidence estimate.
FingerprintDatabase	In-memory store of method fingerprints with per-level hash indexes for exact and similarity lookups.
FingerprintLevel	The three fingerprint granularity levels, each with a fixed index and scoring weight.
FingerprintMatch	The result of comparing two method fingerprints: an overall score, a confidence, and per-level scores.
FLoadInstruction	Represents the JVM FLOAD instruction.
FloatConstant	Represents a float constant.
FloatItem	Represents a CONSTANT_Float entry in the constant pool.
FNegInstruction	Represents the JVM FNEG instruction.
ForEachStmt	An enhanced for loop over an iterable or array, with an optional label.
ForLoopCounterFolder	Folds a loop counter's hoisted declaration back into the for-init:
ForStmt	A basic for loop with init statements, an optional condition, and update expressions.
Frame	One abstract execution path through a method.
FrameComparator	Slot-by-slot comparison of declared StackMapTable frames against dataflow-computed frames.
FrameComparator.FrameMismatch	One difference between a declared and a computed frame slot; critical mismatches are stack-side.
FrameComparator.FrameMismatch.Location	Which frame area the mismatch is in.
FrameGenerator	Generates StackMapTable frames for a method.
FStoreInstruction	Represents the JVM FSTORE instruction.
FullFrame	Represents a FullFrame in the StackMapTable attribute.
GenericAttribute	A fallback attribute for unrecognized attribute names, holding the raw info bytes.
GenericSourceType	A parameterized reference type such as List<String>; the type arguments are source-only and erase away in toIRType.
GetFieldInstruction	Represents the JVM GETFIELD and GETSTATIC instructions.
GetFieldInstruction.FieldType	The field-read kinds (instance GETFIELD vs static GETSTATIC), each pairing a JVM opcode with its mnemonic.
GotoInstruction	Represents the JVM GOTO and GOTO_W instructions.
GotoInstruction.GotoType	The goto widths (16-bit GOTO vs 32-bit GOTO_W), each pairing a JVM opcode with its mnemonic.
GraphPrinterConfig	Immutable rendering settings shared by the dependence-graph printers, built through GraphPrinterConfig.Builder or one of the named presets.
GraphPrinterConfig.Builder	Mutable accumulator for the printer settings, seeded with the normal defaults.
HeapException	Runtime failure raised by the simulated heap, such as bad bounds or storage type mismatches.
HeapManager	Allocation, string interning, and static-field services for the simulated heap.
HeapMode	Configuration for heap behavior during simulation.
Hook	Base interface for all hook configurations.
HookDescriptor	Describes a hook method to be called at instrumentation points.
HookDescriptor.Builder	Builder for HookDescriptor instances.
HookDescriptor.HookParameter	Types of parameters that can be passed to hooks.
I2LInstruction	Represents the JVM I2L instruction.
IALoadInstruction	Represents the JVM IALOAD instruction.
IAndInstruction	Represents the JVM IAND instruction.
IAStoreInstruction	Represents the JVM IASTORE instruction.
IConstInstruction	Represents the JVM ICONST_M1, ICONST_0, ICONST_1, ICONST_2, ICONST_3, ICONST_4, and ICONST_5 instructions.
IdentifierMode	Modes for handling non-standard identifiers during source emission.
IdentifierNormalizer	Rewriter of identifiers per the configured mode: raw, unicode-escaped, or semantically renamed.
IdentifierNormalizer.IdentifierType	Identifier kinds, each with its own semantic-rename prefix and counter.
IfHandler	Handler for if statements.
IfStmt	An if statement with an optional else branch.
IIncInstruction	Represents the JVM IINC instruction.
ILoadInstruction	Represents the JVM ILOAD instruction.
ImportDecl	A single import declaration, either plain or static and either single-type or on-demand.
IncorrectFormatException	Exception thrown when bytecode or class file format is incorrect or malformed.
IndentingWriter	A writer that inserts the configured indent unit at the start of each line.
INegInstruction	Represents the JVM INEG instruction.
InnerClassEntry	Represents an entry in the InnerClasses attribute.
InnerClassesAttribute	The InnerClasses attribute: entries describing nested-class relationships.
InsnContext	Records one execution of one Instruction by the abstract Execution - its operand-stack pops and pushes (with def-use links back to the InsnContext that produced each value) and its local reads.
InstanceOfExpr	An instanceof expression: expression instanceof Type, with an optional Java 16+ pattern variable.
InstanceOfHandler	Handler for instanceof expressions.
InstanceOfInstruction	Represents the INSTANCEOF instruction (0xC1).
Instruction	Represents a single bytecode instruction.
InstructionFactory	Decodes raw bytecode into Instruction objects.
InstructionInterceptor	Debugger hook invoked around each interpreted instruction, method entry and exit, and thrown exception.
InstructionLength	Encoded length of a single instruction in a raw bytecode array, for scanners that walk code without parsing it into instruction objects.
InstructionNode	CPG node wrapping a single IR instruction, positioned by block id and index.
InstructionTranslator	Translator from JVM bytecode instructions to IR instructions during lifting.
InstrumentationConfig	Configuration holder for instrumentation settings.
InstrumentationConfig.Builder	Builder for InstrumentationConfig instances.
InstrumentationFactory	Factory for creating instrumentation IR instructions.
InstrumentationFilter	Base interface for instrumentation filters.
InstrumentationTarget	Enumeration of instrumentation target types.
InstrumentationTransform	Transform that applies instrumentation hooks to IR methods.
Instrumenter	Fluent entry point for registering instrumentation hooks and applying them to a set of classes.
Instrumenter.ArrayLoadHookBuilder	Fluent builder for an array load hook.
Instrumenter.ArrayStoreHookBuilder	Fluent builder for an array store hook.
Instrumenter.ExceptionHookBuilder	Fluent builder for an exception handler hook.
Instrumenter.FieldReadHookBuilder	Fluent builder for a field read hook.
Instrumenter.FieldWriteHookBuilder	Fluent builder for a field write hook.
Instrumenter.InstrumentationReport	Immutable counts from one instrumentation run.
Instrumenter.InstrumentationReport.Builder	Mutable accumulator for the report counters.
Instrumenter.MethodCallHookBuilder	Fluent builder for a method call hook.
Instrumenter.MethodEntryHookBuilder	Fluent builder for a method entry hook.
Instrumenter.MethodExitHookBuilder	Fluent builder for a method exit hook.
IntConstant	Represents an integer constant (covers boolean, byte, char, short, int).
IntegerItem	A CONSTANT_Integer constant pool entry.
InterceptorAction	What an interceptor tells the interpreter to do after a callback: keep going, pause, or abort.
InterfaceDecl	An interface declaration in the source AST, with its extended interfaces, type parameters, members, and nested types.
InterfaceRef	Represents an Interface Method Reference in the constant pool.
InterfaceRefItem	Represents a CONSTANT_InterfaceMethodref entry in the constant pool.
InterProceduralEngine	Simulation engine that follows method calls up to a configurable depth, resolving callees from the ClassPool and lifting their bodies to IR on demand.
IntersectionSourceType	An intersection type such as "A & B", as written in a type parameter bound; it lowers to its first bound.
InvalidNameException	Exception thrown when a name is not a valid Java identifier.
InvocationContext	Interpreter services available to an invocation handler: the call stack, heap, and class resolver.
InvocationHandler	Strategy for executing a resolved method call, producing a result that tells the interpreter how to proceed.
InvocationResult	Outcome of a method invocation attempt, pairing a status with the value, exception, or frame it produced.
InvocationResult.Status	Outcome category of an invocation attempt.
InvokeDynamic	The index pair carried by a CONSTANT_InvokeDynamic pool entry.
InvokeDynamicExpr	An invokedynamic call whose bootstrap method was not a recognized pattern, preserving the bootstrap information and call arguments for display.
InvokeDynamicInfo	An invokedynamic call site: bootstrap method index plus the invoked name and descriptor.
InvokeDynamicInstruction	Represents the INVOKEDYNAMIC instruction (0xBA).
InvokeDynamicItem	Represents a CONSTANT_InvokeDynamic entry in the constant pool.
InvokeInsn	Common supertype for the four owner-bearing invoke instructions - InvokeVirtualInstruction, InvokeSpecialInstruction, InvokeStaticInstruction, and InvokeInterfaceInstruction.
InvokeInstruction	A method invocation of any dispatch kind, including invokedynamic with bootstrap info.
InvokeInterfaceInstruction	Represents the INVOKEINTERFACE instruction (0xB9).
InvokeParameterUtil	Utility for parsing method descriptors in invoke operations.
InvokeSpecialInstruction	Represents the INVOKESPECIAL instruction (0xB7).
InvokeStaticInstruction	Represents the INVOKESTATIC instruction (0xB8).
InvokeType	Types of method invocation.
InvokeVirtualInstruction	Represents the INVOKEVIRTUAL instruction (0xB6).
IOHandlers	Native handlers for print and output stream APIs, which discard all output and return the receiver or a zero result.
IOrInstruction	Represents the IOR instruction (0x80).
IRBlock	A basic block in the SSA CFG, holding phi instructions ahead of its regular instructions.
IRInstruction	Base class for all IR instructions, carrying an id, owning block, optional result, and bytecode offset.
IRMethod	A method in SSA form: its CFG blocks plus parameters, exception handlers, and lowering metadata.
IRMethod.SourceLocal	A source-declared variable (the receiver, a parameter, or a body local) and the SSA value(s) it lowered to.
IRMethodCloner	Utility class for deep-cloning IR methods.
IRPrinter	Utility class for formatting SSA IR instructions and blocks as human-readable strings.
IRRegionStmt	A fallback statement preserving raw IR blocks of an irreducible region, emitted as labeled blocks with breaks.
IRTransform	Interface for IR transformation passes.
IRType	Base interface for all IR types in the SSA representation.
IRVisitor<T>	Visitor interface for IR instructions.
IStoreInstruction	Represents the ISTORE instructions (0x36, 0x3B-0x3E).
Item<T>	Abstract representation of a constant pool item.
IXorInstruction	Represents the IXOR instruction (0x82).
JavaParser	Entry point for parsing Java source into the source AST, holding the error listener that decides whether parse errors throw or are collected.
JsrInstruction	Represents the JSR (0xA8) and JSR_W (0xC9) instructions.
JumpThreading	Jump threading optimization.
LabeledStmt	A statement prefixed with a label, the target of labeled breaks and continues.
LALoadInstruction	Represents the LALOAD instruction (0x2F).
LambdaExpr	A lambda expression: (params) -> body, whose body is either an Expression or a Statement block.
LambdaParameter	A lambda parameter with a name, a type, and whether the type is implicit in source.
LambdaProxyFactory	Factory for heap proxy objects that stand in for invokedynamic lambda instances, storing captured arguments as capture$N fields.
LandInstruction	Represents the LAND instruction (0x7F).
LAStoreInstruction	Represents the LASTORE instruction (0x50).
LConstInstruction	Represents the LCONST_* instructions (0x09 and 0x0A).
Ldc2WInstruction	Represents the LDC2_W instruction (0x14).
LdcInstruction	Represents the LDC instruction (0x12).
LdcInstruction.ConstantType	The kinds of constant-pool entry an ldc-family instruction can load.
LdcWInstruction	Represents the LDC_W instruction (0x13).
Level0Features	Ultra-stable fingerprint features: normalized signature shape plus called, accessed, and instantiated targets.
Level1Features	Stable fingerprint features: loop and block-count shape plus branch, arithmetic, and invoke histograms.
Level2Features	Detailed fingerprint features: opcode-category bigrams, CFG edge and terminator histograms, and dominance depth.
Lexer	Hand-written Java tokenizer with unbounded lookahead, backed by a buffer of already-scanned tokens.
LineNumberTableAttribute	The LineNumberTable attribute: a mapping from bytecode offsets to source line numbers.
LineNumberTableEntry	Represents an entry in the LineNumberTable attribute.
ListenerCapability	Capabilities that listeners can request for performance-gated event notifications.
LiteralExpr	A literal value: integers, floats, strings, booleans, chars, or null.
LivenessAnalysis	Per-block live-in and live-out sets for SSA values.
LLoadInstruction	Represents the LLOAD instruction (0x16).
LlvmLifter	Entry point for lifting textual LLVM IR back to YABR SSA IR, inverting LlvmLowering.
LlvmLiftException	Failure to parse LLVM IR or lift it to SSA form.
LlvmLowering	Entry point lowering YABR SSA IR to textual LLVM IR.
LlvmLoweringConfig	Configuration for LlvmLowering, following the project's builder-plus-presets convention.
LlvmLoweringConfig.Builder	Mutable builder for LlvmLoweringConfig.
LlvmLoweringConfig.ObjectModel	How Java's object/reference/runtime model is lowered.
LNegInstruction	Represents the LNEG instruction (0x75).
LoadLocalInstruction	A load from a local variable slot, used during lifting before SSA conversion.
LocaleHandlers	Native handlers for the host environment natives - time zone, locale provider, DNS, proxy selection and Win32 error mode.
LocalsSnapshot	An immutable slot-to-value view of a frame's locals, taken at one point in execution.
LocalState	Immutable representation of local variable slots during simulation.
LocalVariableTableAttribute	The LocalVariableTable attribute: name, type, slot, and live range of each local variable.
LocalVariableTableBuilder	A builder for a LocalVariableTable over the source-local model recorded during AST lowering (IRMethod.SourceLocal), taking slots from RegisterAllocator and scoping each entry to the blocks holding that local's defs and uses.
LocalVariableTableEntry	Represents an entry in the LocalVariableTable attribute.
LocalVariableTypeTableAttribute	The LocalVariableTypeTable attribute: generic signatures of local variables.
LocalVariableTypeTableEntry	Represents an entry in the LocalVariableTypeTable attribute.
LocalVarInstruction	Implemented by instructions that reference a local-variable slot: the load/store family, iinc, ret, and the wide forms.
Locations	Helpers for carrying SourceLocation provenance across statement rewrites.
Logger	Console logger for informational and error messages, silent unless logging is switched on.
LongConstant	Represents a long constant.
LongItem	Represents a CONSTANT_Long entry in the constant pool.
LookupSwitchInstruction	Represents the LOOKUPSWITCH instruction (0xAB).
LoopAnalysis	Natural-loop detection with per-header back-edge merging and nesting depths.
LoopAnalysis.Loop	A natural loop: a header block plus the blocks of its body.
LoopHandler	Handler for loop statements (for, while, do-while, for-each).
LoopInvariantCodeMotion	Loop-Invariant Code Motion (LICM) optimization transform.
LoopPredication	Loop Predication optimization transform.
LorInstruction	Represents the LOR instruction (0x81).
LoweringContext	Shared mutable state for AST-to-IR lowering: variable bindings, the current block, and break/continue targets.
LoweringContext.LoopTargets	Loop target information for break/continue.
LoweringException	Unchecked exception raised when AST lowering cannot proceed.
LStoreInstruction	Represents the LSTORE instructions (0x37, 0x3F-0x42).
LvtSupport	Shared primitives for emitting LocalVariableTable entries, used by both LVT builders.
LXorInstruction	Represents the LXOR instruction (0x83).
MappingStore	Container for all rename mappings with efficient lookup capabilities.
MathHandlers	Native handlers for java.lang.Math, StrictMath, Float and Double, evaluated with the host JDK's own implementations.
MemberEntry	Abstract base for field and method entries, holding the shared name/descriptor/access state.
MethodBuilder	Fluent builder for one method of a ClassBuilder, holding its code, thrown types, frame sizes, and annotations until the enclosing class is built.
MethodCallExpr	A method call expression: obj.method(args) or Type.staticMethod(args).
MethodCallHandler	Handler for method call expressions.
MethodCallHook	Configuration for method call interception.
MethodCallHook.Builder	Builder for MethodCallHook, defaulting to enabled, priority 100, before-call placement, an unrestricted target and no values passed.
MethodCallListener	Simulation listener that counts method calls by invoke kind and by target, optionally recording the call sequence.
MethodCallListener.CallSite	One recorded call: the invoke, its resolved target, kind and the operand stack depth at entry.
MethodCallListener.MethodReference	An owner, name and descriptor triple used as the call count map key.
MethodDecl	AST node for a method declaration - modifiers, signature and optional body.
MethodEntry	A method entry of a class file, parsed from bytes or built for dynamic creation.
MethodEntryHook	Configuration for method entry instrumentation.
MethodEntryHook.Builder	Fluent builder for a method entry hook; every setting has a default except the hook descriptor.
MethodExitHook	Configuration for method exit instrumentation.
MethodExitHook.Builder	Builder for MethodExitHook, defaulting to enabled, priority 100, no values passed and normal returns only.
MethodFilter	Filter by method name pattern.
MethodFingerprint	A method's identity fingerprint: three feature levels with precomputed hashes and an availability mask.
MethodGrafter	Copies a method from one ClassFile into another, re-resolving its constant-pool references into the target pool.
MethodHandle	The reference kind and pool index pair that makes up a CONSTANT_MethodHandle entry.
MethodHandle	A CONSTANT_MethodHandle target: a reference kind tag plus the member it points at.
MethodHandleConstant	Represents a MethodHandle constant loaded via ldc.
MethodHandleInfo	A CONSTANT_MethodHandle entry: reference kind plus the referenced member's owner, name, and descriptor.
MethodHandleItem	Represents a CONSTANT_MethodHandle entry in the constant pool.
MethodInfo	A resolved method reference: owner class, name, descriptor, and invocation kind flags.
MethodInlining	A class-level transform that replaces calls to private, final, and static methods with the callee's body.
MethodLocals	The parameter slot layout of a method: which local slots hold the receiver and parameters, and how those map to parameter indices.
MethodMapping	Represents a method rename mapping.
MethodNode	CPG node wrapping a lifted IR method together with its owner class.
MethodParameter	Represents a method parameter in the MethodParameters attribute.
MethodParametersAttribute	The MethodParameters attribute: names and flags of a method's formal parameters.
MethodRecoverer	Facade that recovers a source-level method body from an IR method, wiring together name, expression, structural, and statement recovery.
MethodRef	The mutable class-index and name-and-type-index pair behind a constant pool method reference.
MethodReference	An immutable method identity of owner class, name, and descriptor.
MethodRefExpr	A method reference expression - Type::method, expr::method or Type::new.
MethodRefItem	A CONSTANT_Methodref constant pool entry, holding the class and name-and-type indices of a class method.
MethodRefKind	Kinds of method references.
MethodRenamer	Handles renaming of methods and updating all references across the ClassPool.
MethodReturnInstruction	Represents the return instructions (IRETURN, LRETURN, FRETURN, DRETURN, ARETURN, RETURN).
MethodScope	Scope limited to methods matching a pattern or signature.
MethodSignature	A method's comparison fingerprints: bytecode hash, opcode sequence, and structural counters.
MethodSimilarityAnalyzer	Pairwise method-similarity analyzer over a ClassPool, used to find duplicates and renamed copies.
MethodTypeConstant	Represents a MethodType constant loaded via ldc.
MethodTypeInfo	A CONSTANT_MethodType entry wrapping a method descriptor with parsing helpers.
MethodTypeItem	Represents a CONSTANT_MethodType entry in the constant pool.
Modifier	A Java source modifier keyword, paired with the keyword text it prints as.
Modifiers	Utility class for constructing and checking access flags in Java class files.
ModuleAttribute	The Module attribute: a module declaration's requires/exports/opens/uses/provides tables.
ModuleItem	Represents a CONSTANT_Module entry in the constant pool.
MonitorEnterInstruction	Represents the MONITORENTER instruction (0xC2).
MonitorExitInstruction	Represents the MONITOREXIT instruction (0xC3).
MultiANewArrayInstruction	Represents the MULTIANEWARRAY instruction (0xC5).
NameAndType	Represents a Name and Type in the constant pool.
NameAndTypeRefItem	A CONSTANT_NameAndType constant pool entry, holding the name and descriptor indices of a member.
NameConflictException	Signals that a rename was rejected because the new name already belongs to something else at the target location.
NameRecoverer	Recovers variable names from debug info or generates synthetic names.
NameRecoveryStrategy	Strategy for recovering variable names.
NarrowingConversionInstruction	Represents the narrowing conversion instructions (I2B, I2C, I2S).
NarrowingConversionInstruction.NarrowingType	The narrowing conversion kinds, each pairing a JVM opcode with its mnemonic.
NativeContext	Services exposed to native-method handlers: heap access, class resolution, and guest string and exception construction.
NativeException	Exception raised by a native-method handler, carrying the internal name of the guest exception class to materialize.
NativeHandlerProvider	Contributor that registers a family of native-method handlers with a registry.
NativeMethodHandler	Handler that emulates a single native or intrinsic JDK method against interpreter state.
NativeRegistry	Thread-safe registry mapping owner.name+descriptor keys to native-method handlers.
NestHostAttribute	The NestHost attribute: the constant-pool index of the nest host class.
NestMembersAttribute	The NestMembers attribute: constant-pool indices of the classes in this class's nest.
NetworkHandlers	Native handlers for the java.net stack that stub out real I/O, resolving every host to localhost and failing every socket operation without touching the network.
NewArrayExpr	An array allocation - either sized by dimension expressions or by an initializer.
NewArrayHandler	Handler for array instantiation expressions.
NewArrayInstruction	An array allocation covering newarray, anewarray, and multianewarray.
NewExpr	A constructor call expression - new Type(args), or outer.new Inner(args) when an enclosing instance is present.
NewExprHandler	Handler for object instantiation expressions (new).
NewInstruction	An uninitialized object allocation (the new opcode, before the constructor call).
NewObjectInstruction	Represents the NEW instruction (0xBB).
NewPrimitiveArrayInstruction	Represents the NEWARRAY instruction (0xBC).
NewPrimitiveArrayInstruction.ArrayType	The primitive element types NEWARRAY can allocate, each pairing an atype code with a description.
NIOHandlers	Native handlers for the java.nio channel, buffer, and selector natives, mostly stubbed to no-ops.
NodeList<T extends ASTNode>	List of AST nodes that keeps parent links consistent: adding sets each element's parent to the owner, removing clears it.
NopInstruction	Represents the NOP instruction (0x00).
Nullability	Lattice of nullability states for a value, from BOTTOM (unreachable) up to UNKNOWN.
NullCheckElimination	Null Check Elimination optimization transform.
NullConstant	Represents the null constant.
ObjectInstance	A simulated heap object identified by id, holding fields keyed by owner, name, and descriptor.
Opcode	Enum representing all JVM opcodes as per Java 11 Specification.
OpcodeDispatcher	Interpreter core that executes one bytecode instruction per call against a frame, deferring invokes, field access, and allocation to the dispatch context.
OpcodeDispatcher.DispatchResult	Outcome of a dispatch step, directing the interpreter's next action.
Opens	One opens directive of a Module attribute.
Operand	The right-hand side of a Condition.Comparison.
Operand.Literal
Operand.Ref
OperandValidator	Verifier pass that checks each instruction's constant pool operand points at an entry of the kind the opcode requires.
Operator	The comparison and relation vocabulary of the query DSL.
OperatorMapper	Maps IR operators to source-level operators.
OrderBy	Ordering clause for query results: a sort key and a direction.
PackageFilter	Instrumentation filter matching classes by package prefix.
PackageItem	Represents a CONSTANT_Package entry in the constant pool.
ParameterDecl	A method or constructor parameter in the source AST, carrying its type, annotations, and the final and varargs flags.
ParseErrorListener	Callback the parser reports each error to, with factories for the throwing, collecting, logging and silent policies.
ParseErrorListener.CollectingErrorListener
ParseException	Exception thrown when query parsing fails.
ParseException	Unchecked failure to parse Java source, carrying the offending position and, when available, the source text so the message can show the line with a caret.
Parser	Recursive-descent parser over a Lexer token stream, tracking a scope stack so declared variable types are known while parsing expressions.
PathMetrics	Immutable snapshot of the control-flow statistics gathered during a simulation.
PathQuery	Reachability and path-enumeration queries over the control flow graph a simulation covered.
PatternFilter	Static filter keeping classes and methods whose names match a regex, tested with both full match and substring find.
PatternInstanceOfDesugar	Desugars pattern-matching instanceof (Java 16) for the source-to-bytecode front end.
PatternInstanceOfReconstructor	Reconstructs pattern-matching instanceof (Java 16) from the classic bytecode idiom.
PatternMatcher	Functional interface for pattern matching on IR instructions.
Patterns	Factory for common pattern matchers.
PatternSearch	Fluent search API over a ClassPool for code patterns, optionally backed by call-graph, dependency, and type-inference analyses.
PatternSwitchDesugar	Desugars a Java 21 pattern-matching switch expression into the SwitchBootstraps.typeSwitch invokedynamic and an integer dispatch switch.
PatternSwitchReconstructor	Reconstructs a pattern-matching switch (Java 21, SwitchBootstraps.typeSwitch) from the $pc$ dispatch loop that control-flow recovery falls back to.
PDG	Program dependence graph for a single method, holding the control and data dependence edges between its instruction nodes along with lookup indexes by instruction, value and block.
PDGBuilder	Builder of a program dependence graph for one method, deriving control dependence from the post-dominator tree and data dependence from def-use chains.
PDGDependenceType	Kind of dependence a PDG edge carries - control, data, or interprocedural.
PDGDOTExporter	DOT exporter for a program dependence graph, colouring nodes by kind and taint state and edges by dependence type.
PDGEdge	A directed dependence edge in a program dependence graph.
PDGInstructionNode	A PDG node standing for a single IR instruction, typed PHI for phis and INSTRUCTION otherwise.
PDGNode	Base node of a program dependence graph, identified by an id and holding its own incoming and outgoing dependence edges plus optional taint marking.
PDGNodeType	Kind of a program dependence graph node, carrying display text and whether the kind can act as a dependence source or sink.
PDGPrinter	Renders a program dependence graph as indented plain text.
PDGRegionNode	PDG node standing for a control region - entry, exit or a structured region - over a set of covered blocks, defining and using no values.
PDGSlicer	Intraprocedural slicer over a program dependence graph.
PeepholeOptimizations	Peephole optimization transform.
PermittedSubclassesAttribute	The PermittedSubclasses attribute.
PhiConstantPropagation	Phi Constant Propagation optimization transform.
PhiEliminator	Eliminates phi functions by inserting copies in predecessor blocks, splitting critical edges where needed.
PhiInserter	Phi insertion at dominance frontiers via the Cytron algorithm, yielding minimal SSA form.
PhiInstruction	An SSA phi merging one incoming value per predecessor block.
PointsToQuery	Read-only view over a simulated heap answering aliasing, nullness and reachability questions about points-to sets.
Pop2Instruction	Represents the POP2 instruction (0x58).
PopInstruction	Represents the POP instruction (0x57).
PostDominatorTree	Post-dominator tree for a CFG, computed by dominator analysis on the reverse graph.
Precedence	Java operator binding strengths, ordered from loosest (NONE) to tightest (PRIMARY).
PrimitiveSourceType	Represents a primitive type in the source AST.
PrimitiveSourceType.PrimitiveKind	The eight Java primitives, each paired with its source keyword and IR type.
PrimitiveType	Represents JVM primitive types.
ProbePlan	Compiled query plan.
ProbePlan.Builder	Mutable accumulator for a plan around a fixed query.
ProcessHandlers	Native handlers for process and runtime entry points - Runtime memory queries, ProcessImpl, ProcessHandleImpl, Shutdown, ProcessEnvironment and SecurityManager - stubbed so simulated code never spawns a real process.
Provides	One provides entry of a Module attribute - a service interface plus the implementation classes offered for it, held as constant pool indices.
PutFieldInstruction	Represents the PUTFIELD and PUTSTATIC instructions (0xB5, 0xB3).
PutFieldInstruction.FieldType	The field-write kinds (instance PUTFIELD vs static PUTSTATIC), each pairing a JVM opcode with its mnemonic.
Query	Root query AST node.
QueryBatchRunner	Executor of a ProbePlan over a class pool, evaluating the query condition on every candidate the plan's scope filter admits and projecting each hit into a QueryMatch carrying the evaluator's evidence.
QueryBatchRunner.ProgressListener	Callback for run progress, invoked on the thread executing the run.
QueryBatchRunner.QueryBatchResult	The outcome of one run - the ordered matches plus whether the run was cut short by cancellation.
QueryLexer	Tokenizer for the query DSL.
QueryMatch	A single query match.
QueryMatch.Builder	Fluent builder that accumulates attributes and evidence for one match.
QueryParser	Parses the outer query shell - (FIND|SHOW) target [IN|DURING scope] [WHERE expr] [WITH runspec] [LIMIT n] [ORDER BY key] - and delegates the WHERE expression to ConditionParser, the composable matcher grammar.
QueryPlanner	Compiles a query into an executable ProbePlan.
QueryService	Front end for running query text against a class pool - parse, plan, then execute, either inline or on a single daemon worker thread.
QueryService.QueryConfig	Runtime knobs for a query run - currently just the wall-clock budget that aborts long scans.
QueryService.QueryConfig.Builder	Accumulator for a QueryConfig.
QueryService.QueryResult	The outcome of one query run - the source text, its parsed and planned forms, the matches, timing, and either a completion flag or a parse error message.
QueryTarget	The code location a query match points to: a class, a method, or a specific bytecode offset within a method.
QueryTarget.ClassTarget
QueryTarget.MethodTarget
QueryTarget.PCTarget
ReachingConditionStructurer	Reaching-condition control-flow structurer: the DREAM-style ("No More Gotos") replacement for schema-based structural analysis.
Reassociate	Reorders commutative operations so constants group together for folding, e.g.
RecordAttribute	The Record attribute.
RecordAttribute.Component	A record component: name and descriptor Utf8 indices plus per-component attributes.
RecoveryContext	Holds shared state during expression recovery.
RecursiveHandler	Invocation handler that pushes interpreter frames for bytecode-backed methods, dispatches registered natives, and stubs absent bodies with default values.
RedundantAssignmentEliminator	Removes a redundant re-assignment x = V that repeats an earlier identical x = V in the same block, when nothing between writes x and V is side-effect free.
RedundantCopyElimination	Removes redundant copy instructions and simplifies assignment chains.
ReferenceSourceType	Represents a reference type (class or interface) in the source AST.
ReferenceType	Represents a reference type (class or interface).
ReflectionHandlers	Native handlers for the reflection surface.
RegionRecoveryBridge	The narrow set of statement/expression recovery leaves the reaching-condition engine needs from the host StatementRecoverer.
RegisterAllocator	Linear scan register allocator.
RenameException	Base exception for all rename-related errors.
RenameMapping	Interface for all rename mapping types.
Renamer	Main API for renaming classes, methods, and fields in a ClassPool.
RenamerContext	Shared state for a rename run - the class pool, the mapping store, and a class hierarchy and descriptor/signature remappers derived from them.
RenameValidator	Validates rename mappings before application.
Replacement	The action an editor handler returns for a visited AST node: keep, replace, remove, or insert.
Replacement.Type	The kind of action a replacement performs.
Requires	Represents a requires entry in the Module attribute.
ResolutionCache	Concurrent memoization cache for class, method, field, and assignability lookups.
ResolutionException	Unchecked exception raised when a class, method, or field cannot be resolved.
ResolvedField	A resolved field reference paired with the class that actually declares it.
ResolvedMethod	A resolved method reference paired with its declaring class and invoke kind.
ResolvedMethod.InvokeKind	Dispatch style the resolved method should be invoked with.
RetInstruction	Represents the RET instruction (0xA9).
ReturnHandler	Handler for return statements.
ReturnInstruction	A method return, with or without a value.
ReturnStmt	A return statement with an optional value expression.
ReturnType	Enum representing JVM return instruction types.
ReverseOperatorMapper	Maps AST operators to IR operators (reverse of OperatorMapper in recovery).
RunSpec	Execution budget and tracing configuration for queries that require running code.
RunSpec.Builder	Mutable builder for RunSpec instances.
RunSpec.TraceMode	How much execution trace to retain: none, a bounded ring, or the full trace.
RuntimeInvisibleAnnotationsAttribute	The RuntimeInvisibleAnnotations attribute: annotations not retained for runtime reflection.
RuntimeVisibleAnnotationsAttribute	The RuntimeVisibleAnnotations or RuntimeInvisibleAnnotations attribute, distinguished by a visibility flag.
RuntimeVisibleParameterAnnotationsAttribute	The RuntimeVisibleParameterAnnotations or RuntimeInvisibleParameterAnnotations attribute.
SALoadInstruction	Represents the SALOAD instruction (0x35).
SameFrame	Represents a SameFrame in the StackMapTable attribute.
SameFrameExtended	A same_frame_extended stack map entry - unchanged type state, with the offset delta stored explicitly.
SameLocals1StackItemFrame	Represents a SameLocals1StackItemFrame in the StackMapTable attribute.
SameLocals1StackItemFrameExtended	Represents a SameLocals1StackItemFrameExtended in the StackMapTable attribute.
SAStoreInstruction	Represents the SASTORE instruction (0x56).
Scope	Query scope - limits which code locations to analyze.
ScopeEscapeHoister	Repairs declarations whose variable escapes its block.
ScopeFilterVisitor	Translates a Scope into a static prefilter over the candidate set.
ScopeVisitor<T>	Visitor over the closed set of query scope variants.
SDG	System dependence graph - the per-method PDGs joined by parameter and summary edges at resolved call sites.
SDGActualInNode	SDG node for one actual argument passed at a call site.
SDGActualOutNode	SDG node for the value a call site receives back from the callee.
SDGBuilder	A builder for a system dependence graph, stitching per-method PDGs together over a call graph.
SDGCallNode	System dependence graph node for a call site, holding the actual-in nodes for its arguments, an optional actual-out node, and a link to the callee entry once resolved.
SDGDOTExporter	DOT exporter for a system dependence graph, rendering entry, call, formal and actual parameter nodes plus the interprocedural parameter and summary edges.
SDGEntryNode	The entry node of one procedure in a system dependence graph, owning that procedure's PDG plus its formal-in and formal-out parameter nodes.
SDGFormalInNode	System dependence graph node for one formal parameter at a method entry; it defines the parameter's SSA value and uses nothing.
SDGFormalOutNode	System dependence graph node for a method's returned value at its exit; it uses the returned SSA value and defines nothing.
SDGPrinter	Renders a system dependence graph as indented plain text, including formal and actual parameter nodes and interprocedural edges.
SDGSlicer	Interprocedural slicer over a system dependence graph, using the two-phase ascend/descend walk so slices stay context sensitive across call sites.
SearchResult	A single pattern-search hit, locating a class, method, or IR instruction with a description.
SecurityHandlers	Native handlers for AccessController and the native seed generator; privileged actions return null rather than being run.
Severity	Severity ranking for taint findings, from informational to critical.
ShowQuery	SHOW query - displays all matching items without filtering.
SideEffectDetector	Determines whether an expression (or any sub-expression) has side effects.
SignatureAttribute	The Signature attribute: the constant-pool index of a generic signature Utf8.
SignatureRemapper	Remaps class references within generic signatures.
SimArray	Immutable abstract state of one allocated array, tracking elements both index-insensitively and per constant index.
SimHeap	Abstract heap of objects, arrays, and static fields keyed by allocation site - mutated in place in MUTABLE mode, copied on every write otherwise.
SimilarityMetric	Types of similarity metrics for comparing methods.
SimilarityResult	The scored outcome of comparing two methods, ordered by descending overall score.
SimObject	Immutable abstract heap object for one allocation site, holding a set of possible values per field; every mutator returns a new instance.
SimpleHeapManager	In-memory heap manager backed by concurrent maps, with a string pool and flat static-field storage.
SimpleInstruction	A single-operand instruction identified by its SimpleOp: arraylength, monitor ops, throw, goto, or catch.
SimpleOp	The operation kinds a SimpleInstruction can perform.
SimulationContext	Immutable configuration and shared resources for simulation; the with* methods return modified copies.
SimulationContext.Builder	Mutable builder for SimulationContext instances.
SimulationEngine	Main simulation engine for executing abstract interpretation.
SimulationListener	Listener interface for simulation events.
SimulationMode	Defines the granularity of simulation state tracking.
SimulationResult	Immutable result of a simulation run.
SimulationResult.Builder	Mutable builder for SimulationResult instances.
SimulationState	Immutable snapshot of stack, locals, heap and position at one point during simulation.
SimValue	Immutable simulated value carrying its type, defining instruction and, for references, a points-to set and null state; usable as a map key.
SimValue.NullState	What is known about a reference value's nullness.
SimValueBuilder	Builder API for constructing simulated values with field initialization.
SingleUseInliner	Inlines single-use temporary variables into their usage site.
SipushInstruction	Represents the SIPUSH instruction (0x11).
SliceResult	The nodes and edges reached by a program slice, together with the criterion it was taken from.
SliceResult.SliceType	Direction a slice was taken in.
SlotVariablePartition	Partitions each JVM local slot into one or more source variables using a reaching-definition analysis.
SlotVariablePartition.ScopeNameResolver	Resolves the source name in scope for a (slot, bytecode offset), or null when unknown.
SourceDebugExtensionAttribute	The SourceDebugExtension attribute: opaque extended debugging data as raw bytes.
SourceEmitter	Visitor that renders recovered AST nodes back to Java source text.
SourceEmitter.LineMapSink	Receives each provenance-carrying statement's (owning method key, statement, 1-based line).
SourceEmitterConfig	Configuration options for source code emission.
SourceEmitterConfig.Builder	Fluent builder for emitter settings; every setting has a default.
SourceFileAttribute	The SourceFile attribute: the constant-pool index of the source file name Utf8.
SourceLocation	Position of an AST node as a bytecode offset and source line number, either of which may be absent (-1).
SourcePosition	Immutable line/column position in a source file, with an optional character offset.
SourceType	Sealed interface representing source-level types.
SourceVisitor<T>	Visitor interface for traversing source AST nodes.
SSA	Main entry point for SSA-form IR operations.
SSABridge	Bridges CodeWriter (the bytecode layer) and the SSA IR pipeline.
SSAValue	Represents a value defined by an SSA instruction.
Stack	The abstract operand stack: a growable array of StackCtx (one logical entry per value; a long/double is a single wide entry).
StackCtx	One operand-stack slot during abstract execution.
StackFrame	One interpreter activation: a method's operand stack, locals, program counter, and completion state.
StackFrameInfo	Immutable snapshot of one execution frame's position, used to build stack traces after the frame itself is gone.
StackMapFrame	Base class for stack map frames in the StackMapTable attribute.
StackMapTableAttribute	The StackMapTable attribute: verification frames describing local and stack types at branch targets.
StackMapVerifier	Verification pass that validates a method's StackMapTable against frames recomputed by dataflow.
StackMetrics	Immutable operand stack operation counts collected during simulation.
StackOperationListener	A simulation listener that counts operand stack pushes and pops and tracks current and peak depth, resetting its tallies at each simulation start.
StackOperationListener.DepthChange	Represents a change in stack depth.
StackOperationListener.DepthChange.Type	The kind of stack operation that produced a depth change.
StackScheduler	A linearizer that walks the IR blocks in order and produces a flat schedule of loads, stores and executions, tracking the peak operand stack depth as it goes.
StackScheduler.ScheduledInstruction	One entry of the schedule - an instruction paired with the role it plays.
StackScheduler.ScheduleType	The role a scheduled entry plays - a synthesized local load or store, or the IR instruction itself.
StackSnapshot	An immutable view of a frame's operand stack, taken at one point in execution.
StackState	Immutable operand stack snapshot used during simulation.
Statement	Sealed interface representing all statement types in the source AST.
StatementEditor	Statement-only facade over ASTEditor.
StatementHandler	Base interface for handling statements during AST editing.
StatementLowerer	Lowers AST Statement nodes to IR instructions and blocks.
StatementRecoverer	Recovers Statement AST nodes from IR blocks, offering each region to the reaching-condition structurer first and falling back to the legacy walk for shapes it declines.
StatementRecoverer.RetiredSchemaRecoveryException	Signals a region classification whose schema recoverer is retired and which no engine route owned.
StateSnapshot	An immutable snapshot of simulation state at one instruction.
StateTransitions	Computes state transitions for IR instructions.
StaticFilter	Static prefilter that narrows candidate methods/classes without execution.
StaticFilter.AllFilter
StaticFilter.CompositeFilter
StaticFilter.CompositeFilter.Op	How two filters' results are combined - intersection or union.
StatisticsListener	Listener that aggregates execution counters such as opcode frequency, call depth, allocations, and branch outcomes.
Step	One segment of an Accessor path: a keyword atom optionally indexed (e.g.
StepMode	How far the debugger runs before pausing again.
StmtMatcher	Predicate-based matcher for filtering statements during AST editing.
StoreLocalInstruction	A store to a local variable slot, used during lifting before SSA conversion.
StrengthReduction	Strength Reduction optimization transform.
StringConcatHandler	Interpreter-side implementation of StringConcatFactory call sites, expanding recipe strings into concatenated results.
StringConstant	Represents a string constant.
StringHandlers	Native handlers for String, Base64, and the JDK-internal string coding classes, evaluated on the real host JDK and written back into the simulated heap.
StringPool	Interning pool that materializes java/lang/String heap objects in char-array or compact byte-array layout.
StringRefItem	A CONSTANT_String constant pool entry, holding the pool index of its UTF-8 value.
StringSwitchDesugar	Rewrites a switch over String labels into the two-switch dispatch the JVM can execute.
StructuralAnalyzer	CFG structural analysis identifying if-then-else, while, do-while, for and switch regions.
StructuralAnalyzer.RegionInfo	Information about a structured region.
StructuralValidator	Validator of AST structural integrity, chiefly parent-child link consistency.
StructuralVerifier	Bytecode checker for the structure of a method body - code length, opcode validity, wide prefixes, operands, branch targets landing on instruction boundaries, and the last instruction not falling off the end.
Subject	The polymorphic evaluation cursor.
Subject.ArgSubject
Subject.BootstrapArgSubject	A non-dynamic static bootstrap argument, identified by its constant-pool index.
Subject.CallSubject	An invocation site; invoke implements InvokeInsn.
Subject.ClassSubject
Subject.DynamicSubject	A dynamic site: an invokedynamic call site (site == "indy"), a CONSTANT_Dynamic load, or a nested condy bootstrap argument.
Subject.FieldAccessSubject	A field read/write site; instruction is a GetField/PutField instruction.
Subject.InstructionSubject
Subject.MethodSubject
Subject.ParamSubject	A declared method parameter, identified by position; type is its descriptor from the method signature.
SubjectKind	The type of entity an evaluation is currently bound to.
SuperExpr	Represents the 'super' expression.
SwapInstruction	Represents the SWAP instruction (0x5F).
SwitchCase	A case clause of a switch statement, keyed by integer labels or expression labels.
SwitchDescriptor	A decoded, structuring-ready view of a native int/enum switch.
SwitchDescriptor.CaseSpec	One case of a decoded switch.
SwitchExpr	A switch expression (Java 14, JEP 361): switch (sel) { case L -> result; default -> r; }.
SwitchExpr.Arm	One arm.
SwitchExpr.Component	One component of a record-deconstruction pattern: type binding.
SwitchExpressionDesugar	Desugars switch expressions (Java 14) for the source-to-bytecode front end - the inverse of SwitchExpressionReconstructor.
SwitchExpressionReconstructor	Reconstructs switch expressions (Java 14) from the classic statement form javac lowers them to.
SwitchInstruction	A multi-way branch on an int key, covering both tableswitch and lookupswitch.
SwitchMapAnalyzer	Recovers the enum constant behind each ordinal in a javac $SwitchMap holder class by reading its static initializer.
SwitchStmt	A switch statement over a selector expression and a list of cases.
SynchronizedStmt	A synchronized block guarding its body with a lock expression.
SyntheticArrayConstructor	A synthetic array-allocating method pending materialization; its descriptor takes a single int length and returns the array type.
SyntheticAttribute	The Synthetic attribute: a zero-length marker that the element was compiler-generated.
SyntheticLambdaMethod	A lambda body pending materialization as a synthetic class method, with its captured variables and declared parameters.
SyntheticLambdaMethod.CapturedVariable	A variable captured from the enclosing scope, by name and type.
SyntheticLocalVariableTable	Builds a LocalVariableTable for a STRIPPED method from the decompiler's recovered slot model, keyed to the method's ORIGINAL bytecode offsets.
SystemHandlers	Native handlers for the JDK core natives on Object, Class, System and Thread.
TableSwitchInstruction	Represents the TABLESWITCH instruction (0xAA).
TaintAnalysisResult	Collected taint paths from one analysis run, indexed by vulnerability type and severity.
TaintPath	A single tainted data flow from a source to a sink, with the CPG nodes traversed and any sanitizers seen along the way.
TaintPath.Builder	Accumulator for the endpoints and hop list of a TaintPath.
TaintQuery	A source-to-sink taint search over a code property graph, configured with source, sink, and sanitizer definitions.
TaintQuery.Sanitizer	A regex pair matching call targets that neutralize taint on a path.
TaintSink	A regex-matched method call site where tainted data causes a vulnerability, carrying the argument index that must stay untainted.
TaintSink.Builder	Mutable accumulator for the fields of a TaintSink.
TaintSource	A regex-matched method call site that introduces tainted data, either through its return value or through one argument.
TaintSource.Builder	Mutable accumulator for the fields of a TaintSource.
TaintType	Origin categories for tainted data.
Target	Query target type - what kind of entities the query returns.
TernaryExpr	A conditional expression - condition ? thenExpr : elseExpr - whose three operands are children of this node.
ThisExpr	A reference to the enclosing instance - the 'this' expression.
ThreadHandlers	Native handlers for java.lang.Thread, StackWalker and stack trace natives, stubbed as no-ops or empty results since the interpreter is single-threaded.
ThrowHandler	Handler for throw statements.
ThrowStmt	A throw statement, owning the thrown expression as its only child.
TimeHandlers	Native handlers for java.time factories, backing clocks and instants with the host system time.
Token	Token produced by QueryLexer.
Token	An immutable lexer token - its type, source text, decoded literal value and position.
Token.TokenType	The lexical kinds of the query language.
TokenType	The lexical token kinds of Java 11, declared in category order so the classification predicates can test ordinal ranges.
TraceEvent	Immutable record of a single interpreter event, timestamped at creation and built via static factories.
TraceEvent.Type	Categories of interpreter events a trace can record.
TracingListener	Listener that records interpreter events as TraceEvent entries, optionally with stack snapshots and an event cap.
TransformPreset	Preset configurations for IR transform pipelines during decompilation.
TryCatchHandler	Handler for try-catch-finally statements.
TryCatchStmt	Represents a try-catch statement with optional finally block and resources (try-with-resources).
TryNodeDescriptor	A statically decoded try region treated as one opaque composite node by the reaching-condition engine.
TypeCheckInstruction	A checkcast or instanceof test, distinguished by its TypeCheckOp.
TypeCheckOp	Whether a TypeCheckInstruction is a checkcast or an instanceof test.
TypeConstraint	Assignability and category rules over verification types.
TypeDecl	A declared type in the source AST - class, interface, enum or annotation - exposing its modifiers, annotations and members.
TypeDescriptor	An immutable JVM field or method descriptor, classified by a sort constant.
TypeInference	Type inference engine for bytecode analysis.
TypeInferenceAnalyzer	Dataflow analyzer that infers types and nullability for SSA values, narrowing them at instanceof checks and null comparisons.
TypeInfo	A JVM field descriptor with its slot size and primitive/array classification, compared by descriptor.
TypeNames	Normalizes the many spellings of a Java type to one canonical descriptor form.
TypeRecoverer	Recovers source types from IR types.
TypeResolver	Resolves source-level type, field and method references to JVM names and descriptors, consulting the class being lowered, the class pool and the running JVM in that order.
TypeSet	A union of the types a value may hold, flagged complete when the members are exact and incomplete when subtypes may also occur.
TypeState	Immutable representation of the type state at a specific point in bytecode execution.
TypeState	A value's inferred type set paired with its nullability lattice element.
TypeUtil	Utility class for type descriptor validation and string manipulation.
TypeUtils	Utility methods for type operations including boxing, unboxing, type checking, and common supertype computation.
TypeVerifier	Abstract-interpretation type checker for a method body, walking the bytecode to a fixpoint and reporting stack, local and return type errors to a collector.
UnaryExpr	Represents a unary expression: op operand (prefix) or operand op (postfix)
UnaryExprHandler	Handler for unary expressions (negation, increment, etc.).
UnaryOp	Unary operation types.
UnaryOperator	Unary operators for expressions.
UnaryOpInstruction	A unary operation such as negation or a primitive type conversion.
UnionSourceType	Represents a union type, e.g., catch (IOException | SQLException e).
UnknownInstruction	Represents an unknown or unhandled instruction.
Uses	A uses entry of the Module attribute, naming a service interface the module consumes.
Utf8Item	A CONSTANT_Utf8 entry in the constant pool, stored in JVMS modified UTF-8.
ValidationError	A single issue reported by AST validation, with severity, category, and offending node.
ValidationError.Category	The aspect of the AST a validation issue concerns.
ValidationError.Severity	How serious a validation issue is.
ValidationResult	Contains the results of validating rename mappings.
Value	The universal scalar produced by attribute resolution and carried by query literals, as a closed set of nested variants discriminated by Value.kind().
Value	Base interface for all values in SSA form.
Value.Absent
Value.BoolValue
Value.IntValue
Value.NullValue
Value.RealValue
Value.RegexValue
Value.SetValue
Value.StrValue
Value.TypeValue	A type reference: either an internal name (java/lang/String) or a descriptor (I).
ValueFlowQuery	Def-use query over the values observed by a simulation run.
ValueInfo	A debugger-facing description of one interpreter value: its tag, a printable rendering, and the underlying object.
ValueKind	Discriminator for Value variants, used by the comparator to dispatch without instanceof chains.
ValueRange	An inclusive range of integer values used to track value constraints.
ValueTag	Runtime type of an interpreted value, carrying its JVM slot category.
VarargsReconstructor	Reconstructs varargs calls by collapsing an explicit trailing array argument back into individual arguments.
VarCtx	One local-variable slot's contents during abstract execution.
VarDeclStmt	Represents a local variable declaration: Type name [= initializer] Also supports Java 10+ var keyword.
VariableRenamer	Renames variables to complete SSA conversion by walking the dominator tree.
Variables	The abstract local-variable table: an array of VarCtx indexed by slot.
VarRefExpr	Represents a local variable reference.
Verbosity	Detail level for graph printing, from MINIMAL to DEBUG.
VerificationError	One immutable verification finding: a typed error or warning with an optional bytecode offset and location.
VerificationError.Severity	Severity of a finding: ERROR fails verification, WARNING does not.
VerificationErrorType	Category of a verification finding, spanning structural, type, control-flow, and stack-map checks.
VerificationResult	Immutable outcome of a verification run: validity plus the collected errors and warnings.
VerificationType	A verification type in a StackMapTable frame, as a sealed hierarchy.
VerificationType.ObjectType	Object verification type implementation.
VerificationType.PrimitiveType	Primitive verification type implementation.
VerificationType.UninitializedType	Uninitialized verification type implementation.
VerificationTypeInfo	Represents verification type information used in stack map frames.
Verifier	Bytecode verifier that runs the configured structural, type, control-flow, and stack-map passes over methods, classes, or whole pools.
Verifier.Builder	Builder for a Verifier.
VerifierConfig	Immutable settings for the Verifier: which passes run, the error mode, and the error cap.
VerifierConfig.Builder	Builder for a VerifierConfig; all passes default to enabled with COLLECT_ALL and 100 errors.
VerifierConfig.ErrorMode	How the verifier reacts to errors: stop at the first or collect up to the cap.
Visitor<T>	Base visitor interface for processing various bytecode elements.
VMHandlers	Native handlers for the JDK internal VM, boot loader, perf, signal, and CDS natives.
VoidSourceType	The void type in the source AST, held as a singleton.
VoidType	Represents the void type (for method returns).
VulnerabilityType	Vulnerability classes a taint sink can represent.
WhileStmt	A while loop with an optional label.
WhileToForCanonicalizer	Canonicalizes a counted while back into a for:
WideIIncInstruction	Represents the JVM WIDE IINC instruction.
WideInstruction	Represents the WIDE instruction (0xC4).
WildcardSourceType	A wildcard type argument such as "?", "? extends Number" or "? super Integer"; erases to java/lang/Object.
WildcardSourceType.BoundKind	Which bound form a wildcard carries.
WrapperHandlers	Native handlers for the primitive wrapper classes plus StringBuilder and StringBuffer, backing boxing and string building with heap objects.
Xref	An immutable cross-reference from a source instruction to the class, method, or field it names.
Xref.Builder	Mutable accumulator for the fields of an Xref.
XrefBuilder	A builder for a cross-reference database over every class in a ClassPool, recording call, field access, instantiation, cast and inheritance references.
XrefDatabase	Cross-reference store that keeps every xref indexed by source class, target class, target method, target field and reference type for constant-time lookup.
XrefType	Kinds of cross-reference tracked in the xref database.
ZipHandlers	Native handlers for java.util.zip.