Parsing Java's class file

Question

The structure of a class file consists of a single structure (presented here using pseudostructures written in a C-like structure notation):

ClassFile {
    u4             magic;
    u2             minor_version;
    u2             major_version;
    u2             constant_pool_count;
    cp_info        constant_pool[constant_pool_count-1];
    u2             access_flags;
    u2             this_class;
    u2             super_class;
    u2             interfaces_count;
    u2             interfaces[interfaces_count];
    u2             fields_count;
    field_info     fields[fields_count];
    u2             methods_count;
    method_info    methods[methods_count];
    u2             attributes_count;
    attribute_info attributes[attributes_count];
}

The script parses the class file into a dictionary, except for the attributes, but does not verify that the file is valid/correct. (I did not deem that a good use of my time)

For a class file generated for this simple program:

public class Main {
    public static void main(String[] args) {
        System.out.println("Hello, World!");
    }
}

the script produces:

{'access_flags': ['ACC_FINAL',
                  'ACC_INTERFACE',
                  'ACC_ABSTRACT',
                  'ACC_SYNTHETIC',
                  'ACC_ANNOTATION',
                  'ACC_ENUM'],
 'attributes': [{'attribute_length': 2,
                 'attribute_name_index': 13,
                 'info': b'\x00\x0e'}],
 'attributes_count': 1,
 'constant_pool': [{'class_index': 6, 'name_and_type_index': 15, 'tag': 10},
                   {'class_index': 16, 'name_and_type_index': 17, 'tag': 9},
                   {'name_index': 18, 'tag': 8},
                   {'class_index': 19, 'name_and_type_index': 20, 'tag': 10},
                   {'name_index': 21, 'tag': 7},
                   {'name_index': 22, 'tag': 7},
                   {'bytes': b'<init>', 'length': 6, 'tag': 1},
                   {'bytes': b'()V', 'length': 3, 'tag': 1},
                   {'bytes': b'Code', 'length': 4, 'tag': 1},
                   {'bytes': b'LineNumberTable', 'length': 15, 'tag': 1},
                   {'bytes': b'main', 'length': 4, 'tag': 1},
                   {'bytes': b'([Ljava/lang/String;)V', 'length': 22, 'tag': 1},
                   {'bytes': b'SourceFile', 'length': 10, 'tag': 1},
                   {'bytes': b'Main.java', 'length': 9, 'tag': 1},
                   {'descriptor_index': 8, 'name_index': 7, 'tag': 12},
                   {'name_index': 23, 'tag': 7},
                   {'descriptor_index': 25, 'name_index': 24, 'tag': 12},
                   {'bytes': b'Hello, World!', 'length': 13, 'tag': 1},
                   {'name_index': 26, 'tag': 7},
                   {'descriptor_index': 28, 'name_index': 27, 'tag': 12},
                   {'bytes': b'Main', 'length': 4, 'tag': 1},
                   {'bytes': b'java/lang/Object', 'length': 16, 'tag': 1},
                   {'bytes': b'java/lang/System', 'length': 16, 'tag': 1},
                   {'bytes': b'out', 'length': 3, 'tag': 1},
                   {'bytes': b'Ljava/io/PrintStream;', 'length': 21, 'tag': 1},
                   {'bytes': b'java/io/PrintStream', 'length': 19, 'tag': 1},
                   {'bytes': b'println', 'length': 7, 'tag': 1},
                   {'bytes': b'(Ljava/lang/String;)V', 'length': 21, 'tag': 1}],
 'constant_pool_count': 29,
 'fields': [],
 'fields_count': 0,
 'interfaces': [],
 'interfaces_count': 0,
 'magic': '0XCAFEBABE',
 'major': 55,
 'methods': [{'access_flags': ['ACC_PRIVATE',
                               'ACC_PROTECTED',
                               'ACC_STATIC',
                               'ACC_FINAL',
                               'ACC_SYNCHRONIZED',
                               'ACC_BRIDGE',
                               'ACC_VARARGS',
                               'ACC_NATIVE',
                               'ACC_ABSTRACT',
                               'ACC_STRICT',
                               'ACC_SYNTHETIC'],
              'attributes': [{'attribute_length': 29,
                              'attribute_name_index': 9,
                              'info': b'\x00\x01\x00\x01\x00\x00\x00\x05'
                                      b'*\xb7\x00\x01\xb1\x00\x00\x00'
                                      b'\x01\x00\n\x00\x00\x00\x06\x00'
                                      b'\x01\x00\x00\x00\x01'}],
              'attributes_count': 1,
              'descriptor_index': 8,
              'name_index': 7},
             {'access_flags': ['ACC_PRIVATE',
                               'ACC_PROTECTED',
                               'ACC_FINAL',
                               'ACC_SYNCHRONIZED',
                               'ACC_BRIDGE',
                               'ACC_VARARGS',
                               'ACC_NATIVE',
                               'ACC_ABSTRACT',
                               'ACC_STRICT',
                               'ACC_SYNTHETIC'],
              'attributes': [{'attribute_length': 37,
                              'attribute_name_index': 9,
                              'info': b'\x00\x02\x00\x01\x00\x00\x00\t'
                                      b'\xb2\x00\x02\x12\x03\xb6\x00\x04'
                                      b'\xb1\x00\x00\x00\x01\x00\n\x00'
                                      b'\x00\x00\n\x00\x02\x00\x00\x00'
                                      b'\x03\x00\x08\x00\x04'}],
              'attributes_count': 1,
              'descriptor_index': 12,
              'name_index': 11}],
 'methods_count': 2,
 'minor': 0,
 'super_class': 6,
 'this_class': 5}

Code:

#!/usr/bin/env python3

from enum import Enum
from io import BytesIO
from pathlib import Path
from pprint import pprint

import typer


# fmt: off
# This got rather duplicative. 
class Constants(Enum):
    CONSTANT_Class              = 7
    CONSTANT_Fieldref           = 9
    CONSTANT_Methodref          = 10
    CONSTANT_InterfaceMethodref = 11
    CONSTANT_String             = 8
    CONSTANT_Integer            = 3
    CONSTANT_Float              = 4
    CONSTANT_Long               = 5
    CONSTANT_Double             = 6
    CONSTANT_NameAndType        = 12
    CONSTANT_Utf8               = 1
    CONSTANT_MethodHandle       = 15
    CONSTANT_MethodType         = 16
    CONSTANT_InvokeDynamic      = 18


ACCESS_FLAGS = {
    "class":  [
        ("ACC_PUBLIC"       ,0x0001),
        ("ACC_FINAL"        ,0x0010),
        ("ACC_SUPER"        ,0x0020),
        ("ACC_INTERFACE"    ,0x0200),
        ("ACC_ABSTRACT"     ,0x0400),
        ("ACC_SYNTHETIC"    ,0x1000),
        ("ACC_ANNOTATION"   ,0x2000),
        ("ACC_ENUM"         ,0x4000),
    ],
    "field": [
        ("ACC_PUBLIC"       ,0x0001),
        ("ACC_PRIVATE"      ,0x0002),
        ("ACC_PROTECTED"    ,0x0004),
        ("ACC_STATIC"       ,0x0008),
        ("ACC_FINAL"        ,0x0010),
        ("ACC_VOLATILE"     ,0x0040),
        ("ACC_TRANSIENT"    ,0x0080),
        ("ACC_SYNTHETIC"    ,0x1000),
        ("ACC_ENUM"         ,0x4000),
    ],
    "method": [
        ("ACC_PUBLIC"       ,0x0001),
        ("ACC_PRIVATE"      ,0x0002),
        ("ACC_PROTECTED"    ,0x0004),
        ("ACC_STATIC"       ,0x0008),
        ("ACC_FINAL"        ,0x0010),
        ("ACC_SYNCHRONIZED" ,0x0020),
        ("ACC_BRIDGE"       ,0x0040),
        ("ACC_VARARGS"      ,0x0080),
        ("ACC_NATIVE"       ,0x0100),
        ("ACC_ABSTRACT"     ,0x0400),
        ("ACC_STRICT"       ,0x0800),
        ("ACC_SYNTHETIC"    ,0x1000),
    ],
}
# fmt: on


def parse_ux(file: BytesIO, length: int) -> int:
    return int.from_bytes(file.read(length), "big")


def parse_u1(file: BytesIO) -> int:
    return parse_ux(file, 1)


def parse_u2(file: BytesIO) -> int:
    return parse_ux(file, 2)


def parse_u4(file: BytesIO) -> int:
    return parse_ux(file, 4)


def parse_constant_pool(f: BytesIO, pool_size: int) -> int:
    constant_pool = []

    # We could map each constant tag to its corresponding processing logic.
    # Would that be better? This looks horrendous.
    for _ in range(pool_size):
        cp_info = {}
        tag = parse_u1(f)
        constant = Constants(tag)

        if constant in (
            Constants.CONSTANT_Methodref,
            Constants.CONSTANT_InterfaceMethodref,
            Constants.CONSTANT_Fieldref,
        ):
            cp_info["tag"] = constant.value
            cp_info["class_index"] = parse_u2(f)
            cp_info["name_and_type_index"] = parse_u2(f)
        elif constant in (Constants.CONSTANT_Class, Constants.CONSTANT_String):
            cp_info["tag"] = constant.value
            cp_info["name_index"] = parse_u2(f)
        elif constant == Constants.CONSTANT_Utf8:
            cp_info["tag"] = constant.value
            cp_info["length"] = parse_u2(f)
            cp_info["bytes"] = f.read(cp_info["length"])
        elif constant == Constants.CONSTANT_NameAndType:
            cp_info["tag"] = constant.value
            cp_info["name_index"] = parse_u2(f)
            cp_info["descriptor_index"] = parse_u2(f)
        elif constant in (Constants.CONSTANT_Integer, Constants.CONSTANT_Float):
            cp_info["tag"] = constant.value
            cp_info["bytes"] = f.read(4)
        elif constant in (Constants.CONSTANT_Long, Constants.CONSTANT_Double):
            cp_info["tag"] = constant.value
            cp_info["high_bytes"] = f.read(4)
            cp_info["low_bytes"] = f.read(4)
        elif constant == Constants.CONSTANT_MethodHandle:
            cp_info["tag"] = constant.value
            cp_info["reference_kind"] = parse_u1(f)
            cp_info["reference_index"] = parse_u2(f)
        elif constant == Constants.CONSTANT_MethodType:
            cp_info["tag"] = constant.value
            cp_info["descriptor_index"] = parse_u2(f)
        elif constant == Constants.CONSTANT_InvokeDynamic:
            cp_info["tag"] = constant.value
            cp_info["bootstrap_method_attr_index"] = parse_u2(f)
            cp_info["name_and_type_index"] = parse_u2(f)
        else:
            assert False, f"Unexpected tag encountered {tag = }"
        constant_pool.append(cp_info)
    return constant_pool


def parse_access_flags(val: int, flags: [(str, int)]) -> list[str]:
    return [name for (name, mask) in flags if not (val & mask)]


def parse_attributes(f: BytesIO, attributes_count: int) -> list:
    attributes = []

    for _ in range(attributes_count):
        attribute_info = {}
        attribute_info["attribute_name_index"] = parse_u2(f)
        attribute_info["attribute_length"] = parse_u4(f)
        attribute_info["info"] = f.read(attribute_info["attribute_length"])
        attributes.append(attribute_info)

    return attributes


def parse_methods(f: BytesIO, methods_count: int) -> list:
    methods = []

    for _ in range(methods_count):
        method_info = {}
        method_info["access_flags"] = parse_access_flags(
            parse_u2(f), ACCESS_FLAGS["method"]
        )
        method_info["name_index"] = parse_u2(f)
        method_info["descriptor_index"] = parse_u2(f)
        method_info["attributes_count"] = parse_u2(f)
        method_info["attributes"] = parse_attributes(f, method_info["attributes_count"])
        methods.append(method_info)
    return methods


def parse_fields(f: BytesIO, fields_count: int) -> dict:
    fields = []

    for _ in range(fields_count):
        field_info = {}
        field_info["access_flags"] = parse_access_flags(
            parse_u2(f), ACCESS_FLAGS["field"]
        )
        field_info["name_index"] = parse_u2(f)
        field_info["descriptor_index"] = parse_u2(f)
        field_info["attributes_count"] = parse_u2(f)
        field_info["attributes"] = parse_attributes(f, field_info["attributes_count"])
        fields.append(field_info)

    return fields


def parse_interfaces(f: BytesIO, interfaces_count: int) -> dict:
    interfaces = []

    for _ in range(interfaces_count):
        parse_u1(f)  # Discard tag
        class_info = {"tag": "CONSTANT_Class", "name_index": parse_u2()}
        interfaces.append(class_info)

    return interfaces


def parse_class_file(f: BytesIO) -> dict:
    class_file = {}
    class_file["magic"] = str(hex(parse_u4(f))).upper()
    class_file["minor"] = parse_u2(f)
    class_file["major"] = parse_u2(f)
    class_file["constant_pool_count"] = parse_u2(f)
    class_file["constant_pool"] = parse_constant_pool(
        f, class_file["constant_pool_count"] - 1
    )
    class_file["access_flags"] = parse_access_flags(parse_u2(f), ACCESS_FLAGS["class"])
    class_file["this_class"] = parse_u2(f)
    class_file["super_class"] = parse_u2(f)
    class_file["interfaces_count"] = parse_u2(f)
    class_file["interfaces"] = parse_interfaces(f, class_file["interfaces_count"])
    class_file["fields_count"] = parse_u2(f)
    class_file["fields"] = parse_fields(f, class_file["fields_count"])
    class_file["methods_count"] = parse_u2(f)
    class_file["methods"] = parse_methods(f, class_file["methods_count"])
    class_file["attributes_count"] = parse_u2(f)
    class_file["attributes"] = parse_attributes(f, class_file["attributes_count"])

    return class_file


def main(file_path: Path) -> None:
    with open(file_path, mode="rb") as f:
        class_file = parse_class_file(BytesIO(f.read()))
        pprint(class_file)


if __name__ == "__main__":
    typer.run(main)

Review Request:

Bugs, general coding comments, style, idiomatic code, et cetera.

PS: This was done as a recreational activity.

Answer 1

Your reference is extremely out-of-date; refer to version 21. Luckily the JVM hasn't changed much.

Typer seems like overkill for a program that unconditionally accepts one command-line argument. I scarcely consider that justification for bringing in a third-party library.

Your Constants shouldn't be an Enum; it should be an IntEnum. Your ACCESS_FLAGS should not be a dict of lists; it should be split out into separate IntFlags.

When you print the constant tag, don't print the number; print the symbol. repr (!r) will do this.

I consider int.from_bytes and the variable-length method used in parse_ux to be less explicit than the other two options I'll be demonstrating, which are struct unpacking and ctypes unpacking. Your parse_fields and similar methods should be entirely replaced with big-endian structure definitions.

Don't use dictionaries for internal program data; they aren't well-typed.

Your script will not be very useful until you resolve the constant indices to their respective structures. For instance, your output 'attribute_name_index': 9 would be replaced with a reference to the corresponding constant string.

Replace open(file_path, mode="rb") with file_path.open().

It's actually a pretty reasonable idea to in-memory buffer the file content before deserialising it, and may have performance advantages; but for simplicity I do not include this in my demonstration.

Suggested

The following is a little long-winded, but demonstrates some of the concepts I've talked about above. It has nearly mypy-compliant types, save for the functional enums that mypy does not support.

#!/usr/bin/env python3
import ctypes
import struct
import sys
from dataclasses import dataclass
from enum import IntEnum, IntFlag
from functools import partial
from io import BufferedIOBase
from itertools import chain
from pathlib import Path
from typing import Callable, ClassVar, Iterator, NamedTuple, Type, TypeVar

# Spec from
# https://docs.oracle.com/javase/specs/jvms/se21/html/jvms-4.html

# Since we don't require strict validation, this captures all flags that don't
# have multiple definitions.
ACCESS_SHARED = {
    'PUBLIC'    : 0x0001,
    'PRIVATE'   : 0x0002,
    'PROTECTED' : 0x0004,
    'STATIC'    : 0x0008,
    'FINAL'     : 0x0010,
    'NATIVE'    : 0x0100,
    'INTERFACE' : 0x0200,
    'ABSTRACT'  : 0x0400,
    'STRICT'    : 0x0800,
    'SYNTHETIC' : 0x1000,
    'ANNOTATION': 0x2000,
    'ENUM'      : 0x4000,
}

# This functional enum form is not mypy-compatible.
CommonAccess = IntFlag('CommonAccess', ACCESS_SHARED)

ClassAccess = IntFlag('ClassAccess', {
    **ACCESS_SHARED,
    'SUPER':  0x0020,
    'MODULE': 0x8000,
})

MethodAccess = IntFlag('MethodAccess', {
    **ACCESS_SHARED,
    'SYNCHRONIZED' : 0x0020,
    'BRIDGE'       : 0x0040,
    'VARARGS'      : 0x0080,
})

ParameterAccess = IntFlag('ParameterAccess', {
    **ACCESS_SHARED,
    'MANDATED' : 0x8000,
})

ModuleAccess = IntFlag('ModuleAccess', {
    **ACCESS_SHARED,
    'OPEN'     : 0x0020,
    'MANDATED' : 0x8000,
})

ModuleRequiresAccess = IntFlag('ModuleRequiresAccess', {
    **ACCESS_SHARED,
    'TRANSITIVE'   : 0x0020,
    'STATIC_PHASE' : 0x0040,
    'MANDATED'     : 0x8000,
})

FieldAccess = IntFlag('FieldAccess', {
    **ACCESS_SHARED,
    'VOLATILE'  : 0x0040,
    'TRANSIENT' : 0x0080,
})


class ConstantTag(IntEnum):
    UTF8                 = 1
    INTEGER              = 3
    FLOAT                = 4
    LONG                 = 5
    DOUBLE               = 6
    CLASS                = 7
    STRING               = 8
    FIELD_REF            = 9
    METHOD_REF           = 10
    INTERFACE_METHOD_REF = 11
    NAME_AND_TYPE        = 12
    METHOD_HANDLE        = 15
    METHOD_TYPE          = 16
    DYNAMIC              = 17
    INVOKE_DYNAMIC       = 18
    MODULE               = 19
    PACKAGE              = 20


class ReferenceKind(IntEnum):
    getField         = 1
    getStatic        = 2
    putField         = 3
    putStatic        = 4
    invokeVirtual    = 5
    invokeStatic     = 6
    invokeSpecial    = 7
    newInvokeSpecial = 8
    invokeInterface  = 9


class Version(ctypes.BigEndianStructure):
    _pack_ = 1
    _fields_ = (
        ('magic', ctypes.c_uint32),
        ('minor_version', ctypes.c_uint16),
        ('major_version', ctypes.c_uint16),
    )
    __slots__ = [k for k, t in _fields_]


class Constant:
    CHILDREN: ClassVar[tuple[str, ...]]


class ClassConstant(Constant, ctypes.BigEndianStructure):
    _pack_ = 1
    _fields_ = (
        ('name_index', ctypes.c_uint16),
    )
    CHILDREN = 'name_index',
    __slots__ = ('name_index', 'name_constant')

    def __str__(self) -> str:
        return str(self.name_constant)


ModuleConstant = ClassConstant
PackageConstant = ClassConstant


class DoubleConstant(Constant, ctypes.BigEndianStructure):
    _pack_ = 1
    _fields_ = (
        # Don't represent as high bytes and low bytes in the spec;
        # directly unpack to value
        ('value', ctypes.c_double),
    )
    CHILDREN = ()
    __slots__ = 'value',

    def __str__(self) -> str:
        return str(self.value)


class DynamicConstant(Constant, ctypes.BigEndianStructure):
    _pack_ = 1
    _fields_ = (
        ('bootstrap_method_attr_index', ctypes.c_uint16),
        ('name_and_type_index', ctypes.c_uint16),
    )
    CHILDREN = ('bootstrap_method_attr_index', 'name_and_type_index')
    __slots__ = (
        'bootstrap_method_attr_index', 'bootstrap_method_attr_constant',
        'name_and_type_index', 'name_and_type_constant',
    )

    def __str__(self) -> str:
        return f'{self.name_and_type_constant} -> {self.bootstrap_method_attr_constant}'


class FloatConstant(Constant, ctypes.BigEndianStructure):
    _pack_ = 1
    _fields_ = (
        ('value', ctypes.c_float),
    )
    CHILDREN = ()
    __slots__ = 'value',

    def __str__(self) -> str:
        return str(self.value)


class IntegerConstant(Constant, ctypes.BigEndianStructure):
    _pack_ = 1
    _fields_ = (
        ('value', ctypes.c_int32),
    )
    CHILDREN = ()
    __slots__ = 'value',

    def __str__(self) -> str:
        return str(self.value)


class LongConstant(Constant, ctypes.BigEndianStructure):
    _pack_ = 1
    _fields_ = (
        ('value', ctypes.c_int64),
    )
    CHILDREN = ()
    __slots__ = 'value',

    def __str__(self) -> str:
        return str(self.value)


InvokeDynamicConstant = DynamicConstant


class MethodHandleConstant(Constant, ctypes.BigEndianStructure):
    _pack_ = 1
    _fields_ = (
        ('reference_kind', ctypes.c_uint8),
        ('reference_index', ctypes.c_uint16),
    )
    CHILDREN = 'reference_index',
    __slots__ = (
        'reference_kind',
        'reference_index', 'reference_constant',
    )

    @property
    def kind(self) -> ReferenceKind:
        return ReferenceKind(self.reference_kind)

    def __str__(self) -> str:
        return f'{self.kind.name} {self.reference_constant}'


class MethodRefConstant(Constant, ctypes.BigEndianStructure):
    _pack_ = 1
    _fields_ = (
        ('class_index', ctypes.c_uint16),
        ('name_and_type_index', ctypes.c_uint16),
    )
    CHILDREN = ('class_index', 'name_and_type_index')
    __slots__ = (
        'class_index', 'class_constant',
        'name_and_type_index', 'name_and_type_constant',
    )

    def __str__(self) -> str:
        return str(self.name_and_type_constant)


class MethodTypeConstant(Constant, ctypes.BigEndianStructure):
    _pack_ = 1
    _fields_ = (
        ('descriptor_index', ctypes.c_uint16),
    )
    CHILDREN = 'descriptor_index',
    __slots__ = ('descriptor_index', 'descriptor_constant')

    def __str__(self) -> str:
        return str(self.descriptor_constant)


FieldRefConstant = MethodRefConstant
InterfaceMethodConstant = MethodRefConstant


class NameAndTypeConstant(Constant, ctypes.BigEndianStructure):
    _pack_ = 1
    _fields_ = (
        ('name_index', ctypes.c_uint16),
        ('descriptor_index', ctypes.c_uint16),
    )
    CHILDREN = ('name_index', 'descriptor_index')
    __slots__ = (
        'name_index', 'name_constant',
        'descriptor_index', 'descriptor_constant',
    )

    def __str__(self) -> str:
        return f'{self.name_constant} "{self.descriptor_constant}"'


class StringConstant(Constant, ctypes.BigEndianStructure):
    _pack_ = 1
    _fields_ = (
        ('string_index', ctypes.c_uint16),
    )
    CHILDREN = 'string_index',
    __slots__ = ('string_index', 'string_constant')

    def __str__(self) -> str:
        return str(self.string_constant)


class AttributeInfo(Constant, ctypes.BigEndianStructure):
    _pack_ = 1
    _fields_ = (
        ('attribute_name_index', ctypes.c_uint16),
        ('attribute_length', ctypes.c_uint32),
    )
    data: bytes
    CHILDREN = 'attribute_name_index',
    __slots__ = (
        'attribute_name_index', 'attribute_name_constant',
        'attribute_length', 'data',
    )

    def __str__(self) -> str:
        return f'{self.attribute_name_constant}'


class FieldInfo(Constant, ctypes.BigEndianStructure):
    _pack_ = 1
    _fields_ = (
        ('access_flags', ctypes.c_uint16),
        ('name_index', ctypes.c_uint16),
        ('descriptor_index', ctypes.c_uint16),
        ('attributes_count', ctypes.c_uint16),
    )
    CHILDREN = ('name_index', 'descriptor_index')
    attributes: tuple[AttributeInfo, ...]
    __slots__ = (
        'name_index', 'name_constant',
        'descriptor_index', 'descriptor_constant',
        'access_flags', 'attributes_count',
        'attributes',
    )

    @property
    def access(self) -> FieldAccess:
        return FieldAccess(self.access_flags)

    def __str__(self) -> str:
        s = f'{self.access!r} {self.name_constant} "{self.descriptor_constant}"'
        attrs = ', '.join(str(a) for a in self.attributes)
        if attrs:
            s += ' @ ' + attrs
        return s


class MethodInfo(Constant, ctypes.BigEndianStructure):
    _pack_ = 1
    _fields_ = (
        ('access_flags', ctypes.c_uint16),
        ('name_index', ctypes.c_uint16),
        ('descriptor_index', ctypes.c_uint16),
        ('attributes_count', ctypes.c_uint16),
    )
    CHILDREN = ('name_index', 'descriptor_index')
    attributes: tuple[AttributeInfo, ...]
    __slots__ = (
        'name_index', 'name_constant',
        'descriptor_index', 'descriptor_constant',
        'access_flags', 'attributes_count',
        'attributes',
    )

    @property
    def access(self) -> MethodAccess:
        return MethodAccess(self.access_flags)

    def __str__(self) -> str:
        s = f'{self.access!r} {self.name_constant} "{self.descriptor_constant}"'
        attrs = ', '.join(str(a) for a in self.attributes)
        if attrs:
            s += ' @ ' + attrs
        return s


@dataclass(frozen=True, slots=True)
class UTF8Constant(Constant):
    length: int
    bytes_: bytes
    CHILDREN = ()

    @classmethod
    def read(cls, f: BufferedIOBase) -> 'UTF8Constant':
        length = read_short(f)
        bytes_ = f.read(length)
        return cls(length=length, bytes_=bytes_)

    def __str__(self) -> str:
        return self.bytes_.decode(encoding='utf8')


StructT = TypeVar('StructT', bound=ctypes.BigEndianStructure)


def read_struct(f: BufferedIOBase, type_: Type[StructT]) -> StructT:
    value = type_()
    f.readinto(value)
    return value


def read_short(f: BufferedIOBase) -> int:
    fmt = '>H'
    buffer = f.read(struct.calcsize(fmt))
    value, = struct.unpack(fmt, buffer)
    return value


def read_indices(f: BufferedIOBase, n: int) -> tuple[int, ...]:
    fmt = f'>{n}H'
    buffer = f.read(struct.calcsize(fmt))
    return struct.unpack(fmt, buffer)


def bind_read(type_: Type[StructT]) -> Callable[[BufferedIOBase], StructT]:
    return partial(read_struct, type_=type_)


CONSTANT_READERS = {
    ConstantTag.CLASS: bind_read(ClassConstant),
    ConstantTag.DOUBLE: bind_read(DoubleConstant),
    ConstantTag.DYNAMIC: bind_read(DynamicConstant),
    ConstantTag.FIELD_REF: bind_read(FieldRefConstant),
    ConstantTag.FLOAT: bind_read(FloatConstant),
    ConstantTag.INTEGER: bind_read(IntegerConstant),
    ConstantTag.INTERFACE_METHOD_REF: bind_read(InterfaceMethodConstant),
    ConstantTag.INVOKE_DYNAMIC: bind_read(InvokeDynamicConstant),
    ConstantTag.LONG: bind_read(LongConstant),
    ConstantTag.METHOD_REF: bind_read(MethodRefConstant),
    ConstantTag.METHOD_HANDLE: bind_read(MethodHandleConstant),
    ConstantTag.METHOD_TYPE: bind_read(MethodTypeConstant),
    ConstantTag.MODULE: bind_read(ModuleConstant),
    ConstantTag.NAME_AND_TYPE: bind_read(NameAndTypeConstant),
    ConstantTag.PACKAGE: bind_read(PackageConstant),
    ConstantTag.STRING: bind_read(StringConstant),
    ConstantTag.UTF8: UTF8Constant.read,
}


def generate_constants(f: BufferedIOBase, n: int) -> Iterator[Constant]:
    for _ in range(n):
        tag_value, = f.read(1)
        tag = ConstantTag(tag_value)
        yield CONSTANT_READERS[tag](f)


def generate_attrs(f: BufferedIOBase, n: int) -> Iterator[AttributeInfo]:
    for _ in range(n):
        attr = read_struct(f, AttributeInfo)
        attr.data = f.read(attr.attribute_length)
        yield attr


class Class(NamedTuple):
    major_version: int
    minor_version: int
    access_flags: ClassAccess
    constants: tuple[Constant, ...]
    this_class: Constant
    super_class: Constant
    interfaces: tuple[Constant, ...]
    fields: tuple[FieldInfo, ...]
    methods: tuple[MethodInfo, ...]
    attributes: tuple[AttributeInfo, ...]

    @classmethod
    def deserialise(cls, f: BufferedIOBase) -> 'Class':
        version = read_struct(f=f, type_=Version)

        constant_pool_count = read_short(f)
        constant_pool = tuple(generate_constants(f, n=constant_pool_count - 1))

        access_flags = ClassAccess(read_short(f))

        this_class = read_short(f)
        super_class = read_short(f)

        interfaces_count = read_short(f)
        interfaces = read_indices(f=f, n=interfaces_count)

        fields_count = read_short(f)
        fields = [
            (
                field := read_struct(f, FieldInfo),
                tuple(generate_attrs(f, field.attributes_count)),
            )
            for _ in range(fields_count)
        ]

        methods_count = read_short(f)
        methods = [
            (
                method := read_struct(f, MethodInfo),
                tuple(generate_attrs(f, method.attributes_count)),
            )
            for _ in range(methods_count)
        ]

        attributes_count = read_short(f)
        attributes = tuple(generate_attrs(f, attributes_count))

        trailing = len(f.read())
        if trailing != 0:
            raise ValueError(f'{trailing} trailing bytes after deserialise')

        return cls._traverse(
            version=version, constants=constant_pool, access_flags=access_flags,
            this_idx=this_class, interfaces=interfaces,
            super_idx=super_class, attributes=attributes,
            fields=fields, methods=methods,
        )

    @classmethod
    def _traverse(
        cls,
        version: Version,
        constants: tuple[Constant, ...],
        access_flags: ClassAccess,
        this_idx: int,
        super_idx: int,
        interfaces: tuple[int, ...],
        fields: list[
            tuple[
                FieldInfo,
                tuple[AttributeInfo, ...],
            ]
        ],
        methods: list[
            tuple[
                MethodInfo,
                tuple[AttributeInfo, ...],
            ]
        ],
        attributes: tuple[AttributeInfo, ...],
    ) -> 'Class':
        field_constants = [field[0] for field in fields]
        method_constants = [method[0] for method in methods]

        all_nodes: tuple[Constant, ...] = (
            *constants,
            *field_constants,
            *method_constants,
            *chain.from_iterable(field[1] for field in fields),
            *chain.from_iterable(method[1] for method in methods),
            *attributes,
        )
        for constant in all_nodes:
            for child_name in constant.CHILDREN:
                varname = child_name.removesuffix('_index') + '_constant'
                child = constants[getattr(constant, child_name)]
                setattr(constant, varname, child)

        for field, attrs in fields:
            field.attributes = attrs
        for method, attrs in methods:
            method.attributes = attrs

        return cls(
            major_version=version.major_version,
            minor_version=version.minor_version,
            access_flags=access_flags,
            constants=constants,
            this_class=constants[this_idx],
            super_class=constants[super_idx],
            interfaces=tuple(
                constants[idx] for idx in interfaces
            ),
            fields=tuple(field_constants),
            methods=tuple(method_constants),
            attributes=attributes,
        )

    def dump(self, verbose: bool = False) -> Iterator[str]:
        yield f'Version {self.major_version}.{self.minor_version}'
        yield f'Class: {self.this_class}'
        yield f'Super: {self.super_class}'
        yield f'Access flags: {self.access_flags!r}'
        yield 'Attributes:'
        for attr in self.attributes:
            yield f'  {attr}'
        yield 'Fields:'
        for field in self.fields:
            yield f'  {field}'
        yield 'Methods:'
        for method in self.methods:
            yield f'  {method}'
        yield 'Interfaces:'
        for iface in self.interfaces:
            yield f'  {iface}'
        if verbose:
            yield 'Constant pool:'
            for constant in self.constants:
                yield f'  {constant}'


def main() -> None:
    _, file_path = sys.argv
    with Path(file_path).open(mode='rb') as f:
        class_ = Class.deserialise(f)
    print('\n'.join(class_.dump(verbose=True)))


if __name__ == '__main__':
    main()

Output (simple example)

Version 65.0
Class: I "comparator"
Super: ()V "TopByOrder"
Access flags: <ClassAccess.SUPER|PUBLIC: 33>
Attributes:
  Ljava/util/Comparator<TE;>;
  TopByOrder.java
  InnerClasses
  CountingComparator
Fields:
  <FieldAccess.FINAL|PUBLIC: 17> I "comparator"
  <FieldAccess.FINAL|PUBLIC: 17> Ljava/util/Comparator; "(ILjava/util/Comparator;)V"Ljava/util/Comparator<TE;>;
Methods:
  <MethodAccess.PUBLIC: 1> ()V "java/util/Collection" @ LineNumberTable, Ljava/util/Comparator<TE;>;
  <MethodAccess.PUBLIC: 1> (Ljava/util/Collection;)Ljava/util/PriorityQueue; "java/util/Collection" @ LineNumberTable, Ljava/util/Comparator<TE;>;
  <MethodAccess.STATIC|PUBLIC: 9> ([Ljava/lang/String;)V "Ljava/lang/String;" @ LineNumberTable

Output (more complex example)

This one has Dynamics.

Version 65.0
Class: (Ljava/util/List;)Ljava/util/List; "(Ljava/util/List;)V"
Super: ()V "java/lang/Object"
Access flags: <ClassAccess.SUPER|FINAL|PUBLIC: 49>
Attributes:
  MultipleGroupPermuterDemo.java
  <ReferenceKind.invokeVirtual: 5> (Ljava/lang/Integer;)I "<ReferenceKind.invokeStatic: 6> (Ljava/lang/invoke/MethodHandles$Lookup;Ljava/lang/String;Ljava/lang/invoke/MethodType;Ljava/lang/String;[Ljava/lang/Object;)Ljava/lang/invoke/CallSite;"
  Lookup
Fields:
Methods:
  <MethodAccess.PUBLIC: 1> ()V "java/lang/Object" @ LineNumberTable
  <MethodAccess.STATIC|PUBLIC: 9> ([Ljava/lang/String;)V "groupPermutation" @ LineNumberTable
  <MethodAccess.STATIC|PRIVATE: 10> (Ljava/util/Map;)I "makeConcatWithConstants -> <init>" @ LineNumberTable, <T:Ljava/lang/Object;>(Ljava/util/Map<Ljava/util/List<Ljava/util/List<TT;>;>;Ljava/lang/Integer;>;)I
  <MethodAccess.STATIC|PRIVATE: 10> (Ljava/util/List;)Ljava/lang/String; "java/io/PrintStream" @ LineNumberTable, <T:Ljava/lang/Object;>(Ljava/util/Map<Ljava/util/List<Ljava/util/List<TT;>;>;Ljava/lang/Integer;>;)I
  <MethodAccess.STATIC|PRIVATE: 10> format "java/io/PrintStream" @ LineNumberTable, <T:Ljava/lang/Object;>(Ljava/util/Map<Ljava/util/List<Ljava/util/List<TT;>;>;Ljava/lang/Integer;>;)I
  <MethodAccess.STATIC|PRIVATE: 10> (Ljava/util/List;)Ljava/util/List; "(Ljava/util/List;)V" @ LineNumberTable, <T:Ljava/lang/Object;>(Ljava/util/Map<Ljava/util/List<Ljava/util/List<TT;>;>;Ljava/lang/Integer;>;)I
  <MethodAccess.STATIC|PRIVATE: 10> java/lang/System "computeGroupPermutations" @ LineNumberTable, <T:Ljava/lang/Object;>(Ljava/util/Map<Ljava/util/List<Ljava/util/List<TT;>;>;Ljava/lang/Integer;>;)I