demangle 0.5.2__tar.gz → 0.7.0__tar.gz

{demangle-0.5.2 → demangle-0.7.0}/.gitignore

@@ -19,3 +19,6 @@ tools/swift-demangle-reference/swift/
 tools/swift-demangle-reference/build/
 tools/cplus-dem-reference/gcc/
 tools/cplus-dem-reference/build/
+.agents/
+docs/assets/demangle.zip
+playground/assets/

{demangle-0.5.2 → demangle-0.7.0}/ARCHITECTURE.md

@@ -169,7 +169,9 @@ scheme with a fixed first character declares it (`first_characters`), and a name
 starting with anything else never reaches it. A scheme whose names are ordinary C
 identifiers has none, so it declares a `DETECT_SCREEN`: the markers and openings that a
 name must hold for its `detect` to say yes, and a name with none of them is not offered
-to it. The schemes whose names carry no marker at all -- Ada and the two pre-Itanium
+to it. Both can apply: Nim and Free Pascal names are identifiers, so they also declare
+the letters and `_` as first characters, which keeps them off MSVC's `?` and Swift's
+`$s` names even though those hold the `__` and `$` they screen on. The schemes whose names carry no marker at all -- Ada and the two pre-Itanium
 C++ manglings, whose `detect` has to parse -- are offered last, behind everything a
 prefix settles.
 

{demangle-0.5.2 → demangle-0.7.0}/CHANGELOG.md

@@ -8,6 +8,130 @@ the reference demanglers, and a **Performance** section.
 
 ## [Unreleased]
 
+## [0.7.0] - 2026-11-12
+
+### Fixed
+
+- **The IDA, Binary Ninja and Ghidra scripts read Mach-O names without their leading
+  underscore.** Mach-O puts one underscore in front of every symbol, and the tools keep
+  it, so Nim's `_area__mymod_u10` came out as `mymod._area`, JNI's `_Java_...` was not
+  read, and Free Pascal, Ada and GCC 2 names were read with the underscore as part of the
+  name. On a Mach-O file a name is now read without it, except where C++, Swift, Rust, D
+  or Objective-C reads it as it stands (`__Z`, `_$s`, `__D`, ...), which those schemes do
+  already and which keeps Apple's C++ rules. `demangle_labels.Options` has a
+  `leading_underscore` field for it, and each script a `LEADING_UNDERSCORE` setting that
+  overrides the file type. Checked in IDA 9.5, Binary Ninja 6.0 and Ghidra 12.2 on a
+  Mach-O arm64 dylib.
+- **The Binary Ninja plugin leaves alone an address holding several user symbols.**
+  Binary Ninja's DWARF import defines a user symbol for each function the linker
+  discarded, all at the image base beside `__elf_header`. With
+  `ONLY_LEFT_MANGLED = False` on a Rust program the plugin relabelled one of them, which
+  dropped `__elf_header`, and Undo did not bring it back. Such an address is now skipped
+  and counted in the summary line. Found running the plugin live in Binary Ninja 6.0 on
+  Linux; the IDA script was run live in IDA 9.5, through idalib and `idat -S`, with
+  nothing to fix. Both were then run from their windows, the Plugins menu of Binary Ninja
+  6.0.10905 and File > Script file in IDA 9.5, with Cancel, Undo and Redo behaving as
+  documented.
+- **An MSVC name holding `_$$_` or a `/` is no longer read as Free Pascal or Go.**
+  `?A_$$_B@@3HA` read as a Free Pascal routine `B@@3HA` in a unit `?A`, where it is
+  MSVC's `int A_$$_B`, and an MSVC string literal with a `/` in it was claimed by Go and
+  left as it was. Neither scheme writes a name opening `?`.
+- **Swift follows upstream's renames (weekly drift report #70).** The called-once
+  function conventions are `@once` (`XO`) and `@callable(once)` (`XOo`), where they were
+  `@called(exactlyOnce)` and `@called(atMostOnce)`, and `Twa` after a type metadata
+  accessor reads as `back deployment copy of type metadata accessor for ...`, where it
+  was refused. The Swift reference build moves to swiftlang/swift `main` @ `4f010677`
+  (2026-11-12), which reproduces the corpora: 531 / 531, 217 / 217, 71 / 71. Rust's
+  `#[rustc_splat]` is not followed yet: it is on rustc-demangle's `main` only, and the
+  released 0.1.28 that the reference builds still prints `#[splat]`.
+- **MSVC: a conversion operator used as an alias template's argument is declined
+  cleanly.** `?f@@YAXV?$A@$$Y?$?BH@@@@V?$A@$$Y?$?BH@@@@@Z` failed on an internal
+  `ValueError`, because the placeholder for a conversion operator's name and the mark
+  for a function type's calling convention shared a delimiter. They are now distinct,
+  and the name is refused as `llvm-undname` refuses it.
+- **Swift reads a propagated `@differentiable` function argument.** A function
+  signature specialization parameter `a` (`...Tf1na_n`) carries the original function
+  and its JVP and VJP, each as a name and a type, and prints as `[Differentiable
+  Function Propagated, Components : [...]]`; it was refused. That was the last vector of
+  the drift report this library did not read. `swift-upstream.txt` now holds it and the
+  three `Twa` rows: 535 / 535 against the reference build at `4f010677`.
+- Playground navigation, presets, and cards share centered page gutters and a bounded
+  content width. Inner padding, control sizing, and responsive option rows stay aligned
+  on desktop, narrow screens, and with enlarged text; overflow is contained locally.
+- Release recovery resumes publishing when a tag and release already exist. Active
+  or successful publishing runs are preserved; failed runs retry only failed jobs.
+- Playground theme settings no longer prevent startup when browser storage is blocked.
+  The theme toggle follows the system preference until the user selects a theme.
+- Automatic and manual release runs require successful push CI for the commit being tagged.
+
+### Added
+
+- Playground batch results preserve line order and blank lines, show individual errors,
+  cache duplicate symbols, and support copying or downloading the selected output view.
+- Share links restore batch mode and validate options, with a size limit and explicit
+  clipboard feedback. Result states distinguish unrecognized, invalid, and unchanged
+  symbols; keyboard focus and live announcements cover batch controls and results.
+- A release-preparation command updates package and citation versions, release notes,
+  and comparison links together, with metadata checks and rollback on failure.
+- Browser checks for theme persistence, keyboard shortcuts, and stalled-worker recovery.
+- IDA Pro, Binary Ninja and Ghidra scripts that label the symbols each tool leaves
+  mangled, in `integrations/`, with a "Disassembler integrations" page. They stay out of
+  the wheel.
+- `benchmarks/compare.py` and a "Comparison with other demanglers" page that measure this
+  package against LLVM's demangler, `cpp-demangle`, `itanium_demangler` and the `c++filt`
+  tools on the same names.
+- The weekly upstream drift job also reads every checked-in corpus with the newest LLVM,
+  through `llvm-demangle-fxti` pinned by hash, in a job that holds no token
+  (`tools/llvm_oracle.py`; `tools/upstream_drift.py --source llvm-*`, `--llvm-version`,
+  `--require-llvm` and `--no-llvm`).
+
+### Changed
+
+- An MSVC name nested deep enough to reach Python's own recursion limit before
+  `max_depth` can now be read, where 0.6.0 reported `LimitExceeded`. `max_depth` itself is
+  unchanged.
+
+### Performance
+
+- MSVC names read about 7% faster cold, Swift names about 5% and Delphi names about
+  12%. Go, Nim and Free Pascal are asked about a name before these schemes, and the
+  `$`, `__` and `/` they look for are in most such names. Nim and Free Pascal names
+  open with a letter or `_`, which both now declare as their first characters, and Go's
+  `detect` turns away a name opening `?` or `$` before looking for a path: no import
+  path holds either, and Go's own `$` constants were never claimed. Output over every
+  corpus is unchanged.
+- Swift names read about 1.3 times as fast cold: identifiers are split into words only
+  when a substitution needs them, and the commonest parser and printer steps make about
+  40% fewer calls.
+- Template-heavy MSVC names read about 1.5 times as fast cold: each template
+  instantiation is read once per name, and the control-character scan runs once.
+
+## [0.6.0] - 2026-10-11
+
+### Fixed
+
+- Preserve playground input and selected settings while its runtime loads. Scheme
+  selectors and output controls stay inside their columns on narrow screens and with
+  enlarged text. AST references reveal collapsed ancestors and support keyboard use.
+
+### Added
+
+- MSVC C++20 three-way comparison (`operator<=>`) and ARM64e pointer authentication
+  qualifiers, including their structured AST representation.
+- Swift inverse conformance to `~Deinitable`, with module-name display options respected.
+- A standalone browser playground with theme switching and keyboard shortcuts.
+- Shareable playground links and the loaded library version, runtime retry controls,
+  and browser regression tests including a real Pyodide smoke test in CI.
+- Bounded Swift and cross-scheme signature benchmarks with successful-work checks.
+
+### Performance
+
+- Run playground parsing in a worker and derive signature and AST data from one parse.
+  Output view changes reuse the result; AST expansion is lazy and paged with a display
+  budget while raw JSON remains complete.
+- Deliver a deterministic, zipimportable source archive instead of a synthetic wheel
+  and duplicate base64 bundle.
+
 ## [0.5.2] - 2026-10-10
 
 ### Fixed
@@ -4037,7 +4161,9 @@ substitution table contents, pinned by name.
   faster by doing less work.
 - API reference published from docstrings at <https://r0ny123.github.io/demangle/>.
 
-[Unreleased]: https://github.com/r0ny123/demangle/compare/v0.5.2...HEAD
+[Unreleased]: https://github.com/r0ny123/demangle/compare/v0.7.0...HEAD
+[0.7.0]: https://github.com/r0ny123/demangle/compare/v0.6.0...v0.7.0
+[0.6.0]: https://github.com/r0ny123/demangle/compare/v0.5.2...v0.6.0
 [0.5.2]: https://github.com/r0ny123/demangle/compare/v0.5.1...v0.5.2
 [0.5.1]: https://github.com/r0ny123/demangle/compare/v0.5.0...v0.5.1
 [0.5.0]: https://github.com/r0ny123/demangle/compare/v0.4.0...v0.5.0

{demangle-0.5.2 → demangle-0.7.0}/CITATION.cff

@@ -5,4 +5,4 @@ authors:
   - name: demangle contributors
 license: MIT
 repository-code: "https://github.com/r0ny123/demangle"
-version: "0.5.2"
+version: "0.7.0"

{demangle-0.5.2 → demangle-0.7.0}/CONFORMANCE.md

@@ -37,7 +37,7 @@ Replayed by the test suite. No compiler and no reference demangler needed.
 | Bare `<type>` encodings, llvm style | `llvm-cxxfilt --types` 18.1.3 | **1076 / 1076** |
 | Bare `<type>` encodings, gnu style | GNU `c++filt -t` 2.42 | **1076 / 1076** <sup>[3](#3-bare-types-under-both-references)</sup> |
 | Swift runtime + the compiler's own test corpus | `swift-demangle`, built from source <sup>[6](#6-the-swift-reference-is-built-here)</sup> | **8494 / 8494** |
-| Swift — the compiler's own demangler vectors | `swift-demangle`, built from source <sup>[6](#6-the-swift-reference-is-built-here)</sup> | **531 / 531** |
+| Swift — the compiler's own demangler vectors | `swift-demangle`, built from source <sup>[6](#6-the-swift-reference-is-built-here)</sup> | **535 / 535** |
 | Nim 1.6 and 2.2, against the compiler's own record <sup>[14](#14-nim)</sup> | `.ndi` debug mapping | **2115 / 2115** |
 | Free Pascal 3.2.2 runtime and packages <sup>[5](#5-free-pascal)</sup> | re-assembly + `ppudump` | **3899 / 3899** |
 | Go, from the shipped toolchain | round trip <sup>[16](#16-go)</sup> | **1517 / 1517** |

{demangle-0.5.2 → demangle-0.7.0}/CONTRIBUTING.md

@@ -40,7 +40,35 @@ Development requirements are [dependency groups](https://peps.python.org/pep-073
 not extras. An extra is a *published* feature of the distribution -- `pip install
 demangle[dev]` would appear on PyPI as something users are invited to install -- and a
 linter is not a feature of a demangler. The groups are `test`, `format`, `lint`, `docs`,
-and `dev`, which includes the first three.
+`browser`, and `dev`, which includes the first three.
+
+The browser suite is opt-in: it needs the browser dependency group, a built docs site,
+and Chromium. It uses a deterministic fake worker for UI regressions; the real Pyodide
+CDN smoke test is separately opt-in.
+
+```console
+uv pip install -e . --group browser --group docs --group test
+python -m playwright install chromium
+mkdocs build --strict
+DEMANGLE_BROWSER_TESTS=1 python -m pytest -q tests/browser/test_playground_browser.py
+
+# Also exercise Pyodide from its CDN, as the browser CI job does.
+DEMANGLE_BROWSER_TESTS=1 DEMANGLE_PYODIDE_SMOKE=1 \
+  python -m pytest -q tests/browser/test_playground_browser.py
+```
+
+So is the Ghidra test, which runs `integrations/demangle_ghidra.py` in a real headless
+Ghidra: it compiles a small C++ program, imports it with analysis off, runs the script
+twice, and checks the symbol table after each run. It needs Ghidra 11.3 or later with a
+JDK it runs on, the `pyghidra` package for that Ghidra in the same environment as
+`demangle`, and `g++`, `c++` or `clang++` on PATH; without any of them, or without both
+variables below, it is skipped.
+
+```console
+pip install pyghidra
+GHIDRA_INSTALL_DIR=/path/to/ghidra DEMANGLE_GHIDRA_TESTS=1 \
+  python -m pytest -q tests/test_integrations_ghidra_live.py
+```
 
 The toolchain is deliberately the fast one: **ruff** for linting and formatting (it
 replaces black, isort, flake8 and pyupgrade), **ty** for type checking (it replaces
@@ -152,6 +180,23 @@ it accepts -- has been through `tools/enumerate.py`, `tools/mutate.py` and
 has why, what each asks, and how to build the references for Rust, Swift and
 pre-Itanium C++ that no distribution ships.
 
+## Preparing a release
+
+After the Unreleased section has notes ready to publish, prepare the release metadata with
+its stable semantic version. The command defaults the date to today; pass `--date` for a
+specific `YYYY-MM-DD` date. It updates the package and citation versions, moves the notes
+under the dated changelog heading, refreshes comparison links, then runs the documentation
+metadata checks. If those checks fail, it restores the original files. Commit and push
+that change to `main`; `tag-release.yml` creates the tag and release only after push CI
+passes for that exact commit. It then starts the PyPI publishing workflow. If starting
+publishing fails, rerun the tag-release job: an existing release no longer stops recovery.
+Active or successful publishing runs are left alone; failed runs retry only failed jobs.
+Cancelled runs require an explicit manual restart.
+
+```console
+python tools/prepare_release.py 0.7.0 --date 2026-10-12
+```
+
 ## How changes get merged
 
 Leave `CHANGELOG.md` alone: the maintainer writes the entry when merging. A first-time
@@ -163,13 +208,15 @@ while before any checks appear. The easiest first contribution is a
 ## CI and workflows
 
 Workflows run with `permissions: contents: read` and grant more only where a job needs
-it: the weekly `upstream.yml` has `issues: write`, because its one job files the issue
-that says a reference's vectors moved ahead of a scheme. Checkout uses
+it: the weekly `upstream.yml` gives `issues: write` to its `drift` job alone, because that
+job files the issue that says a reference's vectors moved ahead of a scheme; its `llvm`
+job, which runs a third party's native wheel, has `contents: read` and no secret, and its
+wheel is pinned by hash. Checkout uses
 `persist-credentials: false`, because nothing in CI pushes and a token left in
-`.git/config` is readable by every later step. A release is cut by `tag-release.yml`
-when `__version__` changes on `main`, through the API with `contents: write` and
-`actions: write` on that one job; it starts `release.yml`, which publishes through PyPI
-Trusted Publishing, so there is no long-lived API token in repository secrets. The
+`.git/config` is readable by every later step. `tag-release.yml` cuts a release after
+push CI succeeds on `main` for the exact commit, through the API with `contents: write`
+and `actions: write` on that one job; it starts `release.yml`, which publishes through
+PyPI Trusted Publishing, so there is no long-lived API token in repository secrets. The
 `pypi` environment still waits for a maintainer to approve.
 
 The test matrix is deliberately not a cross product. Every supported version runs on

{demangle-0.5.2 → demangle-0.7.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: demangle
-Version: 0.5.2
+Version: 0.7.0
 Summary: Read mangled symbol names -- Itanium C++, MSVC, Rust, Swift, Objective-C, Go, D, Nim, Free Pascal, Delphi, Ada/GNAT, JNI and pre-Itanium C++ (g++ 2.x, cfront/ARM, Lucid, HP aCC, CodeWarrior) -- in pure Python, with no dependencies.
 Project-URL: Homepage, https://github.com/r0ny123/demangle
 Project-URL: Documentation, https://r0ny123.github.io/demangle/
@@ -37,6 +37,7 @@ Description-Content-Type: text/markdown
 [![Python](https://img.shields.io/badge/python-3.11%2B-blue)](https://www.python.org/downloads/)
 [![Licence](https://img.shields.io/badge/licence-MIT-green)](https://github.com/r0ny123/demangle/blob/main/LICENSE)
 [![Docs](https://img.shields.io/badge/docs-r0ny123.github.io-blue)](https://r0ny123.github.io/demangle/)
+[![Open Playground](https://img.shields.io/badge/Open%20Playground-r0ny123.github.io-2ea44f?logo=googlechrome&logoColor=white)](https://r0ny123.github.io/demangle/playground/)
 
 **Read mangled symbol names in pure Python** — Itanium C++ (GCC/Clang), MSVC, Rust,
 Swift, Objective-C, Go, D, Nim, Free Pascal, Delphi, Ada/GNAT, JNI, and the pre-Itanium
@@ -89,7 +90,8 @@ pip install demangle
 Python 3.11 or newer, on CPython or PyPy. That is the whole dependency list.
 
 The documentation, API reference included, is published at
-<https://r0ny123.github.io/demangle/>.
+<https://r0ny123.github.io/demangle/>. An interactive in-browser playground is available
+at <https://r0ny123.github.io/demangle/playground/>.
 
 ## Use
 
@@ -320,6 +322,9 @@ Swift's own 217 vectors:
 ```console
 $ nm -a libfoo.so | demangle
 $ demangle _ZNSt6vectorIiSaIiEE9push_backERKi
+$ demangle -b _ZN3foo3barEv                         # `mangled ==> demangled`
+$ demangle -m _ZN3foo3barEv                         # only print successfully demangled symbols
+$ demangle -s gnu _ZNSt6vectorIiSaIiEE9push_backERKi # choose output style (llvm, gnu)
 $ demangle --tree _Z1fPKc
 $ demangle --detect _RNvC6_123foo3bar
 $ demangle --detect --strict _ZN3Foo               # the scheme that reads it, or an error
@@ -338,6 +343,7 @@ $ demangle --json _Z1fPi                           # the parse tree as JSON
 $ nm -a libfoo.so | demangle --json-lines          # a JSON object per symbol
 $ demangle --json-lines --signature _Z1fPi         # ... with the parts of the name
 $ printf '%s\0' "$name" | demangle -0              # whole names ended by NUL, in and out
+$ demangle --list-languages                        # list supported schemes and aliases
 ```
 
 `--json-lines` writes one object per name, `{"mangled": ..., "demangled": ...,
@@ -396,6 +402,15 @@ Taken from `benchmarks/baseline.json`; treat them as ratios rather than absolute
 gap between cold and warm is the point: symbol tables repeat themselves relentlessly, and
 results are cached.
 
+On names it has not seen, a native demangler is faster than this one by an order of
+magnitude or more: LLVM's, through its Python binding `llvm-demangle-fxti`, reads the
+Itanium names libstdc++ exports about 50 times as fast as this package does cold. This
+package is fast enough in practice because a symbol table repeats its names, and a name
+read once costs a dictionary lookup afterwards. [Comparison with other
+demanglers](https://r0ny123.github.io/demangle/comparison/) has the measurements against it
+and other tools, what each one covers, and what this one offers instead;
+`benchmarks/compare.py` reproduces them.
+
 `bench.py --check` gates CI against the committed baseline. It compares figures
 normalised against a calibration workload measured in the same run, so the gate reports
 a slower *demangler* rather than a slower *machine*.

{demangle-0.5.2 → demangle-0.7.0}/README.md

@@ -4,6 +4,7 @@
 [![Python](https://img.shields.io/badge/python-3.11%2B-blue)](https://www.python.org/downloads/)
 [![Licence](https://img.shields.io/badge/licence-MIT-green)](https://github.com/r0ny123/demangle/blob/main/LICENSE)
 [![Docs](https://img.shields.io/badge/docs-r0ny123.github.io-blue)](https://r0ny123.github.io/demangle/)
+[![Open Playground](https://img.shields.io/badge/Open%20Playground-r0ny123.github.io-2ea44f?logo=googlechrome&logoColor=white)](https://r0ny123.github.io/demangle/playground/)
 
 **Read mangled symbol names in pure Python** — Itanium C++ (GCC/Clang), MSVC, Rust,
 Swift, Objective-C, Go, D, Nim, Free Pascal, Delphi, Ada/GNAT, JNI, and the pre-Itanium
@@ -56,7 +57,8 @@ pip install demangle
 Python 3.11 or newer, on CPython or PyPy. That is the whole dependency list.
 
 The documentation, API reference included, is published at
-<https://r0ny123.github.io/demangle/>.
+<https://r0ny123.github.io/demangle/>. An interactive in-browser playground is available
+at <https://r0ny123.github.io/demangle/playground/>.
 
 ## Use
 
@@ -287,6 +289,9 @@ Swift's own 217 vectors:
 ```console
 $ nm -a libfoo.so | demangle
 $ demangle _ZNSt6vectorIiSaIiEE9push_backERKi
+$ demangle -b _ZN3foo3barEv                         # `mangled ==> demangled`
+$ demangle -m _ZN3foo3barEv                         # only print successfully demangled symbols
+$ demangle -s gnu _ZNSt6vectorIiSaIiEE9push_backERKi # choose output style (llvm, gnu)
 $ demangle --tree _Z1fPKc
 $ demangle --detect _RNvC6_123foo3bar
 $ demangle --detect --strict _ZN3Foo               # the scheme that reads it, or an error
@@ -305,6 +310,7 @@ $ demangle --json _Z1fPi                           # the parse tree as JSON
 $ nm -a libfoo.so | demangle --json-lines          # a JSON object per symbol
 $ demangle --json-lines --signature _Z1fPi         # ... with the parts of the name
 $ printf '%s\0' "$name" | demangle -0              # whole names ended by NUL, in and out
+$ demangle --list-languages                        # list supported schemes and aliases
 ```
 
 `--json-lines` writes one object per name, `{"mangled": ..., "demangled": ...,
@@ -363,6 +369,15 @@ Taken from `benchmarks/baseline.json`; treat them as ratios rather than absolute
 gap between cold and warm is the point: symbol tables repeat themselves relentlessly, and
 results are cached.
 
+On names it has not seen, a native demangler is faster than this one by an order of
+magnitude or more: LLVM's, through its Python binding `llvm-demangle-fxti`, reads the
+Itanium names libstdc++ exports about 50 times as fast as this package does cold. This
+package is fast enough in practice because a symbol table repeats its names, and a name
+read once costs a dictionary lookup afterwards. [Comparison with other
+demanglers](https://r0ny123.github.io/demangle/comparison/) has the measurements against it
+and other tools, what each one covers, and what this one offers instead;
+`benchmarks/compare.py` reproduces them.
+
 `bench.py --check` gates CI against the committed baseline. It compares figures
 normalised against a calibration workload measured in the same run, so the gate reports
 a slower *demangler* rather than a slower *machine*.

{demangle-0.5.2 → demangle-0.7.0}/SECURITY.md

@@ -91,8 +91,8 @@ name that caused it rather than being killed.
 
 | Version | Supported |
 | --- | --- |
-| 0.3.x | yes |
-| < 0.3 | no |
+| 0.7.x | yes |
+| < 0.7 | no |
 
 Until 1.0, security fixes land on the latest released minor version only. There is no
 long-term support branch and no backporting; upgrading to the current minor version is

demangle-0.7.0/benchmarks/audit_signature.py

@@ -0,0 +1,106 @@
+"""Paired signature audit using the same parser and corpus in both versions.
+
+Uses the source-module comparison protocol of audit_api.py/audit_core.py. Alternating
+trials reduce process/runner drift; full field parity gates every retained result.
+"""
+
+import argparse
+import dataclasses
+import gc
+import json
+import statistics
+import subprocess
+import sys
+import time
+import tracemalloc
+import types
+from pathlib import Path
+
+import bench
+
+from demangle import _signature
+from demangle.core.ast import Function, Name, Pointer
+
+
+def main():
+    parser = argparse.ArgumentParser(description=__doc__)
+    parser.add_argument("--before", default="03bd234e6684a7b42672bd962da3f21cfa3e1adb")
+    parser.add_argument("--trials", type=int, default=9)
+    parser.add_argument("--output", type=Path, required=True)
+    args = parser.parse_args()
+    if args.trials < 3:
+        parser.error("at least three trials are required")
+    source = subprocess.check_output(
+        ["git", "show", f"{args.before}:src/demangle/_signature.py"], cwd=bench.ROOT, text=True
+    )
+    old = types.ModuleType("demangle._signature")
+    old.__package__ = "demangle"
+    exec(compile(source, "baseline_signature.py", "exec"), old.__dict__)
+    groups = {
+        language: [(language, name) for name in bench.corpus_sample(corpus, 256)]
+        for language, corpus in (
+            ("itanium", "itanium-real-world.txt"),
+            ("msvc", "msvc-llvm-corpus.txt"),
+            ("rust", "rust-real-world.txt"),
+            ("go", "go-real-world.txt"),
+            ("swift", "swift-real-world.txt"),
+        )
+    }
+    groups["mixed"] = [item for group in groups.values() for item in group]
+    results = {}
+    for group, inputs in groups.items():
+        assert [dataclasses.asdict(old.signature(name, language=language)) for language, name in inputs] == [
+            dataclasses.asdict(_signature.signature(name, language=language)) for language, name in inputs
+        ], group
+        samples = {"before": [], "after": []}
+        functions = [("before", old.signature), ("after", _signature.signature)]
+        for trial in range(args.trials):
+            for label, function in functions if trial % 2 else reversed(functions):
+                gc.collect()
+                start = time.perf_counter()
+                for language, name in inputs:
+                    function(name, language=language)
+                samples[label].append((time.perf_counter() - start) * 1000)
+        medians = {label: statistics.median(values) for label, values in samples.items()}
+        results[group] = {
+            "names": len(inputs),
+            "samples_ms": samples,
+            "medians_ms": medians,
+            "change_percent": 100 * (medians["after"] / medians["before"] - 1),
+        }
+    graphs = {}
+    for depth in (40, 120, 400):
+        parameter = Name("item")
+        for _ in range(depth):
+            parameter = Pointer(parameter)
+        tree = Function(None, (parameter,) * 32, name=Name("f"))
+        peaks = {}
+        fields = []
+        for label, module in (("before", old), ("after", _signature)):
+            gc.collect()
+            tracemalloc.start()
+            result = module._extract(module._Reading("itanium", "::", "gnu"), tree)
+            peaks[label] = tracemalloc.get_traced_memory()[1]
+            tracemalloc.stop()
+            fields.append(dataclasses.asdict(result))
+        assert fields[0] == fields[1], depth
+        graphs[depth] = {"shared_parameters": 32, "peak_bytes": peaks}
+    args.output.write_text(
+        json.dumps(
+            {
+                "baseline": args.before,
+                "python": sys.version,
+                "trials": args.trials,
+                "shared_current_parsers": True,
+                "groups": results,
+                "constructed_graphs": graphs,
+            },
+            indent=2,
+        )
+        + "\n"
+    )
+    print(args.output)
+
+
+if __name__ == "__main__":
+    main()

demangle-0.7.0/benchmarks/baseline.json

@@ -0,0 +1,68 @@
+{
+  "cold": {
+    "names": 14101,
+    "seconds": 0.648513,
+    "per_second": 21744,
+    "microseconds_each": 45.991,
+    "normalised": 1329.407,
+    "relative_to_pivot": 123.19
+  },
+  "warm": {
+    "names": 42303,
+    "seconds": 0.015793,
+    "per_second": 2678592,
+    "microseconds_each": 0.373,
+    "normalised": 10.792
+  },
+  "negative": {
+    "names": 14101,
+    "seconds": 0.011647,
+    "per_second": 1210698,
+    "microseconds_each": 0.826,
+    "normalised": 23.876,
+    "relative_to_pivot": 2.2124
+  },
+  "structured": {
+    "names": 636,
+    "seconds": 0.035171,
+    "per_second": 18083,
+    "microseconds_each": 55.3,
+    "parsed": 636,
+    "normalised": 1598.062,
+    "relative_to_pivot": 148.0849
+  },
+  "calibration": {
+    "seconds": 0.034605,
+    "rounds": 200000
+  },
+  "swift": {
+    "names": 256,
+    "seconds": 0.0181,
+    "per_second": 14174,
+    "microseconds_each": 70.55,
+    "succeeded": 256,
+    "normalised": 2303.46,
+    "relative_to_pivot": 336.776,
+    "recorded_on": "GitHub Actions ubuntu-24.04, CPython 3.13.16; run 38108232827"
+  },
+  "swift_parse": {
+    "names": 256,
+    "seconds": 0.0213,
+    "per_second": 12046,
+    "microseconds_each": 83.02,
+    "succeeded": 256,
+    "normalised": 2710.43,
+    "relative_to_pivot": 396.277,
+    "recorded_on": "GitHub Actions ubuntu-24.04, CPython 3.13.16; run 38108232827"
+  },
+  "signature": {
+    "names": 1280,
+    "seconds": 0.0963,
+    "per_second": 13289,
+    "microseconds_each": 75.25,
+    "succeeded": 1280,
+    "normalised": 2456.81,
+    "relative_to_pivot": 359.197,
+    "recorded_on": "GitHub Actions ubuntu-24.04, CPython 3.13.16; run 38108232827"
+  }
+}