pyflashkit 1.0.0__py3-none-any.whl

flashkit/abc/parser.py

@@ -0,0 +1,434 @@
+"""
+ABC bytecode parser and LEB128 codec.
+
+Parses raw ABC (ActionScript Byte Code) binary data into an ``AbcFile``
+structure. Also provides the LEB128 variable-length integer encoding
+functions used throughout AVM2 bytecode.
+
+Usage::
+
+    from flashkit.abc.parser import parse_abc
+    abc = parse_abc(raw_bytes)
+    print(f"Classes: {len(abc.instances)}")
+    print(f"Strings: {len(abc.string_pool)}")
+
+The LEB128 functions (``read_u30``, ``write_u30``, etc.) are also public
+and useful for manual bytecode manipulation.
+
+Reference: Adobe AVM2 Overview, Chapter 4 (abc file format).
+"""
+
+from __future__ import annotations
+
+import struct
+
+from ..errors import ABCParseError
+from .types import (
+    AbcFile, NamespaceInfo, NsSetInfo, MultinameInfo,
+    MethodInfo, MetadataInfo, TraitInfo, InstanceInfo,
+    ClassInfo, ScriptInfo, ExceptionInfo, MethodBodyInfo,
+)
+from .constants import (
+    CONSTANT_QName, CONSTANT_QNameA,
+    CONSTANT_RTQName, CONSTANT_RTQNameA,
+    CONSTANT_RTQNameL, CONSTANT_RTQNameLA,
+    CONSTANT_Multiname, CONSTANT_MultinameA,
+    CONSTANT_MultinameL, CONSTANT_MultinameLA,
+    CONSTANT_TypeName,
+    TRAIT_Slot, TRAIT_Const, TRAIT_Method, TRAIT_Getter, TRAIT_Setter,
+    TRAIT_Class, TRAIT_Function,
+    ATTR_Metadata,
+    METHOD_HasOptional, METHOD_HasParamNames,
+    INSTANCE_ProtectedNs,
+)
+
+
+# ── LEB128 encoding/decoding ───────────────────────────────────────────────
+
+def read_u30(data: bytes, offset: int) -> tuple[int, int]:
+    """Read a u30 (unsigned LEB128, max 30 bits).
+
+    Returns:
+        Tuple of (value, new_offset).
+    """
+    result = 0
+    shift = 0
+    for _ in range(5):
+        b = data[offset]
+        offset += 1
+        result |= (b & 0x7F) << shift
+        if (b & 0x80) == 0:
+            break
+        shift += 7
+    return result, offset
+
+
+def read_s32(data: bytes, offset: int) -> tuple[int, int]:
+    """Read an s32 (signed LEB128).
+
+    Returns:
+        Tuple of (value, new_offset).
+    """
+    result = 0
+    shift = 0
+    for _ in range(5):
+        b = data[offset]
+        offset += 1
+        result |= (b & 0x7F) << shift
+        shift += 7
+        if (b & 0x80) == 0:
+            break
+    # Sign extend
+    if shift < 32 and (b & 0x40):
+        result |= -(1 << shift)
+    return result, offset
+
+
+def write_u30(value: int) -> bytes:
+    """Encode a u30 value as unsigned LEB128 bytes."""
+    value &= 0x3FFFFFFF  # 30-bit unsigned
+    result = bytearray()
+    while True:
+        byte = value & 0x7F
+        value >>= 7
+        if value:
+            byte |= 0x80
+        result.append(byte)
+        if not value:
+            break
+    return bytes(result)
+
+
+def write_s32(value: int) -> bytes:
+    """Encode an s32 value as signed LEB128 bytes."""
+    result = bytearray()
+    more = True
+    while more:
+        byte = value & 0x7F
+        value >>= 7
+        if (value == 0 and (byte & 0x40) == 0) or (value == -1 and (byte & 0x40)):
+            more = False
+        else:
+            byte |= 0x80
+        result.append(byte)
+    return bytes(result)
+
+
+def s24(value: int) -> bytes:
+    """Encode a signed 24-bit offset (little-endian).
+
+    Used for branch instruction offsets in AVM2 bytecode.
+    """
+    if value < 0:
+        value = value + (1 << 24)
+    return bytes([value & 0xFF, (value >> 8) & 0xFF, (value >> 16) & 0xFF])
+
+
+def read_u8(data: bytes, offset: int) -> tuple[int, int]:
+    """Read a single unsigned byte."""
+    return data[offset], offset + 1
+
+
+def read_u16(data: bytes, offset: int) -> tuple[int, int]:
+    """Read a 16-bit unsigned integer (little-endian)."""
+    return struct.unpack_from("<H", data, offset)[0], offset + 2
+
+
+def read_u32(data: bytes, offset: int) -> tuple[int, int]:
+    """Read a 32-bit unsigned integer (little-endian)."""
+    return struct.unpack_from("<I", data, offset)[0], offset + 4
+
+
+def read_d64(data: bytes, offset: int) -> tuple[float, int]:
+    """Read a 64-bit IEEE 754 double (little-endian)."""
+    return struct.unpack_from("<d", data, offset)[0], offset + 8
+
+
+# ── Internal helpers ────────────────────────────────────────────────────────
+
+def _read_traits(data: bytes, offset: int) -> tuple[list[TraitInfo], int]:
+    """Read a traits_info array.
+
+    Returns:
+        Tuple of (list of TraitInfo, new_offset).
+    """
+    count, offset = read_u30(data, offset)
+    traits = []
+    for _ in range(count):
+        start = offset
+        name, offset = read_u30(data, offset)
+        kind_byte, offset = read_u8(data, offset)
+        kind = kind_byte & 0x0F
+        attr = (kind_byte >> 4) & 0x0F
+
+        if kind in (TRAIT_Slot, TRAIT_Const):
+            _slot_id, offset = read_u30(data, offset)
+            _type_name, offset = read_u30(data, offset)
+            vindex, offset = read_u30(data, offset)
+            if vindex:
+                _vkind, offset = read_u8(data, offset)
+        elif kind in (TRAIT_Method, TRAIT_Getter, TRAIT_Setter):
+            _disp_id, offset = read_u30(data, offset)
+            _method_idx, offset = read_u30(data, offset)
+        elif kind == TRAIT_Class:
+            _slot_id, offset = read_u30(data, offset)
+            _class_idx, offset = read_u30(data, offset)
+        elif kind == TRAIT_Function:
+            _slot_id, offset = read_u30(data, offset)
+            _func_idx, offset = read_u30(data, offset)
+
+        if attr & ATTR_Metadata:
+            md_count, offset = read_u30(data, offset)
+            for _ in range(md_count):
+                _, offset = read_u30(data, offset)
+
+        raw = data[start:offset]
+        traits.append(TraitInfo(name=name, kind=kind, data=raw))
+
+    return traits, offset
+
+
+# ── Main parser ─────────────────────────────────────────────────────────────
+
+def parse_abc(data: bytes) -> AbcFile:
+    """Parse raw ABC bytecode into an AbcFile structure.
+
+    This is the primary entry point for loading ABC data. The returned
+    ``AbcFile`` can be inspected, modified, and serialized back to bytes
+    with ``flashkit.abc.writer.serialize_abc()``.
+
+    Args:
+        data: Raw ABC bytecode bytes.
+
+    Returns:
+        Parsed AbcFile with all constant pools, methods, classes, and bodies.
+
+    Raises:
+        ABCParseError: If the data is not valid ABC bytecode.
+    """
+    if not data:
+        raise ABCParseError("ABC data is empty")
+    if len(data) < 4:
+        raise ABCParseError(
+            f"ABC data too short ({len(data)} bytes, minimum 4)")
+
+    try:
+        return _parse_abc_inner(data)
+    except ABCParseError:
+        raise
+    except (IndexError, struct.error, ValueError, OverflowError) as e:
+        raise ABCParseError(f"Corrupted ABC data: {e}") from e
+
+
+def _parse_abc_inner(data: bytes) -> AbcFile:
+    """Internal ABC parser (no error wrapping)."""
+    abc = AbcFile()
+    off = 0
+
+    abc.minor_version, off = read_u16(data, off)
+    abc.major_version, off = read_u16(data, off)
+
+    # ── Constant pool ────────────────────────────────────────────────────
+
+    # Integers
+    count, off = read_u30(data, off)
+    abc.int_pool = [0]
+    abc._int_pool_raw = [b""]
+    for _ in range(max(0, count - 1)):
+        raw_start = off
+        val, off = read_s32(data, off)
+        abc.int_pool.append(val)
+        abc._int_pool_raw.append(data[raw_start:off])
+
+    # Unsigned integers
+    count, off = read_u30(data, off)
+    abc.uint_pool = [0]
+    abc._uint_pool_raw = [b""]
+    for _ in range(max(0, count - 1)):
+        raw_start = off
+        val, off = read_u30(data, off)
+        abc.uint_pool.append(val)
+        abc._uint_pool_raw.append(data[raw_start:off])
+
+    # Doubles
+    count, off = read_u30(data, off)
+    abc.double_pool = [0.0]
+    for _ in range(max(0, count - 1)):
+        val, off = read_d64(data, off)
+        abc.double_pool.append(val)
+
+    # Strings
+    count, off = read_u30(data, off)
+    abc.string_pool = [""]
+    for _ in range(max(0, count - 1)):
+        slen, off = read_u30(data, off)
+        s = data[off:off + slen].decode("utf-8", errors="replace")
+        off += slen
+        abc.string_pool.append(s)
+
+    # Namespaces
+    count, off = read_u30(data, off)
+    abc.namespace_pool = [NamespaceInfo(0, 0)]
+    for _ in range(max(0, count - 1)):
+        kind, off = read_u8(data, off)
+        name, off = read_u30(data, off)
+        abc.namespace_pool.append(NamespaceInfo(kind, name))
+
+    # Namespace sets
+    count, off = read_u30(data, off)
+    abc.ns_set_pool = [NsSetInfo([])]
+    for _ in range(max(0, count - 1)):
+        ns_count, off = read_u30(data, off)
+        nss = []
+        for __ in range(ns_count):
+            ns, off = read_u30(data, off)
+            nss.append(ns)
+        abc.ns_set_pool.append(NsSetInfo(nss))
+
+    # Multinames
+    count, off = read_u30(data, off)
+    abc.multiname_pool = [MultinameInfo(0)]
+    for _ in range(max(0, count - 1)):
+        kind, off = read_u8(data, off)
+        mn = MultinameInfo(kind=kind)
+        if kind in (CONSTANT_QName, CONSTANT_QNameA):
+            mn.ns, off = read_u30(data, off)
+            mn.name, off = read_u30(data, off)
+        elif kind in (CONSTANT_RTQName, CONSTANT_RTQNameA):
+            mn.name, off = read_u30(data, off)
+        elif kind in (CONSTANT_RTQNameL, CONSTANT_RTQNameLA):
+            pass
+        elif kind in (CONSTANT_Multiname, CONSTANT_MultinameA):
+            mn.name, off = read_u30(data, off)
+            mn.ns_set, off = read_u30(data, off)
+        elif kind in (CONSTANT_MultinameL, CONSTANT_MultinameLA):
+            mn.ns_set, off = read_u30(data, off)
+        elif kind == CONSTANT_TypeName:
+            mn.ns, off = read_u30(data, off)  # base type multiname index
+            param_count, off = read_u30(data, off)
+            params = []
+            for __ in range(param_count):
+                p, off = read_u30(data, off)
+                params.append(p)
+            # Store params as serialized u30 bytes for round-trip fidelity
+            param_bytes = bytearray()
+            for p in params:
+                param_bytes += write_u30(p)
+            mn.data = bytes(param_bytes)
+            mn.name = param_count  # stash param count in name field
+        else:
+            raise ABCParseError(
+                f"Unknown multiname kind: 0x{kind:02X} at offset {off}")
+        abc.multiname_pool.append(mn)
+
+    # ── Methods ──────────────────────────────────────────────────────────
+
+    count, off = read_u30(data, off)
+    for _ in range(count):
+        param_count, off = read_u30(data, off)
+        return_type, off = read_u30(data, off)
+        param_types = []
+        for __ in range(param_count):
+            pt, off = read_u30(data, off)
+            param_types.append(pt)
+        name, off = read_u30(data, off)
+        flags, off = read_u8(data, off)
+
+        mi = MethodInfo(
+            param_count=param_count, return_type=return_type,
+            param_types=param_types, name=name, flags=flags)
+
+        if flags & METHOD_HasOptional:
+            opt_count, off = read_u30(data, off)
+            for __ in range(opt_count):
+                val, off = read_u30(data, off)
+                vkind, off = read_u8(data, off)
+                mi.options.append((val, vkind))
+
+        if flags & METHOD_HasParamNames:
+            for __ in range(param_count):
+                pn, off = read_u30(data, off)
+                mi.param_names.append(pn)
+
+        abc.methods.append(mi)
+
+    # ── Metadata ─────────────────────────────────────────────────────────
+
+    count, off = read_u30(data, off)
+    for _ in range(count):
+        name, off = read_u30(data, off)
+        item_count, off = read_u30(data, off)
+        items = []
+        for __ in range(item_count):
+            k, off = read_u30(data, off)
+            v, off = read_u30(data, off)
+            items.append((k, v))
+        abc.metadata.append(MetadataInfo(name=name, items=items))
+
+    # ── Instances + Classes ──────────────────────────────────────────────
+
+    count, off = read_u30(data, off)
+    for _ in range(count):
+        inst = InstanceInfo(name=0, super_name=0, flags=0)
+        inst.name, off = read_u30(data, off)
+        inst.super_name, off = read_u30(data, off)
+        inst.flags, off = read_u8(data, off)
+
+        if inst.flags & INSTANCE_ProtectedNs:
+            inst.protectedNs, off = read_u30(data, off)
+
+        iface_count, off = read_u30(data, off)
+        for __ in range(iface_count):
+            ifc, off = read_u30(data, off)
+            inst.interfaces.append(ifc)
+
+        inst.iinit, off = read_u30(data, off)
+        inst.traits, off = _read_traits(data, off)
+        abc.instances.append(inst)
+
+    for _ in range(count):
+        ci = ClassInfo(cinit=0)
+        ci.cinit, off = read_u30(data, off)
+        ci.traits, off = _read_traits(data, off)
+        abc.classes.append(ci)
+
+    # ── Scripts ──────────────────────────────────────────────────────────
+
+    count, off = read_u30(data, off)
+    for _ in range(count):
+        si = ScriptInfo(init=0)
+        si.init, off = read_u30(data, off)
+        si.traits, off = _read_traits(data, off)
+        abc.scripts.append(si)
+
+    # ── Method bodies ────────────────────────────────────────────────────
+
+    count, off = read_u30(data, off)
+    for _ in range(count):
+        mb = MethodBodyInfo(
+            method=0, max_stack=0, local_count=0,
+            init_scope_depth=0, max_scope_depth=0, code=b"")
+        mb.method, off = read_u30(data, off)
+        mb.max_stack, off = read_u30(data, off)
+        mb.local_count, off = read_u30(data, off)
+        mb.init_scope_depth, off = read_u30(data, off)
+        mb.max_scope_depth, off = read_u30(data, off)
+        code_len, off = read_u30(data, off)
+        mb.code = data[off:off + code_len]
+        off += code_len
+
+        # Exceptions
+        exc_count, off = read_u30(data, off)
+        for __ in range(exc_count):
+            ei = ExceptionInfo(0, 0, 0, 0, 0)
+            ei.from_offset, off = read_u30(data, off)
+            ei.to_offset, off = read_u30(data, off)
+            ei.target, off = read_u30(data, off)
+            ei.exc_type, off = read_u30(data, off)
+            ei.var_name, off = read_u30(data, off)
+            mb.exceptions.append(ei)
+
+        mb.traits, off = _read_traits(data, off)
+        abc.method_bodies.append(mb)
+
+    return abc

flashkit/abc/types.py

@@ -0,0 +1,275 @@
+"""
+AVM2 bytecode data structures.
+
+These dataclasses mirror the structures defined in the AVM2 specification
+(avm2overview.pdf). They represent the parsed contents of an ABC (ActionScript
+Byte Code) block as found inside SWF DoABC/DoABC2 tags.
+
+All pool indices (string, namespace, multiname, method) are zero-based.
+Index 0 in each pool is the implicit default entry and is always present.
+
+Reference: Adobe AVM2 Overview, Chapter 4 (abc file format).
+"""
+
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+
+
+@dataclass
+class NamespaceInfo:
+    """A namespace entry in the constant pool.
+
+    Attributes:
+        kind: Namespace kind constant (CONSTANT_Namespace, CONSTANT_PackageNamespace, etc.).
+        name: Index into the string pool for the namespace name.
+    """
+    kind: int
+    name: int
+
+
+@dataclass
+class NsSetInfo:
+    """A namespace set — an unordered collection of namespaces.
+
+    Used by Multiname and MultinameL to search across multiple namespaces.
+
+    Attributes:
+        namespaces: List of indices into the namespace pool.
+    """
+    namespaces: list[int]
+
+
+@dataclass
+class MultinameInfo:
+    """A multiname entry in the constant pool.
+
+    Multinames are the primary name-resolution mechanism in AVM2. The
+    interpretation of fields depends on ``kind``:
+
+    - QName/QNameA: ``ns`` = namespace index, ``name`` = string index.
+    - RTQName/RTQNameA: ``name`` = string index (namespace from runtime stack).
+    - RTQNameL/RTQNameLA: no fields (both name and namespace from stack).
+    - Multiname/MultinameA: ``name`` = string index, ``ns_set`` = ns-set index.
+    - MultinameL/MultinameLA: ``ns_set`` = ns-set index (name from stack).
+    - TypeName: ``ns`` = base type multiname index (repurposed field),
+      ``name`` = parameter count (repurposed), ``data`` = serialized
+      parameter multiname indices as u30 bytes. This encoding is intentional
+      for round-trip fidelity — a future version may add dedicated fields.
+
+    Attributes:
+        kind: Multiname kind constant (CONSTANT_QName, etc.).
+        data: Raw serialized parameter bytes (TypeName only).
+        ns:   Namespace index, or base type index for TypeName.
+        name: String index, or parameter count for TypeName.
+        ns_set: Namespace set index.
+    """
+    kind: int
+    data: bytes = b""
+    ns: int = 0
+    name: int = 0
+    ns_set: int = 0
+
+
+@dataclass
+class MethodInfo:
+    """A method signature (not the body — see MethodBodyInfo).
+
+    Attributes:
+        param_count: Number of formal parameters.
+        return_type: Multiname index of the return type (0 = any/void).
+        param_types: List of multiname indices for each parameter type.
+        name: String index for the method name (0 = anonymous).
+        flags: Bitmask — 0x08 = HAS_OPTIONAL, 0x80 = HAS_PARAM_NAMES, etc.
+        options: Default parameter values as (value_index, value_kind) pairs.
+        param_names: String indices for parameter names (debug info).
+    """
+    param_count: int
+    return_type: int
+    param_types: list[int]
+    name: int
+    flags: int
+    options: list[tuple] = field(default_factory=list)
+    param_names: list[int] = field(default_factory=list)
+
+
+@dataclass
+class MetadataInfo:
+    """Metadata attached to traits (e.g. [SWF(width=800)]).
+
+    Attributes:
+        name: String index for the metadata tag name.
+        items: List of (key_string_index, value_string_index) pairs.
+    """
+    name: int
+    items: list[tuple]
+
+
+@dataclass
+class TraitInfo:
+    """A trait (field, method, getter, setter, class, or const) on a class or script.
+
+    Traits are stored with their raw binary data to guarantee perfect
+    round-trip serialization. The ``name`` and ``kind`` fields are parsed
+    for easy inspection, but the full trait data (including slot IDs,
+    type references, method indices, and metadata) is in ``data``.
+
+    To inspect trait contents beyond name/kind, use the trait resolution
+    utilities in ``flashkit.info``.
+
+    Attributes:
+        name: Multiname index for the trait name.
+        kind: Trait kind (TRAIT_Slot, TRAIT_Method, TRAIT_Getter, etc.).
+        data: Complete raw binary of this trait entry (includes name and kind bytes).
+    """
+    name: int
+    kind: int
+    data: bytes
+
+
+@dataclass
+class InstanceInfo:
+    """An instance (non-static side) of a class definition.
+
+    Each InstanceInfo is paired with a ClassInfo at the same array index.
+
+    Attributes:
+        name: Multiname index for the class name.
+        super_name: Multiname index for the superclass (0 = Object).
+        flags: Bitmask — 0x01 = sealed, 0x02 = final, 0x04 = interface,
+               0x08 = has protected namespace.
+        protectedNs: Namespace index for the protected namespace (if flag 0x08 set).
+        interfaces: List of multiname indices for implemented interfaces.
+        iinit: Method index for the instance initializer (constructor).
+        traits: Instance traits (fields, methods, getters, setters).
+    """
+    name: int
+    super_name: int
+    flags: int
+    protectedNs: int = 0
+    interfaces: list[int] = field(default_factory=list)
+    iinit: int = 0
+    traits: list[TraitInfo] = field(default_factory=list)
+
+
+@dataclass
+class ClassInfo:
+    """The static side of a class definition.
+
+    Paired with InstanceInfo at the same array index.
+
+    Attributes:
+        cinit: Method index for the static initializer.
+        traits: Static traits (static fields, static methods).
+    """
+    cinit: int
+    traits: list[TraitInfo] = field(default_factory=list)
+
+
+@dataclass
+class ScriptInfo:
+    """A script entry point.
+
+    Each ABC file has one or more scripts. The last script is the entry point.
+
+    Attributes:
+        init: Method index for the script initializer.
+        traits: Script-level traits (top-level classes, functions, variables).
+    """
+    init: int
+    traits: list[TraitInfo] = field(default_factory=list)
+
+
+@dataclass
+class ExceptionInfo:
+    """An exception handler within a method body.
+
+    Attributes:
+        from_offset: Bytecode offset where the try block starts.
+        to_offset: Bytecode offset where the try block ends.
+        target: Bytecode offset of the catch handler.
+        exc_type: Multiname index for the exception type (0 = catch-all).
+        var_name: Multiname index for the catch variable name.
+    """
+    from_offset: int
+    to_offset: int
+    target: int
+    exc_type: int
+    var_name: int
+
+
+@dataclass
+class MethodBodyInfo:
+    """The bytecode body of a method.
+
+    Attributes:
+        method: Index into the method array this body belongs to.
+        max_stack: Maximum operand stack depth.
+        local_count: Number of local registers (including 'this' at register 0).
+        init_scope_depth: Initial scope stack depth.
+        max_scope_depth: Maximum scope stack depth.
+        code: Raw AVM2 bytecode bytes.
+        exceptions: Exception handler table.
+        traits: Activation traits (rare — used for method-level closures).
+    """
+    method: int
+    max_stack: int
+    local_count: int
+    init_scope_depth: int
+    max_scope_depth: int
+    code: bytes
+    exceptions: list[ExceptionInfo] = field(default_factory=list)
+    traits: list[TraitInfo] = field(default_factory=list)
+
+
+@dataclass
+class AbcFile:
+    """A complete ABC (ActionScript Byte Code) file.
+
+    Contains the constant pools, method signatures, class definitions,
+    scripts, and method bodies that make up one compilation unit.
+
+    Constant pools always have an implicit entry at index 0:
+    - int_pool[0] = 0
+    - uint_pool[0] = 0
+    - double_pool[0] = 0.0
+    - string_pool[0] = ""
+    - namespace_pool[0] = NamespaceInfo(0, 0)
+    - ns_set_pool[0] = NsSetInfo([])
+    - multiname_pool[0] = MultinameInfo(0)
+
+    Attributes:
+        minor_version: ABC minor version (typically 16).
+        major_version: ABC major version (typically 46).
+    """
+    minor_version: int = 16
+    major_version: int = 46
+
+    # Constant pools (index 0 is always the implicit default)
+    int_pool: list[int] = field(default_factory=lambda: [0])
+    uint_pool: list[int] = field(default_factory=lambda: [0])
+
+    # Raw LEB128 bytes for constant pool entries (for round-trip fidelity).
+    # The AVM2 spec allows non-minimal LEB128 encodings (e.g. -1 encoded
+    # as 4 bytes instead of 1) and uint values that exceed 30 bits.
+    # We preserve the original encoding so serialize_abc() produces
+    # byte-identical output.
+    # Index 0 is empty (the implicit default). Populated by parse_abc().
+    _int_pool_raw: list[bytes] = field(default_factory=lambda: [b""])
+    _uint_pool_raw: list[bytes] = field(default_factory=lambda: [b""])
+    double_pool: list[float] = field(default_factory=lambda: [0.0])
+    string_pool: list[str] = field(default_factory=lambda: [""])
+    namespace_pool: list[NamespaceInfo] = field(
+        default_factory=lambda: [NamespaceInfo(0, 0)])
+    ns_set_pool: list[NsSetInfo] = field(
+        default_factory=lambda: [NsSetInfo([])])
+    multiname_pool: list[MultinameInfo] = field(
+        default_factory=lambda: [MultinameInfo(0)])
+
+    # Definitions
+    methods: list[MethodInfo] = field(default_factory=list)
+    metadata: list[MetadataInfo] = field(default_factory=list)
+    instances: list[InstanceInfo] = field(default_factory=list)
+    classes: list[ClassInfo] = field(default_factory=list)
+    scripts: list[ScriptInfo] = field(default_factory=list)
+    method_bodies: list[MethodBodyInfo] = field(default_factory=list)