pytecode 0.0.1__tar.gz → 0.0.3__tar.gz

{pytecode-0.0.1/pytecode.egg-info → pytecode-0.0.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pytecode
-Version: 0.0.1
+Version: 0.0.3
 Summary: Python library for parsing, manipulating, and emitting JVM class files
 Author: Trenton Smith
 License-Expression: MIT
@@ -95,8 +95,8 @@ Use `recompute_frames=True` when an edit changes control flow or stack/local lay
 
 ```python
 from pytecode import JarFile
-from pytecode.constants import MethodAccessFlag
-from pytecode.model import ClassModel, MethodModel
+from pytecode.classfile.constants import MethodAccessFlag
+from pytecode.edit.model import ClassModel, MethodModel
 from pytecode.transforms import (
     class_named,
     method_is_public,
@@ -136,15 +136,15 @@ Top-level exports:
 Supported submodules:
 
 - `pytecode.transforms` for composable class, field, method, and code transforms.
-- `pytecode.labels` for label-aware bytecode editing helpers.
-- `pytecode.operands` for symbolic operand wrappers.
+- `pytecode.edit.labels` for label-aware bytecode editing helpers.
+- `pytecode.edit.operands` for symbolic operand wrappers.
 - `pytecode.analysis` for CFG construction, frame simulation, and recomputation helpers.
-- `pytecode.verify` for structural validation and diagnostics.
-- `pytecode.hierarchy` for type and override resolution helpers.
-- `pytecode.descriptors` for JVM descriptors and generic signatures.
-- `pytecode.constant_pool_builder` for deterministic constant-pool construction.
-- `pytecode.modified_utf8` for JVM Modified UTF-8 encoding and decoding.
-- `pytecode.debug_info` for explicit debug-info preservation and stripping policies.
+- `pytecode.analysis.verify` for structural validation and diagnostics.
+- `pytecode.analysis.hierarchy` for type and override resolution helpers.
+- `pytecode.classfile.descriptors` for JVM descriptors and generic signatures.
+- `pytecode.edit.constant_pool_builder` for deterministic constant-pool construction.
+- `pytecode.classfile.modified_utf8` for JVM Modified UTF-8 encoding and decoding.
+- `pytecode.edit.debug_info` for explicit debug-info preservation and stripping policies.
 
 ## Documentation
 
@@ -166,13 +166,13 @@ uv run ruff check .
 uv run ruff format --check .
 uv run basedpyright
 uv run pytest -q
-uv run python tools\generate_api_docs.py --check
+uv run python tools/generate_api_docs.py --check
 ```
 
 Generate local API reference HTML with:
 
 ```powershell
-uv run python tools\generate_api_docs.py
+uv run python tools/generate_api_docs.py
 ```
 
 Build source and wheel distributions locally:
@@ -181,11 +181,21 @@ Build source and wheel distributions locally:
 uv build
 ```
 
-The `oracle`-marked CFG tests lazily cache ASM 9.7.1 test jars under `.pytest_cache\pytecode-oracle` and also honor manually seeded jars in `tests\resources\oracle\lib`. If `java`, `javac`, or the ASM jars are unavailable, that suite skips without failing the rest of the test run.
+Profile isolated JAR-processing stages without `run.py`'s output overhead:
+
+```powershell
+uv run python tools/profile_jar_pipeline.py path/to/jar.jar
+uv run python tools/profile_jar_pipeline.py path/to/jar.jar --stages class-parse model-lift model-lower
+uv run python tools/profile_jar_pipeline.py path/to/dir/with/jars --stages model-lift model-lower --summary-json output/profiles/common-libs/summary.json
+```
+
+When making runtime-performance changes, prefer checking both a focused jar such as `225.jar` and the wider common-jar corpus so regressions and wins are not judged from a single artifact. A single jar defaults to all stages; directories and multi-jar runs default to `model-lift` and `model-lower`.
+
+The `oracle`-marked CFG tests lazily cache ASM 9.7.1 test jars under `.pytest_cache/pytecode-oracle` and also honor manually seeded jars in `tests/resources/oracle/lib`. If `java`, `javac`, or the ASM jars are unavailable, that suite skips without failing the rest of the test run.
 
 ## Release automation
 
-PyPI releases are published from GitHub Actions by pushing an immutable `v<version>` tag that matches `project.version` in `pyproject.toml`. The release workflow reruns validation on the tagged commit, builds both `sdist` and `wheel` with `uv build`, and publishes from the protected `pypi` environment via PyPI Trusted Publishing.
+PyPI releases are published from GitHub Actions by pushing an immutable `v<version>` tag that matches `project.version` in `pyproject.toml`. The same workflow can also be started manually for an existing tag by supplying a `tag` input. In both cases, the workflow checks out the tagged commit, reruns validation, builds both `sdist` and `wheel` with `uv build`, publishes from the protected `pypi` environment via PyPI Trusted Publishing, and then creates or updates a GitHub Release for the same tag with the built distributions attached.
 
 Release procedure:
 
@@ -195,7 +205,7 @@ uv run ruff check .
 uv run ruff format --check .
 uv run basedpyright
 uv run pytest -q
-uv run python tools\generate_api_docs.py --check
+uv run python tools/generate_api_docs.py --check
 
 git commit -am "Bump version to X.Y.Z"
 git push origin master
@@ -203,16 +213,16 @@ git tag vX.Y.Z
 git push origin vX.Y.Z
 ```
 
-The release workflow rejects tags that do not match `project.version`. Treat release tags as immutable: if a tag or published artifact is wrong, bump to a new version and publish a new tag instead of force-pushing the old one. If the workflow fails before the publish step because of environment approval or a transient PyPI issue, rerun the workflow for the same tag instead of moving the tag.
+The release workflow rejects tags that do not match `project.version`. Treat release tags as immutable: if a tag or published artifact is wrong, bump to a new version and publish a new tag instead of force-pushing the old one. For an existing tag, you can rerun the workflow directly or start it manually from Actions by providing the tag name. The workflow is safe to rerun for the same tag: PyPI uploads skip files that already exist, and the GitHub Release step updates the existing release assets in place if the release was already created.
 
 ## Repository utilities
 
-`run.py` is a manual smoke-test helper that parses a JAR file, writes pretty-printed parsed class structures under `<jar parent>\output\<jar stem>\parsed\`, and writes class-model-derived rewritten `.class` files plus copied resources under `<jar parent>\output\<jar stem>\rewritten\`.
+`run.py` is a manual smoke-test helper that parses a JAR file, writes pretty-printed parsed class structures under `<jar parent>/output/<jar stem>/parsed/`, and writes class-model-derived rewritten `.class` files plus copied resources under `<jar parent>/output/<jar stem>/rewritten/`.
 
 Example:
 
 ```powershell
-uv run python .\run.py .\path\to\input.jar
+uv run python ./run.py ./path/to/input.jar
 ```
 
 The script prints read, parse, lift, write, and rewrite timings plus class and resource counts to stdout.

{pytecode-0.0.1 → pytecode-0.0.3}/README.md

@@ -69,8 +69,8 @@ Use `recompute_frames=True` when an edit changes control flow or stack/local lay
 
 ```python
 from pytecode import JarFile
-from pytecode.constants import MethodAccessFlag
-from pytecode.model import ClassModel, MethodModel
+from pytecode.classfile.constants import MethodAccessFlag
+from pytecode.edit.model import ClassModel, MethodModel
 from pytecode.transforms import (
     class_named,
     method_is_public,
@@ -110,15 +110,15 @@ Top-level exports:
 Supported submodules:
 
 - `pytecode.transforms` for composable class, field, method, and code transforms.
-- `pytecode.labels` for label-aware bytecode editing helpers.
-- `pytecode.operands` for symbolic operand wrappers.
+- `pytecode.edit.labels` for label-aware bytecode editing helpers.
+- `pytecode.edit.operands` for symbolic operand wrappers.
 - `pytecode.analysis` for CFG construction, frame simulation, and recomputation helpers.
-- `pytecode.verify` for structural validation and diagnostics.
-- `pytecode.hierarchy` for type and override resolution helpers.
-- `pytecode.descriptors` for JVM descriptors and generic signatures.
-- `pytecode.constant_pool_builder` for deterministic constant-pool construction.
-- `pytecode.modified_utf8` for JVM Modified UTF-8 encoding and decoding.
-- `pytecode.debug_info` for explicit debug-info preservation and stripping policies.
+- `pytecode.analysis.verify` for structural validation and diagnostics.
+- `pytecode.analysis.hierarchy` for type and override resolution helpers.
+- `pytecode.classfile.descriptors` for JVM descriptors and generic signatures.
+- `pytecode.edit.constant_pool_builder` for deterministic constant-pool construction.
+- `pytecode.classfile.modified_utf8` for JVM Modified UTF-8 encoding and decoding.
+- `pytecode.edit.debug_info` for explicit debug-info preservation and stripping policies.
 
 ## Documentation
 
@@ -140,13 +140,13 @@ uv run ruff check .
 uv run ruff format --check .
 uv run basedpyright
 uv run pytest -q
-uv run python tools\generate_api_docs.py --check
+uv run python tools/generate_api_docs.py --check
 ```
 
 Generate local API reference HTML with:
 
 ```powershell
-uv run python tools\generate_api_docs.py
+uv run python tools/generate_api_docs.py
 ```
 
 Build source and wheel distributions locally:
@@ -155,11 +155,21 @@ Build source and wheel distributions locally:
 uv build
 ```
 
-The `oracle`-marked CFG tests lazily cache ASM 9.7.1 test jars under `.pytest_cache\pytecode-oracle` and also honor manually seeded jars in `tests\resources\oracle\lib`. If `java`, `javac`, or the ASM jars are unavailable, that suite skips without failing the rest of the test run.
+Profile isolated JAR-processing stages without `run.py`'s output overhead:
+
+```powershell
+uv run python tools/profile_jar_pipeline.py path/to/jar.jar
+uv run python tools/profile_jar_pipeline.py path/to/jar.jar --stages class-parse model-lift model-lower
+uv run python tools/profile_jar_pipeline.py path/to/dir/with/jars --stages model-lift model-lower --summary-json output/profiles/common-libs/summary.json
+```
+
+When making runtime-performance changes, prefer checking both a focused jar such as `225.jar` and the wider common-jar corpus so regressions and wins are not judged from a single artifact. A single jar defaults to all stages; directories and multi-jar runs default to `model-lift` and `model-lower`.
+
+The `oracle`-marked CFG tests lazily cache ASM 9.7.1 test jars under `.pytest_cache/pytecode-oracle` and also honor manually seeded jars in `tests/resources/oracle/lib`. If `java`, `javac`, or the ASM jars are unavailable, that suite skips without failing the rest of the test run.
 
 ## Release automation
 
-PyPI releases are published from GitHub Actions by pushing an immutable `v<version>` tag that matches `project.version` in `pyproject.toml`. The release workflow reruns validation on the tagged commit, builds both `sdist` and `wheel` with `uv build`, and publishes from the protected `pypi` environment via PyPI Trusted Publishing.
+PyPI releases are published from GitHub Actions by pushing an immutable `v<version>` tag that matches `project.version` in `pyproject.toml`. The same workflow can also be started manually for an existing tag by supplying a `tag` input. In both cases, the workflow checks out the tagged commit, reruns validation, builds both `sdist` and `wheel` with `uv build`, publishes from the protected `pypi` environment via PyPI Trusted Publishing, and then creates or updates a GitHub Release for the same tag with the built distributions attached.
 
 Release procedure:
 
@@ -169,7 +179,7 @@ uv run ruff check .
 uv run ruff format --check .
 uv run basedpyright
 uv run pytest -q
-uv run python tools\generate_api_docs.py --check
+uv run python tools/generate_api_docs.py --check
 
 git commit -am "Bump version to X.Y.Z"
 git push origin master
@@ -177,16 +187,16 @@ git tag vX.Y.Z
 git push origin vX.Y.Z
 ```
 
-The release workflow rejects tags that do not match `project.version`. Treat release tags as immutable: if a tag or published artifact is wrong, bump to a new version and publish a new tag instead of force-pushing the old one. If the workflow fails before the publish step because of environment approval or a transient PyPI issue, rerun the workflow for the same tag instead of moving the tag.
+The release workflow rejects tags that do not match `project.version`. Treat release tags as immutable: if a tag or published artifact is wrong, bump to a new version and publish a new tag instead of force-pushing the old one. For an existing tag, you can rerun the workflow directly or start it manually from Actions by providing the tag name. The workflow is safe to rerun for the same tag: PyPI uploads skip files that already exist, and the GitHub Release step updates the existing release assets in place if the release was already created.
 
 ## Repository utilities
 
-`run.py` is a manual smoke-test helper that parses a JAR file, writes pretty-printed parsed class structures under `<jar parent>\output\<jar stem>\parsed\`, and writes class-model-derived rewritten `.class` files plus copied resources under `<jar parent>\output\<jar stem>\rewritten\`.
+`run.py` is a manual smoke-test helper that parses a JAR file, writes pretty-printed parsed class structures under `<jar parent>/output/<jar stem>/parsed/`, and writes class-model-derived rewritten `.class` files plus copied resources under `<jar parent>/output/<jar stem>/rewritten/`.
 
 Example:
 
 ```powershell
-uv run python .\run.py .\path\to\input.jar
+uv run python ./run.py ./path/to/input.jar
 ```
 
 The script prints read, parse, lift, write, and rewrite timings plus class and resource counts to stdout.

{pytecode-0.0.1 → pytecode-0.0.3}/pyproject.toml

@@ -6,14 +6,14 @@ build-backend = "setuptools.build_meta"
 include-package-data = true
 
 [tool.setuptools.packages.find]
-include = ["pytecode"]
+include = ["pytecode*"]
 
 [tool.setuptools.package-data]
 pytecode = ["py.typed"]
 
 [project]
 name = "pytecode"
-version = "0.0.1"
+version = "0.0.3"
 description = "Python library for parsing, manipulating, and emitting JVM class files"
 readme = "README.md"
 authors = [{ name = "Trenton Smith" }]

{pytecode-0.0.1 → pytecode-0.0.3}/pytecode/__init__.py

@@ -11,12 +11,12 @@ Provides four top-level entry points:
 Additional submodules expose transforms, descriptors, analysis, hierarchy
 resolution, validation, operands, labels, debug-info helpers, and the
 underlying data types.  See ``pytecode.transforms``, ``pytecode.analysis``,
-``pytecode.verify``, and the other documented submodules for details.
+``pytecode.analysis.verify``, and the other documented submodules for details.
 """
 
-from .class_reader import ClassReader
-from .class_writer import ClassWriter
-from .jar import JarFile
-from .model import ClassModel
+from .archive import JarFile
+from .classfile.reader import ClassReader
+from .classfile.writer import ClassWriter
+from .edit.model import ClassModel
 
 __all__ = ["ClassModel", "ClassReader", "ClassWriter", "JarFile"]

pytecode-0.0.3/pytecode/_internal/__init__.py

@@ -0,0 +1 @@
+"""Internal implementation helpers for pytecode."""

pytecode-0.0.1/pytecode/analysis.py → pytecode-0.0.3/pytecode/analysis/__init__.py

@@ -27,7 +27,7 @@ from collections.abc import Sequence
 from dataclasses import dataclass
 from typing import TYPE_CHECKING
 
-from .attributes import (
+from ..classfile.attributes import (
     AppendFrameInfo,
     ChopFrameInfo,
     DoubleVariableInfo,
@@ -48,11 +48,11 @@ from .attributes import (
     UninitializedVariableInfo,
     VerificationTypeInfo,
 )
-from .constants import VerificationType
-from .descriptors import (
+from ..classfile.constants import VerificationType
+from ..classfile.descriptors import (
     ArrayType as DescArrayType,
 )
-from .descriptors import (
+from ..classfile.descriptors import (
     BaseType,
     FieldDescriptor,
     ObjectType,
@@ -60,15 +60,14 @@ from .descriptors import (
     parse_field_descriptor,
     parse_method_descriptor,
 )
-from .hierarchy import JAVA_LANG_OBJECT, common_superclass
-from .instructions import (
+from ..classfile.instructions import (
     ArrayType as InsnArrayType,
 )
-from .instructions import (
+from ..classfile.instructions import (
     InsnInfo,
     InsnInfoType,
 )
-from .labels import (
+from ..edit.labels import (
     BranchInsn,
     CodeItem,
     ExceptionHandler,
@@ -76,7 +75,7 @@ from .labels import (
     LookupSwitchInsn,
     TableSwitchInsn,
 )
-from .operands import (
+from ..edit.operands import (
     FieldInsn,
     IIncInsn,
     InterfaceMethodInsn,
@@ -95,11 +94,12 @@ from .operands import (
     TypeInsn,
     VarInsn,
 )
+from .hierarchy import JAVA_LANG_OBJECT, common_superclass
 
 if TYPE_CHECKING:
-    from .constant_pool_builder import ConstantPoolBuilder
+    from ..edit.constant_pool_builder import ConstantPoolBuilder
+    from ..edit.model import CodeModel, MethodModel
     from .hierarchy import ClassResolver
-    from .model import CodeModel, MethodModel
 
 # ===================================================================
 # Analysis errors
@@ -435,7 +435,7 @@ def initial_frame(method: MethodModel, class_name: str) -> FrameState:
     Returns:
         A ``FrameState`` representing the method entry point.
     """
-    from .constants import MethodAccessFlag
+    from ..classfile.constants import MethodAccessFlag
 
     md = parse_method_descriptor(method.descriptor)
     locals_list: list[VType] = []
@@ -1936,7 +1936,7 @@ def _simulate_raw_insn(insn: InsnInfo, state: FrameState) -> FrameState:
     # --- NEWARRAY ---
     if opcode == _T.NEWARRAY:
         state, _ = state.pop(1)  # pop count
-        from .instructions import NewArray as NewArrayInsn
+        from ..classfile.instructions import NewArray as NewArrayInsn
 
         if isinstance(insn, NewArrayInsn):
             array_desc = _NEWARRAY_TYPE_MAP.get(insn.atype, "[I")
@@ -2279,7 +2279,7 @@ def compute_frames(
     analysis_code = _prepare_analysis_code(code)
     analysis_label_offsets = label_offsets
     if analysis_code is not code:
-        from .labels import resolve_labels
+        from ..edit.labels import resolve_labels
 
         analysis_label_offsets = resolve_labels(list(analysis_code.instructions), cp).label_offsets
 

{pytecode-0.0.1/pytecode → pytecode-0.0.3/pytecode/analysis}/hierarchy.py

@@ -13,13 +13,13 @@ from collections.abc import Iterable, Iterator
 from dataclasses import dataclass
 from typing import TYPE_CHECKING, Protocol
 
-from .constant_pool import ClassInfo
-from .constant_pool_builder import ConstantPoolBuilder
-from .constants import ClassAccessFlag, MethodAccessFlag
-from .info import ClassFile
+from ..classfile.constant_pool import ClassInfo
+from ..classfile.constants import ClassAccessFlag, MethodAccessFlag
+from ..classfile.info import ClassFile
+from ..edit.constant_pool_builder import ConstantPoolBuilder
 
 if TYPE_CHECKING:
-    from .model import ClassModel
+    from ..edit.model import ClassModel
 
 JAVA_LANG_OBJECT = "java/lang/Object"
 
@@ -494,7 +494,7 @@ def _resolve_class_name(cp: ConstantPoolBuilder, index: int) -> str:
         ValueError: If the entry at *index* is not a ``ClassInfo``.
     """
 
-    entry = cp.get(index)
+    entry = cp.peek(index)
     if not isinstance(entry, ClassInfo):
         raise ValueError(f"CP index {index} is not a CONSTANT_Class: {type(entry).__name__}")
     return cp.resolve_utf8(entry.name_index)

{pytecode-0.0.1/pytecode → pytecode-0.0.3/pytecode/analysis}/verify.py

@@ -15,7 +15,7 @@ from __future__ import annotations
 from dataclasses import dataclass, field
 from enum import Enum
 
-from .attributes import (
+from ..classfile.attributes import (
     AnnotationDefaultAttr,
     AttributeInfo,
     BootstrapMethodsAttr,
@@ -41,7 +41,7 @@ from .attributes import (
     SourceDebugExtensionAttr,
     StackMapTableAttr,
 )
-from .constant_pool import (
+from ..classfile.constant_pool import (
     ClassInfo,
     ConstantPoolInfo,
     DoubleInfo,
@@ -61,11 +61,10 @@ from .constant_pool import (
     StringInfo,
     Utf8Info,
 )
-from .constants import MAGIC, ClassAccessFlag, FieldAccessFlag, MethodAccessFlag
-from .debug_info import is_class_debug_info_stale, is_code_debug_info_stale
-from .descriptors import is_valid_field_descriptor, is_valid_method_descriptor
-from .info import ClassFile, FieldInfo, MethodInfo
-from .instructions import (
+from ..classfile.constants import MAGIC, ClassAccessFlag, FieldAccessFlag, MethodAccessFlag
+from ..classfile.descriptors import is_valid_field_descriptor, is_valid_method_descriptor
+from ..classfile.info import ClassFile, FieldInfo, MethodInfo
+from ..classfile.instructions import (
     Branch,
     BranchW,
     ConstPoolIndex,
@@ -77,14 +76,15 @@ from .instructions import (
     MultiANewArray,
     TableSwitch,
 )
-from .labels import (
+from ..classfile.modified_utf8 import decode_modified_utf8
+from ..edit.debug_info import is_class_debug_info_stale, is_code_debug_info_stale
+from ..edit.labels import (
     BranchInsn,
     Label,
     LookupSwitchInsn,
     TableSwitchInsn,
 )
-from .model import ClassModel, CodeModel, FieldModel, MethodModel
-from .modified_utf8 import decode_modified_utf8
+from ..edit.model import ClassModel, CodeModel, FieldModel, MethodModel
 
 __all__ = [
     "Category",
@@ -1000,110 +1000,123 @@ def _verify_code_cp_refs(
         )
 
         if isinstance(insn, ConstPoolIndex):
-            entry = _cp_entry(cp, insn.index)
-            if entry is None:
+            cp_entry = _cp_entry(cp, insn.index)
+            if cp_entry is None:
                 dc.add(Severity.ERROR, Category.CODE, f"{insn.type.name} references invalid CP index {insn.index}", loc)
                 continue
+            cp_entry_type = type(cp_entry)
 
             if insn.type in _FIELD_OPS:
-                if not isinstance(entry, FieldrefInfo):
+                if not isinstance(cp_entry, FieldrefInfo):
                     dc.add(
                         Severity.ERROR,
                         Category.CODE,
-                        f"{insn.type.name} CP#{insn.index} expected FieldrefInfo, got {type(entry).__name__}",
+                        f"{insn.type.name} CP#{insn.index} expected FieldrefInfo, got {cp_entry_type.__name__}",
                         loc,
                     )
             elif insn.type in _METHOD_OPS:
                 if major >= 52:
-                    if not isinstance(entry, (MethodrefInfo, InterfaceMethodrefInfo)):
+                    if not isinstance(cp_entry, (MethodrefInfo, InterfaceMethodrefInfo)):
                         msg = (
                             f"{insn.type.name} CP#{insn.index} expected "
-                            f"Methodref/InterfaceMethodref, got {type(entry).__name__}"
+                            f"Methodref/InterfaceMethodref, got {cp_entry_type.__name__}"
                         )
                         dc.add(Severity.ERROR, Category.CODE, msg, loc)
-                elif not isinstance(entry, MethodrefInfo):
+                elif not isinstance(cp_entry, MethodrefInfo):
                     dc.add(
                         Severity.ERROR,
                         Category.CODE,
-                        f"{insn.type.name} CP#{insn.index} expected MethodrefInfo, got {type(entry).__name__}",
+                        f"{insn.type.name} CP#{insn.index} expected MethodrefInfo, got {cp_entry_type.__name__}",
                         loc,
                     )
             elif insn.type in _CLASS_OPS:
-                if not isinstance(entry, ClassInfo):
+                if not isinstance(cp_entry, ClassInfo):
                     dc.add(
                         Severity.ERROR,
                         Category.CODE,
-                        f"{insn.type.name} CP#{insn.index} expected ClassInfo, got {type(entry).__name__}",
+                        f"{insn.type.name} CP#{insn.index} expected ClassInfo, got {cp_entry_type.__name__}",
                         loc,
                     )
             elif insn.type == InsnInfoType.LDC_W:
-                _verify_ldc_entry(entry, insn.index, major, loc, dc)
+                _verify_ldc_entry(cp_entry, insn.index, major, loc, dc)
             elif insn.type == InsnInfoType.LDC2_W:
-                if not isinstance(entry, (LongInfo, DoubleInfo)):
+                if not isinstance(cp_entry, (LongInfo, DoubleInfo)):
                     dc.add(
                         Severity.ERROR,
                         Category.CODE,
-                        f"LDC2_W CP#{insn.index} expected Long/Double, got {type(entry).__name__}",
+                        f"LDC2_W CP#{insn.index} expected Long/Double, got {cp_entry_type.__name__}",
                         loc,
                     )
 
         elif isinstance(insn, LocalIndex) and insn.type == InsnInfoType.LDC:
-            entry = _cp_entry(cp, insn.index)
-            if entry is None:
+            ldc_entry = _cp_entry(cp, insn.index)
+            if ldc_entry is None:
                 dc.add(Severity.ERROR, Category.CODE, f"LDC references invalid CP index {insn.index}", loc)
             else:
-                _verify_ldc_entry(entry, insn.index, major, loc, dc)
+                _verify_ldc_entry(ldc_entry, insn.index, major, loc, dc)
 
         elif isinstance(insn, InvokeInterface):
-            entry = _cp_entry(cp, insn.index)
-            if entry is None:
+            invoke_interface_entry = _cp_entry(cp, insn.index)
+            if invoke_interface_entry is None:
                 dc.add(
                     Severity.ERROR,
                     Category.CODE,
                     f"INVOKEINTERFACE references invalid CP index {insn.index}",
                     loc,
                 )
-            elif not isinstance(entry, InterfaceMethodrefInfo):
+            else:
+                invoke_interface_entry_type = type(invoke_interface_entry)
+                if isinstance(invoke_interface_entry, InterfaceMethodrefInfo):
+                    continue
                 dc.add(
                     Severity.ERROR,
                     Category.CODE,
-                    f"INVOKEINTERFACE CP#{insn.index} expected InterfaceMethodrefInfo, got {type(entry).__name__}",
+                    "INVOKEINTERFACE "
+                    f"CP#{insn.index} expected InterfaceMethodrefInfo, got "
+                    f"{invoke_interface_entry_type.__name__}",
                     loc,
                 )
 
         elif isinstance(insn, InvokeDynamic):
-            entry = _cp_entry(cp, insn.index)
-            if entry is None:
+            invoke_dynamic_entry = _cp_entry(cp, insn.index)
+            if invoke_dynamic_entry is None:
                 dc.add(
                     Severity.ERROR,
                     Category.CODE,
                     f"INVOKEDYNAMIC references invalid CP index {insn.index}",
                     loc,
                 )
-            elif not isinstance(entry, InvokeDynamicInfo):
+            else:
+                invoke_dynamic_entry_type = type(invoke_dynamic_entry)
+                if isinstance(invoke_dynamic_entry, InvokeDynamicInfo):
+                    continue
                 dc.add(
                     Severity.ERROR,
                     Category.CODE,
-                    f"INVOKEDYNAMIC CP#{insn.index} expected InvokeDynamicInfo, got {type(entry).__name__}",
+                    f"INVOKEDYNAMIC CP#{insn.index} expected InvokeDynamicInfo, "
+                    f"got {invoke_dynamic_entry_type.__name__}",
                     loc,
                 )
 
         elif isinstance(insn, MultiANewArray):
-            entry = _cp_entry(cp, insn.index)
-            if entry is None:
+            multi_anew_array_entry = _cp_entry(cp, insn.index)
+            if multi_anew_array_entry is None:
                 dc.add(
                     Severity.ERROR,
                     Category.CODE,
                     f"MULTIANEWARRAY references invalid CP index {insn.index}",
                     loc,
                 )
-            elif not isinstance(entry, ClassInfo):
-                dc.add(
-                    Severity.ERROR,
-                    Category.CODE,
-                    f"MULTIANEWARRAY CP#{insn.index} expected ClassInfo, got {type(entry).__name__}",
-                    loc,
-                )
+            else:
+                multi_anew_array_entry_type = type(multi_anew_array_entry)
+                if not isinstance(multi_anew_array_entry, ClassInfo):
+                    dc.add(
+                        Severity.ERROR,
+                        Category.CODE,
+                        f"MULTIANEWARRAY CP#{insn.index} expected ClassInfo, "
+                        f"got {multi_anew_array_entry_type.__name__}",
+                        loc,
+                    )
             if insn.dimensions < 1:
                 dc.add(
                     Severity.ERROR,
@@ -1115,6 +1128,7 @@ def _verify_code_cp_refs(
 
 def _verify_ldc_entry(entry: ConstantPoolInfo, idx: int, major: int, loc: Location, dc: _Collector) -> None:
     """Validate that an LDC/LDC_W entry is a valid loadable type."""
+    entry_type = type(entry)
     if isinstance(entry, (IntegerInfo, FloatInfo, StringInfo)):
         return
     if isinstance(entry, ClassInfo):
@@ -1131,7 +1145,7 @@ def _verify_ldc_entry(entry: ConstantPoolInfo, idx: int, major: int, loc: Locati
             dc.add(
                 Severity.ERROR,
                 Category.CODE,
-                f"LDC CP#{idx} {type(entry).__name__} requires version >= 51, got {major}",
+                f"LDC CP#{idx} {entry_type.__name__} requires version >= 51, got {major}",
                 loc,
             )
         return
@@ -1147,7 +1161,7 @@ def _verify_ldc_entry(entry: ConstantPoolInfo, idx: int, major: int, loc: Locati
     dc.add(
         Severity.ERROR,
         Category.CODE,
-        f"LDC CP#{idx} has non-loadable type {type(entry).__name__}",
+        f"LDC CP#{idx} has non-loadable type {entry_type.__name__}",
         loc,
     )
 

pytecode-0.0.1/pytecode/jar.py → pytecode-0.0.3/pytecode/archive/__init__.py

@@ -9,11 +9,11 @@ import zipfile
 from dataclasses import dataclass
 from pathlib import Path, PurePosixPath
 
-from .class_reader import ClassReader
-from .debug_info import DebugInfoPolicy, normalize_debug_info_policy
-from .hierarchy import ClassResolver
-from .model import ClassModel
-from .transforms import ClassTransform
+from ..analysis.hierarchy import ClassResolver
+from ..classfile.reader import ClassReader
+from ..edit.debug_info import DebugInfoPolicy, normalize_debug_info_policy
+from ..edit.model import ClassModel
+from ..transforms import ClassTransform
 
 __all__ = ["JarFile", "JarInfo"]
 

pytecode-0.0.3/pytecode/classfile/__init__.py

@@ -0,0 +1,14 @@
+"""Parsed JVM classfile structures, parsing, and emission."""
+
+from .info import ClassFile, FieldInfo, MethodInfo
+from .reader import ClassReader, MalformedClassException
+from .writer import ClassWriter
+
+__all__ = [
+    "ClassFile",
+    "ClassReader",
+    "ClassWriter",
+    "FieldInfo",
+    "MalformedClassException",
+    "MethodInfo",
+]